Top 20 Multithreading Java Interview questions and Answers Part-II

14.What is the purpose of the volatile keyword in multithreading?

In Java, the volatile keyword is used to indicate that a variable’s value may be modified by multiple threads and that changes to the variable should be visible to all threads immediately. The volatile keyword ensures that each thread accesses the most up-to-date value of the variable and that changes to the variable are propagated immediately to all threads.

Without the volatile keyword, each thread may cache the value of the variable in its own CPU cache, and changes made by one thread may not be visible to other threads until the cache is flushed to main memory. This can lead to race conditions, where different threads have different versions of the variable’s value, and can cause unpredictable and incorrect behavior.

Here is an example that demonstrates the use of the volatile keyword:

arduinoCopy codeclass MyThread extends Thread {
    volatile boolean stop = false;

    public void run() {
        while (!stop) {
            // Do some work
        }
    }

    public void stopThread() {
        stop = true;
    }
}

In this example, a MyThread class extends the Thread class and has a volatile boolean variable called stop. The run() method of the thread checks the value of the stop variable in a loop and continues to do some work until the variable is set to true. The stopThread() method is used to set the stop variable to true and stop the thread.

The volatile keyword ensures that changes to the stop variable made by the stopThread() method are immediately visible to the run() method, even if the two methods are executed in different threads.

It is important to note that the volatile keyword only ensures visibility of changes to a variable’s value, but it does not provide mutual exclusion or atomicity guarantees. If multiple threads are accessing and modifying the same variable, you may need to use other synchronization mechanisms such as locks or atomic variables to ensure correctness and consistency.

15.What is the Executor framework?

The Executor framework is a high-level abstraction for managing and executing threads in Java. It provides a way to decouple the task submission and execution process, allowing you to focus on the logic of your program instead of managing threads.

The Executor framework consists of three main components:

1. 1. Executor interface: This interface provides a single method called execute(Runnable command) that is used to execute the given command in a thread pool. The Executor interface is a simple interface that provides basic execution facilities.

1. 1. ExecutorService interface: This interface extends the Executor interface and provides additional methods for managing the execution of tasks, such as submitting tasks for execution, waiting for tasks to complete, and shutting down the thread pool.

1. 1. ThreadPoolExecutor class: This class implements the ExecutorService interface and provides a powerful and flexible thread pool implementation. You can customize the behavior of the thread pool by providing parameters such as the number of threads in the pool, the maximum number of tasks that can be queued, and the thread creation policy.

The Executor framework provides several benefits over manually managing threads:

1. 1. It provides a simple and consistent way to execute tasks in a thread pool, without the need to manage threads manually.

1. 1. It improves the performance of your application by reusing threads and avoiding the overhead of creating and destroying threads for each task.

1. 1. It provides a way to manage the lifecycle of the thread pool, including starting and stopping the pool, and waiting for tasks to complete.

Overall, the Executor framework provides a powerful and flexible way to manage threads in Java, making it easier to write high-performance, scalable, and concurrent applications.

16.What is a ReentrantLock?

ReentrantLock is a type of lock provided in Java that allows a thread to acquire and release the lock multiple times. It is called “reentrant” because a thread can re-enter a critical section of code protected by the same lock it has already acquired, without blocking on itself.

The ReentrantLock provides several advantages over the synchronized block for controlling access to a shared resource:

1. 1. A ReentrantLock can be used to implement more complex locking strategies, such as fairness, timed waits, and interruptible locks.

1. 1. The ReentrantLock provides methods to query the state of the lock, such as the number of threads waiting to acquire the lock and the owner of the lock.

1. 1. Unlike the synchronized block, a ReentrantLock can be used to provide non-blocking lock acquisition, where a thread can try to acquire the lock and immediately return if the lock is not available.

Here is an example of how to use a ReentrantLock to protect a shared resource:

