DEV Community: mrityunjay saraf

♨️ Mastering Java Concurrency: Dive into Part 2!

mrityunjay saraf — Sun, 07 Apr 2024 09:53:17 +0000

👋 Hi Developer! Welcome to part 2 of the Mastering Concurrency in Java series! In this blog, we'll explore some advanced multithreading topics like Reentrant Locks, Semaphores, and CountDown Latches.

We have covered the basic topics in part 1, so be sure to check them out if you haven't already. Let's dive in and explore these concepts in depth! 🚀

📌 Table of Contents

🔒Reentrant Lock
⏳Introduction to CountDownLatch
🚪What are Semaphores

🔒 Reentrant Lock

It is the alternative to using the synchronized keyword.
Re-entrant Lock as the name suggests can be re-acquired (lock) again N number of times by the same thread.
It has to call unlock the same number of times to completely release the lock.
Only one thread can lock a lock at any given time.

📝 Example:



import java.util.Scanner;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Runner {

    private int count = 0;
    private Lock lock =new ReentrantLock();

    private void increment() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

    public void firstThread() throws InterruptedException {
        lock.lock();
        try {
            increment();
        } finally {
            lock.unlock();
        }
    }

    public void secondThread() throws InterruptedException {
        lock.lock();
        try {
            increment();
        } finally {
           lock.unlock();

        }
    }

    public void finished() {
        System.out.println("Count is: " + count);
    }
}

I'll run these 2 methods from 2 different thread and check for the total count;



public class App {

    public static void main(String[] args) throws Exception {
        final Runner runner = new Runner();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                try {
                    runner.firstThread();
                } catch (InterruptedException ignored) {
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    runner.secondThread();
                } catch (InterruptedException ignored) {
                }
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        runner.finished();
    }

}

Result



Count is: 20000

⌛Introduction to CountDownLatch

Sometimes we need to ensure that a certain number of tasks are completed before proceeding with other parts of our application. CountDownLatch provides a mechanism to handle such scenarios.

Initialization: When using CountDownLatch, we first initialize it with a count representing the number of tasks or threads that need to be completed before the waiting threads can proceed.
CountDown: As each task or thread completes its work, it calls the countDown() method of the CountDownLatch. This method decrements the internal count by 1.
Blocking Await: Threads that are waiting for tasks to complete call the await() method of the CountDownLatch. This method blocks the thread until all the threas complete their task ie. internal count reaches zero.
Signaling Completion: Once the internal count reaches zero, the waiting threads are unblocked, and they can proceed with their respective tasks or operations.

✍🏼Example:

We will create 5 multiple worker threads to perform tasks concurrently, and a main thread needs to wait for all tasks to complete before continuing its execution.



import java.util.concurrent.CountDownLatch;

public class Worker implements Runnable{
    private int workerNumber;
    CountDownLatch count;

    public Worker(CountDownLatch count, int workerNumber){
        this.workerNumber= workerNumber;
        this.count = count;
    }
    @Override
    public void run() {
        System.out.println("Worker " + workerNumber + " is working");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Worker " + workerNumber + " completed working");
        count.countDown();

    }
}

I'll call the Worker run method from the 5 different Threads from the main method



import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class App {
    public static void main (String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(5);
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            executor.submit(new Worker(latch,i));
        }

        latch.await();
        System.out.println("All work is completed");
        executor.shutdown();
        executor.awaitTermination(1 , TimeUnit.DAYS);

    }
}

✍🏼Explanation:

Five instances of the Worker class are created, each with a unique worker number (1, 2, 3, etc.) and a reference to the CountDownLatch.
Each worker begins its execution and simulates work by sleeping for 2 seconds.
After completing the work, each worker prints a message indicating it has finished and decreases the latch count by 1 using countDown().
The main thread waits for all workers to complete their tasks by calling latch.await().
Once all workers have finished their tasks and the latch count reaches zero, the main thread proceeds.
The main thread prints a message indicating that all workers have completed their tasks.
Finally, the executor service is shut down.

📊 This is the result:

🛑 What are Semaphores

Semaphores allow you to control how many threads can access a resource simultaneously.

