Play Store Application link – https://play.google.com/store/apps/details?id=com.ideepro.java25hours

Learn with youtube video-

💡Definition-

Multithreading is a concept of execution of multiple threads, simultaneously/concurrently/at the same time.

💡Process-

A process is running state of instruction.

💡Thread-

Threads exist within a process.
every process has at least one thread in it.
Threads share the process’s resources,

Here is a comparison of processes and threads:

💡Important –

1- Every Java program has at least one thread, the main thread, which is created by the Java Virtual Machine (JVM) when the program starts. You can use the currentThread() method to access the main thread and perform actions on it.

2- A daemon thread is a low-priority thread that runs in the background and does not prevent the program from exiting. An example of a daemon thread in the real world might be a thread that periodically checks for updates to a software application and installs them in the background.

💡Life Cycle of Thread-

·      

Here is a table that compares the different stages of a thread’s lifecycle in Java:

💡THREAD PRIORITY-

Threads with higher priority should be executed before lower-priority threads.
However, thread priorities cannot guarantee the order.

[Static fields]-
Java thread priorities are in the range between
1-MIN_PRIORITY (a constant of 1) and
2-MAX_PRIORITY (a constant of 10).
3-NORM_PRIORITY (a constant of 5)-By default.

💡Thread creation-

Here is a tabular comparison of the two approaches:

💡Q- which is better way?

A- In general, the Runnable interface is a more flexible approach, because a class can implement multiple interfaces but can only extend one superclass. However, the Thread class provides additional methods and fields for controlling and managing threads, which may be useful in some situations.

💡1) Using inheritance (Extending Thread class):

Note-

1- Always keep a separate class to start a main thread.

2- If you want to perform different task on a different thread then always keep a separate thread class for each task.

3- If you want to perform a common task on each thread then create a single thread class and make a multiple objects of same thread.

Example-

class Thread1 extends Thread {

public void run()

{
for(int i=0; i<=5; i++)
{
System.out.println(Thread.currentThread().getName());
}
}
}

class Thread2 extends Thread {
public void run()
{
for(int i=0; i<=6; i++)
{
System.out.println(Thread.currentThread().getName());
}
}
}

class RunThread
{
public static void main(String[] Arg)
{

Thread1 t1 = new Thread1();

Thread2 t2 = new Thread2();

t1.start();

t2.start();
}
}

2) Using Association (Implementing Runnable interface):
implement Runnable and override the run method.

class Thread1 implements Runnable{

public void run() {

for(int i=0; i<=10; i++) {

System.out.println(Thread.currentThread().getName());

}

}

}

class RunThread
{
public static void main(String[] args)
{

Thread1 t1 = new Thread1();

Thread tt1 = new Thread(t1);

tt1.start();

Thread tt2 = new Thread(t1);

tt2.start();

}
}

💡Constructors in Thread class

Here is a tabular comparison of all the constructors of the Thread class in Java, along with code snippets showing how to use them:

Note that in order to start a new thread, you need to call the start() method on the Thread object. For example:

Thread t = new Thread(r, "Thread-1");
t.start();

This will actually create a new thread and start it running. The thread will execute the run() method of the Runnable object passed to the constructor.

Note – ThreadGroup class is used to represent a group of threads. It allows you to manipulate a group of threads as a single entity, including setting priority, setting a UncaughtExceptionHandler, and suspending and resuming all threads in the group at once.

💡Static methods of Thread Class-

Here is a tabular comparison of all the static methods of the Thread class, along with code snippets demonstrating their usage:

.           

💡Instance methods-

Here is a tabular comparison of all instance methods of the Thread class in Java, along with brief descriptions and code snippets showing how each method can be used:

·   

💡-Single example to combine most useful methods –

public class ThreadMethodsExample {
    public static void main(String[] args) throws InterruptedException {
        // Create a new thread
        Thread thread = new Thread(() -> {
            try {
                // Sleep for 500 milliseconds
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // Print a message if the thread is interrupted
                System.out.println("Thread interrupted while sleeping");
            }

            // Print a message
            System.out.println("Hello from a new thread!");

            // Yield to other threads
            Thread.yield();
        });

        // Set the name of the thread
        thread.setName("My Thread");

        // Set the priority of the thread
        thread.setPriority(Thread.MAX_PRIORITY);

        // Set the thread as a daemon thread
        thread.setDaemon(true);

        // Start the thread
        thread.start();

        // Wait for the thread to finish
        thread.join();

        // Get the name of the thread
        String threadName = thread.getName();
        System.out.println("Thread name: " + threadName);

        // Get the priority of the thread
        int priority = thread.getPriority();
        System.out.println("Thread priority: " + priority);

        // Check if the thread is a daemon thread
        boolean isDaemon = thread.isDaemon();
        System.out.println("Is daemon thread: " + isDaemon);

        // Check if the thread is alive
        boolean isAlive = thread.isAlive();
        System.out.println("Is thread alive: " + isAlive);

        // Interrupt the thread
        thread.interrupt();
        System.out.println("Thread interrupted");
    }
}


💡Can we start a thread twice?

->No. After staring a thread, it can never be started again. If you does so, an IllegalThreadStateException is thrown.

For Example:
T1.start();
T1.start(); (exception)

💡Here is a comparison between synchronization and lock in Java:

It’s important to note that both synchronization and lock are used to achieve thread safety in Java. However, lock offers more advanced and flexible locking capabilities compared to synchronization.

💡Synchronization in java –

💡Synchronization- It’s a capability of control the access of multiple threads to any shared resource.

💡Types of thread synchronization-