csharpCopy codeclass MyResource {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

In this example, the MyResource class has a private ReentrantLock object called lock that is used to protect the count variable. The increment() method acquires the lock, increments the count, and releases the lock. The getCount() method acquires the lock, reads the value of the count, and releases the lock.

Using a ReentrantLock can provide better control over the synchronization of shared resources and can lead to better performance and scalability compared to using synchronized blocks. However, it requires more code and can be more complex to use correctly.

17.What is the difference between ReentrantLock and synchronized block?

Both ReentrantLock and synchronized blocks are used to synchronize access to shared resources in Java. However, there are some differences between the two approaches:

1. 1. Locking mechanism: The synchronized block is built into the Java language and provides a simple and easy-to-use mechanism for synchronizing access to shared resources. In contrast, ReentrantLock is a lock implementation provided by the Java API that provides more advanced locking features.

1. 1. Lock acquisition: The synchronized block acquires and releases the lock automatically when entering and exiting the block. In contrast, with ReentrantLock, you need to acquire and release the lock manually by calling the lock() and unlock() methods.

1. 1. Reentrancy: The synchronized block is reentrant, which means that a thread can re-enter a synchronized block it has already entered. Similarly, ReentrantLock is also reentrant, but it provides more control over the number of times a thread can enter a critical section of code.

1. 1. Fairness: The synchronized block does not provide any guarantees about which thread will acquire the lock when it becomes available. In contrast, ReentrantLock provides fairness by allowing threads to acquire the lock in the order in which they requested it.

1. 1. Advanced features: ReentrantLock provides more advanced locking features, such as timed waits, interruptible locks, and lock conditions. These features are not available with synchronized blocks.

In general, synchronized blocks are simpler and easier to use, and they are appropriate for most synchronization needs. However, if you need more advanced locking features or greater control over the locking mechanism, ReentrantLock may be a better choice.

18.What is the Callable interface?

The Callable interface in Java is similar to the Runnable interface, but it allows a thread to return a result and throw a checked exception. The Callable interface is defined in the java.util.concurrent package and has a single method:

csharpCopy codepublic interface Callable<V> {
    V call() throws Exception;
}

The call() method returns a result of type V and can throw a checked exception of type Exception. This makes it easier to write concurrent programs that need to return a value from a thread and handle exceptions.

To use a Callable in a thread, you need to submit it to an ExecutorService using the submit() method. The submit() method returns a Future object that can be used to retrieve the result of the computation and handle any exceptions that occurred.

Here is an example of how to use a Callable to compute the factorial of a number:

javaCopy codeimport java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Factorial implements Callable<Long> {
    private final int number;

    public Factorial(int number) {
        this.number = number;
    }

    public Long call() throws Exception {
        long result = 1;
        for (int i = 1; i <= number; i++) {
            result *= i;
        }
        return result;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Factorial factorial = new Factorial(5);
        FutureTask<Long> futureTask = new FutureTask<>(factorial);
        Thread thread = new Thread(futureTask);
        thread.start();
        Long result = futureTask.get();
        System.out.println("Factorial of " + factorial.number + " is " + result);
    }
}

In this example, the Factorial class implements the Callable<Long> interface and overrides the call() method to compute the factorial of the given number. The main() method creates a FutureTask object with the Factorial instance and submits it to a new thread using the Thread class. Finally, it waits for the result using the get() method of the FutureTask object.

Using Callable can make it easier to write concurrent programs that need to return a value from a thread and handle exceptions.

19.What is a CyclicBarrier?

A CyclicBarrier is a synchronization aid that allows a set of threads to wait for each other to reach a common barrier point before proceeding. It is similar to a CountDownLatch, but it can be reused multiple times.

A CyclicBarrier is initialized with a count and a barrier action, which is a Runnable that is executed when the barrier is reached. Each thread that reaches the barrier point calls the await() method, which blocks until all other threads have also called await(). Once the count reaches zero, the barrier action is executed, and the count is reset to its initial value.

Here is an example of how to use a CyclicBarrier to synchronize three threads:

arduinoCopy codeimport java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Worker implements Runnable {
private final CyclicBarrier barrier;
private final int id;

public Worker(CyclicBarrier barrier, int id) {
this.barrier = barrier;
this.id = id;
}

public void run() {
try {
System.out.println(“Worker ” + id + ” started”);
Thread.sleep(1000); // do some work
System.out.println(“Worker ” + id + ” reached barrier”);
barrier.await(); // wait for all workers to reach the barrier
System.out.println(“Worker ” + id + ” finished”);
} catch (InterruptedException | BrokenBarrierException e) {
Thread.currentThread().interrupt();
}
}

public static void main(String[] args) {
int nWorkers = 3;
CyclicBarrier barrier = new CyclicBarrier(nWorkers, () -> System.out.println(“All workers reached barrier”));
for (int i = 0; i < nWorkers; i++) {
new Thread(new Worker(barrier, i)).start();
}
}
}

In this example, the Worker class implements the Runnable interface and waits for the barrier signal before doing some work and signaling that it has finished. The main() method creates three Worker instances and starts them in separate threads. Once all three workers have reached the barrier point, the barrier action is executed and all workers are released.

Using CyclicBarrier can make it easier to synchronize multiple threads that need to perform a set of operations in a specific order and want to wait for each other to reach a common barrier point.

20.What is a CountDownLatch?

A CountDownLatch is a synchronization aid that allows one or more threads to wait for a set of operations to complete before proceeding. It is similar to a barrier, but it can be used only once, whereas a barrier can be reused.

A CountDownLatch is initialized with a count, and each await() call blocks until the count reaches zero. The count can be decremented by calling the countDown() method, which signals that an operation has completed. Once the count reaches zero, all waiting threads are released.

Here is an example of how to use a CountDownLatch to synchronize two threads:

//java code
//
//import java.util.concurrent.CountDownLatch;
//
//public class Worker implements Runnable {
//    private final CountDownLatch startLatch;
//    private final CountDownLatch endLatch;
//    private final int id;
//
//    public Worker(CountDownLatch startLatch, CountDownLatch endLatch, int id) {
//        this.startLatch = startLatch;
//        this.endLatch = endLatch;
//        this.id = id;
//    }
//
//    public void run() {
//        try {
//            startLatch.await(); // wait for the start signal
//            System.out.println("Worker " + id + " started");
//            Thread.sleep(1000); // do some work
//            System.out.println("Worker " + id + " finished");
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        } finally {
//            endLatch.countDown(); // signal that this worker has finished
//        }
//    }
//
//    public static void main(String[] args) throws InterruptedException {
//        int nWorkers = 2;
//        CountDownLatch startLatch = new CountDownLatch(1);
//        CountDownLatch endLatch = new CountDownLatch(nWorkers);
//        for (int i = 0; i < nWorkers; i++) {
//            new Thread(new Worker(startLatch, endLatch, i)).start();
//        }
//        Thread.sleep(5000); // wait for some time
//        startLatch.countDown(); // start the workers
//        endLatch.await(); // wait for all workers to finish
//        System.out.println("All workers finished");
//    }
//}
//
//
//In this example, the Worker class implements the Runnable interface and waits for the startLatch signal before doing some work and signaling that it has finished using the endLatch. The main() method creates two Worker instances and starts them in separate threads. It waits for some time and then signals the startLatch to start the workers. Finally, it waits for all workers to finish using the endLatch.