It constrains access to at most N threads, to control/limit concurrent access to a shared resource.

✍️ Example:

Let's say we want to connect to a remote server that can only accept N number of connections at a time.



import java.util.concurrent.Semaphore;

public class Connection {

    public static Connection instance = new Connection();
    private int connections = 0;
    Semaphore sem = new Semaphore(10, true);

    private Connection() {

    }

    public static Connection getInstance() {
        return instance;
    }

    public void doConnect() {
        synchronized (this) {
            connections++;
            System.out.println("connection number " + connections);
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        synchronized (this) {
            connections--;
        }
    }

    public void connect() {
        try {
            sem.acquire();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        try {
            doConnect();
        } finally {
            sem.release();

        }
    }
}

I'll Call the connect method from the 200 Threads from the main Method.



import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class App {
    public static void main (String[] args) throws InterruptedException {

        ExecutorService executor = Executors.newCachedThreadPool();
        for(int i=0;i<200;i++){
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    Connection.getInstance().connect();
                }
            });
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.DAYS);
    }
}

If you see the call stack of each Thread it will be

1. Call the connect method:
2. Acquire the Semaphore permit if available.
3. connection ++ ;
4. Make Thread sleep for 2 sec.
5. Release the permit.

Now Semaphore will allow up to 10 permits at a time.

📈 Results:

Thank you for reading this blog! I hope you found it insightful and valuable in your journey to mastering concurrency in Java. 🙏

Feel free to share your thoughts in the comments below. I'm eager to learn and improve! 😊 🌟

🔥 Mastering Java Concurrency: Dive into Part 1! 🚀

mrityunjay saraf — Mon, 01 Apr 2024 11:44:09 +0000

👋 Hello there! Welcome to our Java Concurrency Series! 🚀

🚀 In this series, we'll dive into various aspects of Java concurrency, from basic to advanced topics. We'll begin by tackling fundamental concepts such as thread caching issues, basic thread synchronization, and utilizing multiple locks using synchronized code blocks. Stay tuned for an insightful journey into the world of multithreading!

🔄 Understanding Concurrency
🧵What are Threads
💾Problem with Thread Caching
🔒 Solution: Volatile Keyword
🏎️ Problem: Race Conditions
🛠️ Solution: Synchronized Keyword
🧱 Synchronize Code Blocks
🔐 Locking

🔄 Understanding Concurrency

Concurrency is where your computer can handle multiple tasks simultaneously. It involves managing the execution of multiple tasks concurrently to improve performance and responsiveness in software applications.

🧵 What are Threads

Thread is like a separate path of execution within a program. When a program is running, it can have multiple threads running concurrently, each performing its own set of instructions independently.

💾 Problem with Thread Caching

In the code below, we create the Clock class as a Runnable and run it by spawning a new Thread from the main class. Once started, the Clock class's run method will keep running the while loop. To stop this, we need to call the cancel method from the main thread, which will:

Change the isStopped value to false.
Write it in the memory.

However, the thread running the while loop may not have the updated value of isStopped and could still have a local cache of the old value of isStopped (false).



public class Main {
    public static void main(String[] args) throws InterruptedException {
        Clock clock  = new Clock();
        Thread thread = new Thread(clock);
        thread.start();
        Thread.sleep(10000);
        clock.cancel();
    }
}

class Clock implements Runnable {
    private volatile boolean isStopped = false;

    public void cancel() {
        this.isStopped = true;
    }

    public void run() {
        while (!this.isStopped) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("Tick");
        }
    }
}

🔒 Solution: Volatile Keyword

The values of the volatile variable will never be cached, and all writes and reads will be done to and from the main memory. So, the above thread running the while loop will always have the latest read value from the memory.

🏎️ Problem: Race Conditions

Let's consider the scenario where we create the Counter class and try to update the counter value from two separate threads.



public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(counter);
        Thread t2 = new Thread(counter);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("expect to be 2000 but value is : " + counter.getCounter());

    }
}


public class Counter implements Runnable{
    private int counter=0;

    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            increament();
        }
    }
    public void increament(){
        int i =counter;
        counter = i+1;
    }
    public int getCounter(){
        return this.counter;
    }
}