Here is a tabular comparison between mutual exclusion, inter-thread communication, synchronized method, synchronized block, and static synchronization in Java:

1- Mutual exclusion example- (synchronized keyword- ): (Synchronized method example)–

Here is a complete example of mutual exclusion in Java using the synchronized keyword:

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

In this example, the increment and getCount methods are both marked with the synchronized keyword. This ensures that only one thread can execute either of these methods at a time.

Here is an example of how you might use this Counter class in a multi-threaded environment:

Counter counter = new Counter();

Thread t1 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        counter.increment();
    }
});

Thread t2 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        counter.increment();
    }
});

t1.start();
t2.start();

t1.join();
t2.join();

System.out.println(counter.getCount());  // 2000

In this example, two threads are created and each increments the counter 1000 times. Without the use of mutual exclusion, the final value of the counter may not be accurate, as both threads could be updating the counter simultaneously. However, by using the synchronized keyword, we ensure that only one thread can execute the increment method at a time, and the final value of the counter is guaranteed to be accurate.

2- Mutual exclusion example- (synchronized keyword- ): (Synchronized block example)–

Here is an example of using a synchronized block in Java:

public class SynchronizedExample {
    private int count = 0;

    public void increment() {
        synchronized(this) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

In this example, the increment() method increments the count variable. However, the increment() method is surrounded by a synchronized block, which means that only one thread can execute the code inside the block at a time. This can be useful if multiple threads are accessing and modifying the count variable and you want to ensure that the variable is updated consistently and correctly.

To use a synchronized block, you first need to specify the object that you want to synchronize on. In this case, we are using this, which refers to the current object (i.e., the SynchronizedExample instance). You can also use any other object as the lock, as long as all threads that want to synchronize on the same block use the same lock object.

3- Mutual exclusion example- (synchronized keyword- ): (Static Synchronized example)–

Here is an example of using a static synchronized method in Java:

public class SynchronizedExample {
    private static int count = 0;

    public static synchronized void increment() {
        count++;
    }

    public static int getCount() {
        return count;
    }
}

In this example, the increment() method is a static synchronized method, which means that only one thread can execute the method at a time. This can be useful if multiple threads are accessing and modifying the count variable and you want to ensure that the variable is updated consistently and correctly.

To use a static synchronized method, you simply need to use the synchronized keyword before the static keyword in the method declaration. The lock object used for the synchronized block is the class object of the class in which the synchronized method is defined. In this case, the lock object is the SynchronizedExample.class object.

4- Inter-thread communication example –

Here is an example of inter-thread communication in Java using the wait(), notify(), and notifyAll() methods from the Object class:

public class InterThreadCommunicationExample {

    public static void main(String[] args) {
        final Customer c = new Customer();
        new Thread() {
            public void run() {
                c.withdraw(15000);
            }
        }.start();

        new Thread() {
            public void run() {
                c.deposit(10000);
            }
        }.start();
    }
}

class Customer {
    int amount = 10000;

    synchronized void withdraw(int amount) {
        System.out.println("going to withdraw...");

        if (this.amount < amount) {
            System.out.println("Less balance; waiting for deposit...");
            try {
                wait();
            } catch (Exception e) {
            }
        }
        this.amount -= amount;
        System.out.println("withdraw completed...");
    }

    synchronized void deposit(int amount) {
        System.out.println("going to deposit...");
        this.amount += amount;
        System.out.println("deposit completed... ");
        notify();
    }
}

In this example, there are two threads: one for withdrawing money and one for depositing money. The Customer class has a synchronized withdraw() method and a synchronized deposit() method. The withdraw() method checks if there is enough balance to withdraw the requested amount. If there is not enough balance, it calls the wait() method to wait for a deposit.

The deposit() method deposits the given amount and then calls the notify() method to wake up the thread that is waiting in the withdraw() method.

The wait(), notify(), and notifyAll() methods can only be called from within a synchronized method or block. They are used to allow threads to communicate with each other and synchronize their actions.

💡Concept of Lock in java-

Synchronized is done around the concept of locks.

Objects have internal entity which is called monitors.

Threads can lock and unlock these monitors.

One object can hold only one lock.

One thread can hold many locks.

Here is a tabular comparison of the various locks in Java, along with some examples:

1- Here is an example of how to use a ReentrantLock in Java:

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private static int count = 0;
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
            } finally {
                lock.unlock();
            }
        });

        Thread t2 = new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
            } finally {
                lock.unlock();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + count);
    }
}

In this example, two threads are incrementing a shared count variable concurrently. To ensure that the updates to the count variable are thread-safe, the threads acquire a lock on the ReentrantLock object before updating the count variable. The lock.lock() method acquires the lock, and the lock.unlock() method releases the lock.

Note that it is important to release the lock using the finally block to ensure that the lock is always released, even if an exception is thrown while the thread holds the lock.

2- Here is an example of using a ReentrantReadWriteLock in Java:

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
  private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  private final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
  private final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

  private int value;

  public int getValue() {
    readLock.lock();
    try {
      return value;
    } finally {
      readLock.unlock();
    }
  }

  public void setValue(int value) {
    writeLock.lock();
    try {
      this.value = value;
    } finally {
      writeLock.unlock();
    }
  }
}

This example defines a simple class that has a single integer value that can be read and written by multiple threads. The ReentrantReadWriteLock is used to ensure that the value is accessed in a thread-safe manner. The readLock is used to protect the getValue method, which can be called concurrently by multiple threads. The writeLock is used to protect the setValue method, which should only be called by a single thread at a time.

Interview Questions —

• What is difference between process and thread?
• What is life cycle of thread in java?