can you guess the output?



expect to be 2000 but value is: 1746

But why does this happen? Let's understand it:

Look at the increment method:

First, we store the value of the counter to local variable i.
Then, we increment i by 1.
Finally, we write i back to counter.

And two threads are doing this simultaneously.

🛠️ Solution: Synchronized Keyword

We can make the method synchronized so that only one thread can run the method at a time. Other threads have to wait for their turn to execute the method. This leads to consistent data.

We define a method to be synchronized using the synchronized keyword.



public class Counter implements Runnable{
    private int counter=0;

    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            increament();
        }
    }
    public synchronized void increament(){
        int i =counter;
        counter = i+1;
    }
    public int getCounter(){
        return this.counter;
    }
}

🧱 Synchronize Code Blocks

If two methods are dealing with two different variables, instead of making the entire method synchronized and locking the entire object, we can use synchronized code blocks to lock only the critical sections of each method. This approach allows us to ensure that no two threads can access the same method at the same time, providing better concurrency.



public class ExampleClass {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    private int value1 = 0;
    private int value2 = 0;

    public void incrementValue1() {
        synchronized (lock1) {
            value1++;
            System.out.println("Value 1 incremented to: " + value1);
        }
    }

    public void decrementValue2() {
        synchronized (lock2) {
            value2--;
            System.out.println("Value 2 decremented to: " + value2);
        }
    }
}

For instance, imagine we have incrementValue1() and decrementValue2() methods, each modifying separate variables value1 and value2. We have declared two private final objects lock1 and lock2. These objects are used as locks for synchronized blocks to ensure thread safety when accessing the corresponding variables. By using synchronized code blocks within each method, we can lock only the sections where the shared variables are modified, allowing concurrent access to other methods while maintaining thread safety.

🔐 Locking

Locks in concurrency are used to achieve thread-safety by enabling synchronous access to shared resources.

- Intrinsic Locks

In Java, every object has a built-in lock called the intrinsic lock. When a thread wants to access a shared object, it must first acquire this lock. This ensures that only one thread can access the object at a time. When you declare that a method as synchronized, the thread calling that method acquires the intrinsic lock for that method’s object and releases it when the method exits

For example, consider a Counter class where each thread increments a shared counter variable. In this class, the increment() method is declared as synchronized, which means only one thread can execute it at a time for a given Counter object. When a thread calls the increment() method, it automatically acquires the intrinsic lock associated with that method's object, ensuring that no other thread can modify the counter concurrently. Once the method completes its execution, the lock is released, allowing other threads to call the method.

🌟 Thank you for joining us on this Java Concurrency Series journey! 🚀 We'll delve into CountdownLatch, Callable, Futures, and Semaphores soon.

📢 We'd love your feedback to improve our content. Share your thoughts with us!

🤝 Stay connected, happy coding! 🌟

Crafting Concurrency: Building Your Own ThreadPool for Multi-Threaded Servers

mrityunjay saraf — Tue, 26 Mar 2024 16:14:02 +0000

Table of Contents 📚

🌟 Introduction
💡 The Solution
🛠️ Understanding ThreadPool
💻 Implementing the ThreadPool Class from Scratch
🌐 Implementing ThreadPool in our Web Server
📊 Result Overview

✨ Introduction

In our previous discussion on TCP server design, we explored the concept of a multi-threaded server, where each incoming request spawns a new thread. While this method initially seems intuitive, it poses challenges in terms of scalability and resource management. Imagine thousands of threads being created simultaneously to handle thousands of requests; this could easily overwhelm system resources and degrade performance.

💡The Solution

To address this issue, we introduce the concept of a ThreadPool. A ThreadPool maintains a predefined number of threads that can be reused to handle incoming requests. This approach optimizes resource usage by preventing the excessive creation of threads and effectively managing system resources.

🛠️Understanding ThreadPool

A ThreadPool essentially consists of a collection of threads waiting to execute tasks. Instead of creating a new thread for each request, tasks are submitted to the ThreadPool, where available threads pick them up for execution. Once a thread completes its task, it becomes available to handle another incoming request.

🚀 Implementing the ThreadPool Class from Scratch

Creating a ThreadPool from scratch involves defining a mechanism to manage threads and execute tasks concurrently. Here's how you can do it:

1. Define the ThreadPool Class:

ThreadPool maintain the List of task queue and Worker Threads.
The ThreadPool class consists of several components:
- Task Queue (Blocking Queue): This contains the tasks. Tasks are added to this queue, and the workers (threads) pick them up and execute them.
- List of ThreadPool Runnables: This contains the list of all available worker threads.
- isStopped Flag: This flag is used to check if the ThreadPool is currently active or stopped. When the ThreadPool is stopped, it won't accept any new tasks, but it will allow the existing tasks to finish.

Methods:

1. Constructor



   import java.util.ArrayList;
   import java.util.List;
   import java.util.concurrent.ArrayBlockingQueue;
   import java.util.concurrent.BlockingQueue;

   public class ThreadPool {
       private BlockingQueue<Runnable> taskQueue;
       private List<PoolThreadRunnable> runnables;
       private boolean isStopped;

       // Constructor for initializing the ThreadPool
       public ThreadPool(int numberOfThreads, int taskQueueSize) {
           this.taskQueue = new ArrayBlockingQueue<>(taskQueueSize);
           this.runnables = new ArrayList<>();
           this.isStopped = false;

           // Create and start threads in the pool
           for (int i = 0; i < numberOfThreads; i++) {
               PoolThreadRunnable runnable = new PoolThreadRunnable(taskQueue);
               runnables.add(runnable);
               new Thread(runnable).start();
           }
       }

2. Method to Submit a Task for Execution

This method allows users to submit a task to the ThreadPool for execution. It adds the task to the task queue for processing by the ThreadPool.



// Method to submit a task for execution in the ThreadPool
public synchronized void execute(Runnable task) {
    if (isStopped) {
        throw new IllegalStateException("ThreadPool is stopped");
    }
    taskQueue.offer(task);
}

3. Method to Stop the ThreadPool

This method stops the ThreadPool by setting the isStopped flag to true. It then stops all worker threads in the ThreadPool.



// Method to stop the ThreadPool
public synchronized void stop() {
    isStopped = true;
    for (PoolThreadRunnable runnable : runnables) {
        runnable.stop();
    }
}

4.Method to Wait Until All Tasks are Finished

This method blocks until all tasks in the task queue are finished processing. It continuously checks if the task queue is empty and sleeps for a short duration if it's not.



// Method to wait until all tasks in the queue are finished
public synchronized void waitUntilAllTasksFinished() {
    while (!taskQueue.isEmpty()) {
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

2. Define the PoolThreadRunnable Class

The PoolThreadRunnable class implements the Runnable interface and represents the worker threads in the ThreadPool. Each worker thread continuously takes tasks from the task queue and executes them.

Methods:

1. Constructor for PoolThreadRunnable

The constructor initializes a PoolThreadRunnable instance with a task queue.



public PoolThreadRunnable(BlockingQueue<Runnable> taskQueue) {
    this.taskQueue = taskQueue;
}

2. Run Method for PoolThreadRunnable

The run method is overridden from the Runnable interface. It defines the behaviour of the worker thread when it is started.



@Override
public void run() {
    currentThread = Thread.currentThread();
    while (!isStopped) {
        try {
            Runnable runnable = taskQueue.take();
            System.out.println("Starting : " + currentThread.getName());
            runnable.run();
        } catch (InterruptedException e) {
            // Handle InterruptedException
        }
    }
}

3. Stop Method for PoolThreadRunnable

The stop method is used to stop the execution of the worker thread.



public void stop() {

    isStopped = true;

    System.out.println("Stopping : " + currentThread.getName());

    this.currentThread.interrupt();

}

🌐 Implementing ThreadPool in our Web Server

In the context of our web server implementation, we'll integrate the ThreadPool to handle incoming client connections. Here's how we'll do it:

Initialization socket: Initialise the socket to listen to port 1234.
Initialization ThreadPool: Initialize the ThreadPool with a predetermined number of threads and task queue size. ex.(2,10)
Accepting Connections: Will accept the client connection.
Task Execution: When a client connects to the server, instead of creating a new thread for each connection, we'll submit the client handling task to the ThreadPool. The ThreadPool will manage the execution of tasks, ensuring that they are picked up by available threads for processing.

By implementing a ThreadPool in our web server, we balance concurrency and resource utilization, resulting in a more scalable and efficient server architecture.

📊 Result Overview

Our system handles 4 requests coming from different clients at the same time using only 2 threads. This means that each thread is responsible for handling multiple requests, showing efficient resource usage.

Response Visualization:

Here, you can see the responses our system generates for each incoming request. It gives a clear picture of how well our system handles multiple clients simultaneously.

Task-wise Thread Execution:

In the image below, you'll notice that despite there being 4 requests, only 2 threads are used to handle them. This demonstrates that our system effectively reuses threads, making the most out of limited resources.

This setup ensures that our system operates efficiently and can manage incoming requests smoothly while optimizing resource utilization.

🌟 Thank you for reading! I appreciate your time and hope you found the article helpful. 📚 I'm open to suggestions and feedback, so feel free to reach out. Let's keep exploring together! 🚀

🚀How TCP Servers Are Designed to Handle Multiple Requests

mrityunjay saraf — Fri, 22 Mar 2024 18:52:59 +0000

📚 Table of Contents

🖥️ What Is a Server?
🔄 What Is Multi-Threading?
❓ Why Do We Need a Multi-threaded Server?
🛠️ How to Design Multi-Threaded Servers?

🖥️ What Is a Server?

It is the process that listens to the TCP protocol on some port, addresses the client request, and sends the response.

🔄 What Is Multi-Threading?

Multithreading is a programming concept that allows multiple threads of execution to run concurrently within a single process.

❓ Why Do We Need a Multi-threaded Server?

Let's imagine we have a single-threaded server that will process one request at a time. Now, imagine what if millions of requests come in.

I've created a server that processes requests one after the other. Each new request waits until the previous one is completed. Take a look at the response times in different terminals:

Now, consider a multithreaded server architecture. It can handle multiple client connections simultaneously using threads. Each incoming connection gets its own thread, enabling the server to serve multiple clients at once.

In our example, all four clients receive their responses concurrently after four seconds. This demonstrates the efficiency of a multithreaded server in handling multiple requests simultaneously.

🛠️ How to Design Multi-Threaded Servers?

Step 1: Open the Socket to Listen to the Port
Create the ServerSocket object that will accept the TCP connection from port 1234.
Step 2: Accept the Client's Connection to That Port
Accept the client request using the ServerSocket.accept().
It is a blocking system call meaning it will not move further without accepting the connection.
ServerSocket.accept() will return the Socket object specific to that client connection, which will be used for reading requests and sending responses to that client.
Step 3: Create a New Thread for Each Request
Step 4: Read the Request and Send the Response
Step 5: Repeat Steps 2 to 4 an Infinite Amount of Time

Disclaimer: 🚨 This article aims to explain multithreaded servers. However, there are practical limitations to this design. Creating millions of threads to handle millions of requests can strain system resources. These issues can be addressed by using strategies such as thread pooling.

🌟 Thank you for reading! I appreciate your time and hope you found the article helpful. 📚 I'm open to suggestions and feedback, so feel free to reach out. Let's keep exploring together! 🚀

A Deep Dive into Parking Spot LLD Design

mrityunjay saraf — Fri, 18 Aug 2023 13:43:15 +0000

Greetings, dear reader! 🌟

In this blog, we're crafting functional and super-efficient parking spots. And guess what? We're diving into design patterns to make them even smarter and more effective. So reading.start()🚗💡

Responsibility

🚗 Vehicle Entry and Exit: Finding the appropriate parking spot for the vehicle and creating the ticket.

🅿️ Parking Spot Allocation: Efficiently allocate available parking spots to incoming vehicles based on factors like size, type, and user preferences.

💰 Cost Computation and Payment: Calculate parking costs based on duration and vehicle type, offering flexible payment options for users.

🏆 Parking Strategy Options: Different parking strategies (e.g., park near entrance, park near elevator) should be available to users and prioritize spot allocation based on user preferences and vehicle type.

Our Parking Model Lineup 🌟

ParkingSpot 🅿️
Vehicle 🚗
ParkingSpotManager (EntranceManager and ExitManager) 🅿️
Ticket 🎫
ParkingSpotType and VehicleType (enum) 🚗
ParkingStrategy 🚦
CostConfiguration 💸
CostComputationStrategy💰

ParkingSpot Interface 🚗🏍️

🚙 The ParkingSpotManager holds a collection of ParkingSpot catering to various Vehicle types (2-wheelers and 4-wheelers).

🛠️ To achieve this, we'll create an interface that Concrete Classes (like twoWheelerParkingSpot and FourWheelerParkingSpot) can implement.

🏁 Additionally, it employs a ParkingSpotType enumeration to categorize the types of parking spots available.

🚀 The benefit of employing this interface is that if we decide to introduce a new type of parking spot later on, we can simply create a class that adheres to the interface.

🅿️ParkingManager: Central hub for parking spot management, handling addition/removal, spot allocation, ticket creation, and price computation.

🚗EntranceManager: This manager is responsilbe for efficiently allocating parking spots to incoming vehicles based on vehicle types and parking strategies and Generating the ticket.

🚦 ExitManager: Calculate parking fees using a Cost computation strategy considering duration and spot type.

Finding the Right Spot for you Vehicle 🚗

🚀Imagine the EntranceManager as a matchmaker for vehicles.

🎯 It take two parameter: a vehicle to know vehicle type, and a ParkingStrategy to understand the user preference.

💡Using this, it finds the right parking spot and makes a ticket for that vehicle and strategy.

🚫After the successfull allocation of the spot, the spot in marked as the occupied and hence not available for the other Vehicle.

🎉 Unraveling the Magic:
You might notice our usage of

Optional<Ticket>

In essence, an Optional acts as a container that may or may not hold a ticket. Optional are used to avoid null check if object not found

🎩 Exit Manager: Calculate your Parking Fare!

🚗 When your trusty vehicle bids adieu and rolls out from the parking haven, the Exit Manager springs into action.

💰By summoning the mighty Cost Computation Strategy (including the HourlyCostComputation and DailyCostComputation) and your ride Duration ,it crafts a fair and fancy price tag🤑.

After we have combined all the stuff here is the complete Diagram.

🌟 Thanks for joining our parking adventure!😊

💬 If you enjoyed reading this blog,please take a moment to share your thoughts by leaving a review and liking it 😀

🚗 Stay tuned for our next blog, where we'll dive into an exciting coding demo of this smart parking system. Keep your engines running! 🎉

Docker 101: Understanding Images and Containers in Plain English

mrityunjay saraf — Fri, 23 Jun 2023 18:23:21 +0000

📌 Table of content

📍What is Docker

📍Advantage of Docker

📍Architecture of Docker

📍What is Image

📍What is Container

📍Docker Commands

📍Image Commands

📍Container Commands

🔎 What is Docker

Docker is an open-source platform that enables the packaging, distribution, and deployment of applications using containerization.
Docker uses an isolated environment called container on the host OS to run applications. It allows applications to use the same Linux kernel as a system on the host computer, rather than creating a whole virtual OS.
Docker works only on the Linux kernel.

✨ Advantage of Docker

👉Portability: Containers are highly portable, allowing applications to run consistently across different environments.

👉Scalability: Docker enables efficient scaling of applications by quickly creating and deploying multiple containers.

👉Isolation: Containers provide a level of isolation between applications, improving security and preventing conflicts between dependencies.

👉Efficiency: Docker's lightweight architecture and shared OS resources result in efficient resource utilization and faster application startup times.

🔑 Key concept of Docker

Containers,Images,Docker Registry is discussed soon in detail in different section of this blog.
Dockerfile: A Dockerfile is a text file that defines the instructions for building a Docker image.

Docker Engine: The Docker Engine is the runtime that enables the execution of Docker containers.

🧬 Architecture of Docker

Docker client : provide the user an interface to communicate with the docker daemon in form of commands and REST API's req.
Docker Host : It is the physical or virtual machine where the docker runtime environment is installed. It run the docker daemon (server) which listened to request from the docker client and manages the container and images.
Docker registry : A Docker registry is a central repository that stores Docker images.
- Public Registry: Access to everybody for ex : DockerHub
- Private Registry: registry accessed by any particular organisation.

📔 What is an Image

A Docker image is a blueprint for creating containers. It contains all the necessary files, dependencies, configurations, and instructions for running a specific application or service.
Each container created from an image is an instance of that image
Docker images are stored in a registry, such as Docker Hub

📦 What is the Container

👉A Docker container is a lightweight and isolated runtime instance created from a Docker image.
👉Docker containers encapsulate applications and their dependencies, providing a consistent and isolated runtime environment.
👉Docker containers are highly portable and can run consistently on different systems, such as development machines, servers, cloud platforms.
👉Docker containers can be easily scaled horizontally by running multiple instances of the same container.
👉 After the allocation of the host system resources to image container is created.

Image + Some part of your system resources (cpu,memory,storage) . = Container
Below example shows how container is made out of an image 😀

📌 Docker Commands

🚀 Image Commands

docker image pull <image-name>:<tag>:Pull an image from a registry

mrityunjay:~$ docker image pull redis:latest
latest: Pulling from library/redis
5b5fe70539cd: Pull complete 
a1bc4b7ad0f0: Pull complete 
a33d2f01ead9: Pull complete 
94b33095e71c: Pull complete 
d3c2b649b97c: Pull complete 
8a5bf7f0acd7: Pull complete 
Digest: sha256:6ccde0cb87c24c09b1970802b10e702ab4491ac932b79f69682609787379fa42
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest

docker image ls: show all the images

mrityunjay:~$ docker image ls
REPOSITORY   TAG       IMAGE ID       CREATED      SIZE
redis        latest    8e69fcb59ff4   7 days ago   130MB

docker image inspect <image_name or image_id> :Display detailed information on one or more images

mrityunjay:~$ docker image inspect redis
[
    {
        "Id": "sha256:8e69fcb59ff4a25f87cf68cf2558df9c56df3c3c8ef709677dc602a458fe9b2d",
        "RepoTags": [
            "redis:latest"
        ],
        "RepoDigests": [
            "redis@sha256:6ccde0cb87c24c09b1970802b10e702ab4491ac932b79f69682609787379fa42"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2023-06-14T21:57:04.72797832Z",
        "Container": 
        ....

docker image rm <image_id / image_name>: Delete one or more images

mrityunjay:~$ docker image rm redis
Untagged: redis:latest
Untagged: redis@sha256:6ccde0cb87c24c09b1970802b10e702ab4491ac932b79f69682609787379fa42
Deleted: sha256:8e69fcb59ff4a25f87cf68cf2558df9c56df3c3c8ef709677dc602a458fe9b2d
Deleted: sha256:fe526a32129d428c70598b5002c0c36375de4c593d5e9a9c5cb23b3029be6535
Deleted: sha256:5ae934b4bc8f1f63c0c096d7c33b9aa6782e4bf32c6584ab4a3374a5c2fea61b
Deleted: sha256:ad2888d341396ec43ce8c9526f4f706951cdd46b9c5c68248560fe19b7eeeebc
Deleted: sha256:ab6989ff03a00c9b4e5524e3858ba3ad6c939482d48434ad61c49bb5d390d31d
Deleted: sha256:67fa40895a637a6ffa36df77928cdd46f9f28f9ca2e7a5f5d1ca4851875b4956
Deleted: sha256:ac4d164fef90ff58466b67e23deb79a47b5abd30af9ebf1735b57da6e4af1323

docker image push <image-name>:<tag>:Push an image or a repository to a registry
docker image build . : Build image from dockerfile

📝 NOTE : If you need any help related to docker image command just type

docker image command --help

mrityunjay:~$ docker image command --help

Usage:  docker image COMMAND

Manage images

Commands:
  build       Build an image from a Dockerfile
  history     Show the history of an image
  import      Import the contents from a tarball to create a filesystem image
  inspect     Display detailed information on one or more images
  load        Load an image from a tar archive or STDIN
  ls          List images
  prune       Remove unused images
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rm          Remove one or more images
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE

Run 'docker image COMMAND --help' for more information on a command.

🚀 Container Commands
🎯 Creating the Container: This command will create the container of specific image in an interactive mode. But this will not run the container.

docker container create -it --name <container_name> <image_id / image_name>

🎯 Starting the Container: docker container start will start the container. -i will open container's console for i/o . CONTAINER is either name or id of the container.

docker container start -i CONTAINER

🎯 Running the Container : docker run command will create and run the container --name will name the container and -it allow you to interact with the container's console. -d option make container run in deatched mode.

docker run -it --name <container_name> -d <image_name>

🎯 Running the Command in Container: docker exec will execute the command in docker container. -it will enable interactive mode. container is either container name or id command specify the command to be executed.

docker exec -it CONTAINER COMMAND

🎯 Stopping the Container : docker container stop will stop the running container mycontainer is either name or id of container.

docker container stop mycontainer

🎯 Kill the Running Container : docker container kill command will forcefully terminate the container after try stopping conatiner gracefully using docker container stop command. mycontainer is either container name or container id.

docker container kill mycontainer

🎯 Removing the container : docker container rm will remove the container. mycontainer is one of more container_name or container_id.

docker container rm mycontainer

📝 NOTE : If you need help for the docker container command

docker container command --help

mrityunjay:~$ docker container command --help

Usage:  docker container COMMAND

Manage containers

Commands:
  attach      Attach local standard input, output, and error streams to a running container
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes to files or directories on a container's filesystem
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  inspect     Display detailed information on one or more containers
  kill        Kill one or more running containers
  logs        Fetch the logs of a container
  ls          List containers
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  prune       Remove all stopped containers
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  run         Run a command in a new container
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  wait        Block until one or more containers stop, then print their exit codes

Run 'docker container COMMAND --help' for more information on a command.

🌟 This is all about Images and Containers.In next blog will be be going to see how to Container the appication.

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀

DEV Community: mrityunjay saraf

♨️ Mastering Java Concurrency: Dive into Part 2!

📌 Table of Contents

🔒 Reentrant Lock

📝 Example:

Result

⌛Introduction to CountDownLatch

✍🏼Example:

✍🏼Explanation:

📊 This is the result:

🛑 What are Semaphores

✍️ Example:

📈 Results:

🔥 Mastering Java Concurrency: Dive into Part 1! 🚀

Table of Contents

🔄 Understanding Concurrency

🧵 What are Threads

💾 Problem with Thread Caching

🔒 Solution: Volatile Keyword

🏎️ Problem: Race Conditions

🛠️ Solution: Synchronized Keyword

🧱 Synchronize Code Blocks

🔐 Locking

- Intrinsic Locks

Crafting Concurrency: Building Your Own ThreadPool for Multi-Threaded Servers

Table of Contents 📚

✨ Introduction

💡The Solution

🛠️Understanding ThreadPool

🚀 Implementing the ThreadPool Class from Scratch

1. Define the ThreadPool Class:

Methods:

2. Define the PoolThreadRunnable Class

Methods:

🌐 Implementing ThreadPool in our Web Server

📊 Result Overview

🚀How TCP Servers Are Designed to Handle Multiple Requests

📚 Table of Contents

🖥️ What Is a Server?

🔄 What Is Multi-Threading?

❓ Why Do We Need a Multi-threaded Server?

🛠️ How to Design Multi-Threaded Servers?

A Deep Dive into Parking Spot LLD Design

Responsibility

Our Parking Model Lineup 🌟

ParkingSpot Interface 🚗🏍️

Finding the Right Spot for you Vehicle 🚗

🎩 Exit Manager: Calculate your Parking Fare!

Docker 101: Understanding Images and Containers in Plain English

📌 Table of content

📍What is Docker

📍Advantage of Docker

📍Architecture of Docker

📍What is Image

📍What is Container

📍Docker Commands

📍Image Commands

📍Container Commands

🔎 What is Docker

✨ Advantage of Docker

🔑 Key concept of Docker

🧬 Architecture of Docker

📔 What is an Image

📦 What is the Container

📌 Docker Commands

🚀 Image Commands

🚀 Container Commands