Top Java Multithreading interview questions(2024)

Are you preparing for a Java multithreading interview and want to ensure you’re well prepared to answer even the toughest questions?
In this comprehensive guide, we’ve compiled a list of top Java multithreading interview questions, carefully categorized by level of experience to help both freshers and experienced.
Whether you’re just starting out in your Java career or have years of experience under your belt, this article is designed to help you brush up on your multithreading skills and confidently ace your next interview.

Our collection of questions is divided into four sections, tailored to candidates with 2, 5, 7, and 10 years of experience.
Each question is accompanied by a detailed answer, complete with code examples to illustrate key concepts and provide a deeper understanding of the topic.

By the end of this article, you’ll be well-versed in the most common Java multithreading interview questions and equipped with the knowledge and skills to tackle even the most challenging scenarios.

Multithreading interview questions for freshers

Here are the answers to the interview questions based on Java concurrency for freshers and experience up to 2 years:

1. What is the difference between thread and process in Java?

In Java, a process is an independent unit of execution that runs in its own memory space.
Each process has its own memory, and changes made to one process’s memory do not affect other processes.
On the other hand, a thread is a lightweight process that runs within a process. Multiple threads can share the same memory space and resources, making them more efficient than processes.
However, this shared memory space can also lead to concurrency issues if not handled properly.

2. How do you create a thread in Java?
Can you explain the differences between extending Thread class and implementing Runnable interface?

There are two ways to create a thread in Java:

A. Extending Thread class:

public class MyThread extends Thread {
  public void run() {
    System.out.println("Hello from MyThread!");
  }
}
MyThread thread = new MyThread();
thread.start();

B. Implementing Runnable interface

public class MyRunnable implements Runnable {
  public void run() {
    System.out.println("Hello from MyRunnable!");
  }
}
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

The main difference between the two approaches is that when you extend the Thread class, you’re creating a new thread class that can be used only once.
When you implement the Runnable interface, you’re creating a separate class that can be executed by multiple threads.

3. What is synchronization in Java? How do you achieve synchronization using synchronized keyword?

Synchronization in Java is the process of controlling access to shared resources in a multithreaded environment.
The synchronized keyword is used to achieve synchronization by locking an object’s monitor, ensuring that only one thread can execute a block of code at a time.
Here’s an example:

public class BankAccount {
  private int balance = 0;
  public synchronized void deposit(int amount) {
    balance += amount;
  }
  public synchronized void withdraw(int amount) {
    balance -= amount;
  }
}

In this example, the deposit() and withdraw() methods are synchronized, ensuring that only one thread can access the balance variable at a time.

4. What is the difference between wait() and sleep() methods in Java?

wait() and sleep() methods are both used to pause the execution of a thread, but they serve different purposes:

sleep() method

Thread.sleep() method pauses the execution of a thread for a specified amount of time.
The thread remains in a running state and can be interrupted by other threads.

// sleep for 1 second
Thread.sleep(1000);

wait() method

Pauses the execution of a thread until another thread notifies it.
The thread releases its lock on the object’s monitor and waits for a notification.

synchronized (object) {
  object.wait();
}

5. Can you explain the concept of deadlock in Java?
How can you avoid it?

A deadlock is a situation where two or more threads are blocked indefinitely, each waiting for the other to release a resource.
In Java, deadlocks can occur when multiple threads are competing for shared resources, such as locks on objects.
To avoid deadlocks, follow these best practices:

Avoid nested locks: Try to acquire locks in a consistent order to avoid deadlocks.
Use timeouts: Use wait() with a timeout to avoid waiting indefinitely.
Avoid unnecessary locks: Minimize the use of locks and synchronize only the critical sections of code.

6. What is the role of volatile keyword in Java concurrency?

volatile keyword in Java is used to ensure that changes made to a variable are visible to all threads.
When a variable is declared as volatile, the Java Memory Model (JMM) ensures that the changes are propagated to all threads.
Here’s an example:

public class MyThread {
  private volatile boolean stop = false;
  
  public void run() {
    while (!stop) {
      // do something
    }
  }
  
  public void stopThread() {
    stop = true;
  }
}

In this example, the stop variable is declared as volatile, ensuring that changes made to it are visible to all threads.

7. How do you handle InterruptedException in Java?

InterruptedException is thrown when a thread is interrupted while waiting or sleeping.
To handle it, you can use a try-catch block:

try {
  Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

It’s essential to restore the interrupted status by calling Thread.currentThread().interrupt() to ensure that the thread remains interruptible.

8. Can you explain the concept of atomic variables in Java? How do you use AtomicInteger class?

Atomic variables in Java are variables that can be updated atomically, ensuring that multiple threads can access and update them safely without the need for synchronization.
The AtomicInteger class is an example of an atomic variable.
It provides methods to atomically increment, decrement, and update the value of an integer variable.
Here’s an example:

AtomicInteger counter = new AtomicInteger(0);

public void incrementCounter() {
  counter.incrementAndGet();
}

In this example, the incrementAndGet() method atomically increments the value of the counter variable, ensuring that multiple threads can access and update it safely.

9. What is the purpose of ThreadLocal class in Java?

The ThreadLocal class in Java is used to create thread-local variables, which are variables that have a separate copy for each thread.
This allows each thread to maintain its own state without interfering with other threads.
Here’s an example:

public class MyThreadLocal {
  private static ThreadLocal counter = new ThreadLocal() {
    @Override
    protected Integer initialValue() {
      return 0;
    }
  };

  public void incrementCounter() {
    counter.set(counter.get() + 1);
  }
  
  public int getCounter() {
    return counter.get();
  }
}

In this example, each thread has its own copy of the counter variable, which can be incremented and accessed independently without affecting other threads.

10. How do you use Executor framework to execute tasks concurrently in Java?

The Executor framework in Java provides a way to execute tasks concurrently using a thread pool.
Here’s an example:

ExecutorService executor = Executors.newFixedThreadPool(5);
Runnable task1 = new Runnable() {
  public void run() {
    System.out.println("Task 1 executed");
  }
};
Runnable task2 = new Runnable() {
  public void run() {
    System.out.println("Task 2 executed");
  }
};
executor.execute(task1);
executor.execute(task2);
executor.shutdown();

In this example, we create an ExecutorService instance with a fixed thread pool of 5 threads.
We then submit two tasks to the executor using the execute() method.
The executor will execute the tasks concurrently using the available threads in the pool.
Finally, we shut down the executor using the shutdown() method.

Multithreading interview questions for 5 years experienced

Here are the answers to the Java concurrency interview questions for 5 years experience.

1. Can you explain the concept of producer-consumer problem in Java?
How do you implement it using wait() and notify() methods?

The producer-consumer problem is a classic synchronization problem where one thread (producer) produces data and another thread (consumer) consumes it.
The challenge is to ensure that the consumer doesn’t consume data before it’s produced and the producer doesn’t produce data before the consumer has consumed the previous data.
Here’s an example implementation using wait() and notify() methods:

class ProducerConsumer {
  private final Object lock = new Object();
  private boolean isProduced = false;
    
  public void produce() {
    synchronized (lock) {
      while (isProduced) {
        try {
          lock.wait();
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        }
      }
      // Produce data
      System.out.println("Produced data");
      isProduced = true;
      lock.notify();
    }
  }
  
  public void consume() {
    synchronized (lock) {
      while (!isProduced) {
        try {
          lock.wait();
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        }
      }
      // Consume data
      System.out.println("Consumed data");
      isProduced = false;
      lock.notify();
    }
  }
}

In this example, the producer thread calls produce() method, which waits until the consumer has consumed the previous data.
Once the data is produced, it notifies the consumer thread. The consumer thread calls consume() method, which waits until the producer has produced new data.
Once the data is consumed, it notifies the producer thread.

2. How do you use Lock interface and its implementations (ReentrantLock, ReadWriteLock) in Java?

The Lock interface is a part of the Java concurrency API that provides a more flexible and powerful way of locking compared to the synchronized keyword.
ReentrantLock and ReadWriteLock are two implementations of the Lock interface.
Here’s an example of using ReentrantLock:

class ReentrantLockExample {
  private final ReentrantLock lock = new ReentrantLock();
  public void accessSharedResource() {
    lock.lock();
    try {
      // Access shared resource
      System.out.println("Accessing shared resource");
    } finally {
      lock.unlock();
    }
  }
}

In this example, the ReentrantLock is used to protect the shared resource.
The lock() method is used to acquire the lock, and the unlock() method is used to release the lock.
Here’s an example of using ReadWriteLock:

class ReadWriteLockExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    public void readSharedResource() {
        lock.readLock().lock();
        try {
            // Read shared resource
            System.out.println("Reading shared resource");
        } finally {
            lock.readLock().unlock();
        }
    }
    public void writeSharedResource() {
        lock.writeLock().lock();
        try {
            // Write shared resource
            System.out.println("Writing shared resource");
        } finally {
            lock.writeLock().unlock();
        }
    }
}

In this example, the ReadWriteLock is used to protect the shared resource.
The readLock() method is used to acquire a read lock, and the writeLock() method is used to acquire a write lock.

3. What is the difference between fair and unfair locking in Java?

In Java, locks can be either fair or unfair.
A fair lock ensures that threads are granted access to the lock in the order they requested it, whereas an unfair lock does not guarantee any ordering.
ReentrantLock has a constructor that takes a boolean argument fair, which determines whether the lock is fair or unfair.
If fair is true, the lock is fair; otherwise, it’s unfair.
Fair locks are more predictable and prevent starvation, but they can be slower due to the overhead of maintaining the queue of waiting threads.
Unfair locks are faster but can lead to starvation.

4. Can you explain the concept of starvation and livelock in Java? How do you avoid them?

Starvation occurs when a thread is unable to gain access to a shared resource because other threads are holding onto the resource for an extended period.
This can happen when multiple threads are competing for the same resource, and one thread is not getting a chance to access it.
Livelock occurs when two or more threads are blocked indefinitely, each waiting for the other to release a resource.
To avoid starvation and livelock, you can use the following strategies:

Use fair locks to ensure that threads are granted access to the lock in the order they requested it.
Use timeouts when acquiring locks to prevent threads from waiting indefinitely.
Avoid nested locks, which can lead to livelock.
Use atomic variables and lock-free data structures to minimize the need for locks.

5. How do you use CountdownLatch and CyclicBarrier classes in Java?

CountDownLatch is a synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
Here’s an example:

class CountdownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(5);
    public void performOperation() {
        // Perform some operation
        System.out.println("Performing operation");
        latch.countDown();
    }
    public void waitForOperationsToComplete() {
        try {
            latch.await();
            System.out.println("All operations completed");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

In this example, the CountDownLatch is initialized with a count of 5. Each time the performOperation() method is called, it decrements the count using countDown().
The waitForOperationsToComplete() method waits until the count reaches 0 using await().
CyclicBarrier is a synchronization aid that allows a set of threads to wait until all threads in the set have reached a certain point.
Here’s an example:

class CyclicBarrierExample {
  private final CyclicBarrier barrier = new CyclicBarrier(5);
  public void performOperation() {
    // Perform some operation
    System.out.println("Performing operation");
    try {
      barrier.await();
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    } catch (BrokenBarrierException e) {
       // Handle broken barrier exception
    }
  }
}

In this example, the CyclicBarrier is initialized with a count of 5.
Each thread calls the performOperation() method, which waits until all threads have reached the barrier using await().

6. What is the purpose of Phaser class in Java? Can you explain its usage?

Phaser is a synchronization aid that allows multiple threads to wait until a set of operations being performed in other threads completes.
It’s similar to CountDownLatch, but more flexible and powerful.
Here’s an example:

class PhaserExample {
  private final Phaser phaser = new Phaser(5);
  public void performOperation() {
    // Perform some operation
    System.out.println("Performing operation");
    phaser.arriveAndAwaitAdvance();
  }
    
  public void waitForOperationsToComplete() {
    phaser.awaitAdvance(0);
    System.out.println("All operations completed");
  }
}

In this example, the Phaser is initialized with a count of 5.
Each thread calls the performOperation() method, which arrives at the phaser using arriveAndAwaitAdvance(). The waitForOperationsToComplete() method waits until all threads have arrived at the phaser using awaitAdvance(0).

7. Can you explain the concept of parallel streams in Java? How do you use them for concurrent processing?

Parallel streams are a way to process large datasets in parallel using multiple threads.
They’re part of the Java Stream API.
Here’s an example:

List numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.parallelStream()
       .filter(n -> n % 2 == 0)
       .map(n -> n * 2)
       .forEach(System.out::println);

In this example, the parallelStream() method is used to create a parallel stream from the list of numbers.
The filter() method is used to filter out odd numbers, the map() method is used to double the remaining numbers, and the forEach() method is used to print the results.

8. How do you use ForkJoinPool class in Java for parallel execution of tasks?

ForkJoinPool is a class that provides a way to execute tasks in parallel using multiple threads.
Here’s an example:

class ForkJoinExample {
  private final ForkJoinPool pool = new ForkJoinPool();
  public void performTask() {
    RecursiveTask task = new RecursiveTask() {
      @Override
      protected Void compute() {
        // Perform some task
        System.out.println("Performing task");
        return null;
      }
    };
    pool.execute(task);
    pool.shutdown();
  }
}

In this example, the ForkJoinPool is created with a default number of threads.
The performTask() method creates a recursive task and submits it to the pool using execute().
The shutdown() method is called to shut down the pool after the task is completed.

Multithreading interview questions for 7 years experience

Here are the answers to the interview questions based on Java concurrency for 7 years of experience

1. Can you explain the concept of Java Memory Model (JMM) and its impact on concurrency?

The Java Memory Model (JMM) is a specification that defines how Java programs behave in a multithreaded environment. It outlines the rules for memory visibility, atomicity, and ordering of operations in a concurrent program. The JMM ensures that changes made by one thread are visible to other threads in a predictable manner.
The JMM has a significant impact on concurrency because it:

Ensures that changes to shared variables are visible to all threads
Defines the happens-before relationship between operations, which affects the ordering of instructions
Provides a way to reason about the behavior of concurrent programs
For example, consider the following code snippet:

public class MemoryModelExample {
    private int x = 0;
    public void increment() {
        x++;
    }
    public int getX() {
        return x;
    }
}

In this example, if two threads call the increment() method concurrently, the JMM ensures that the changes made by one thread are visible to the other thread. However, without proper synchronization, the outcome of the getX() method may be unpredictable due to the lack of happens-before relationships.

2. How do you use StampedLock class in Java for optimistic locking?

The StampedLock class in Java provides a more efficient way of implementing optimistic locking compared to traditional locks.
It allows multiple threads to access a shared resource without blocking each other, reducing contention and improving performance.
Here’s an example of using StampedLock for optimistic locking:

public class OptimisticLockingExample {
    private final StampedLock lock = new StampedLock();
    private int x = 0;
    public void increment() {
        long stamp = lock.tryOptimisticRead();
        int currentX = x;
        if (!lock.validate(stamp)) {
            // Someone else modified the value, retry
            stamp = lock.writeLock();
            try {
                x = currentX + 1;
            } finally {
                lock.unlockWrite(stamp);
            }
        } else {
            // No one else modified the value, update it optimistically
            x = currentX + 1;
        }
    }
    public int getX() {
        long stamp = lock.tryOptimisticRead();
        int currentX = x;
        if (!lock.validate(stamp)) {
            // Someone else modified the value, retry
            stamp = lock.readLock();
            try {
                currentX = x;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return currentX;
    }
}

In this example, the increment() method uses tryOptimisticRead() to acquire a stamp, which allows it to read the value of x without blocking.
If the stamp is validated, the method updates the value of x optimistically.
If the stamp is invalid, the method retries with a write lock.

3. Can you explain the concept of lock striping in Java?
How do you implement it?

Lock striping is a technique used to reduce contention on a single lock by dividing the lock into multiple stripes, each protecting a portion of the data.
This allows multiple threads to access different parts of the data simultaneously, reducing contention and improving performance.
In Java, you can implement lock striping using an array of locks, where each lock protects a portion of the data.
Here’s an example:

public class LockStripingExample {
    private final int numStripes = 16;
    private final Object[] locks = new Object[numStripes];
    public LockStripingExample() {
        for (int i = 0; i < numStripes; i++) {
            locks[i] = new Object();
        }
    }
    public void accessData(int index) {
        int stripeIndex = index % numStripes;
        synchronized (locks[stripeIndex]) {
            // Access the data protected by the lock
        }
    }
}

In this example, the LockStripingExample class uses an array of 16 locks to protect different portions of the data.
accessData() method calculates the stripe index based on the input index and synchronizes on the corresponding lock before accessing the data.

4. How do you use concurrent collections (ConcurrentHashMap, CopyOnWriteArrayList, etc.) in Java?

Concurrent collections in Java provide thread-safe implementations of common data structures, allowing multiple threads to access and modify the data simultaneously. Here are some examples:

ConcurrentHashMap:

public class ConcurrentHashMapExample {
    private final ConcurrentHashMap map = new ConcurrentHashMap<>();
    public void putValue(String key, int value) {
        map.put(key, value);
    }
    public int getValue(String key) {
        return map.getOrDefault(key, 0);
    }
}

CopyOnWriteArrayList:

public class CopyOnWriteArrayListExample {
    private final CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
    public void addElement(String element) {
        list.add(element);
    }
    public List getElements() {
        return list;
    }
}

These collections provide thread-safety guarantees, such as atomicity and visibility, allowing multiple threads to access and modify the data without worrying about concurrency issues.

5. Can you explain the concept of concurrent hash maps in Java?
How do you use them?

ConcurrentHashMap provides a thread-safe implementation of a hash map.
It allows multiple threads to access and modify the map simultaneously, while ensuring that the map remains consistent and correct.
Here’s an example of using ConcurrentHashMap:

public class ConcurrentHashMapExample {
    private final ConcurrentHashMap map = new ConcurrentHashMap<>();
    public void putValue(String key, int value) {
        map.put(key, value);
    }
    public int getValue(String key) {
        return map.getOrDefault(key, 0);
    }
}

In this example, the ConcurrentHashMap is used to store key-value pairs, and multiple threads can call the putValue() and getValue() methods concurrently without worrying about concurrency issues.

6. How do you use ExecutorCompletionService class in Java for asynchronous task execution?

ExecutorCompletionService class in Java provides a way to execute tasks asynchronously and retrieve their results in the order they complete.
Here’s an example:

public class ExecutorCompletionServiceExample {
    private final ExecutorCompletionService completionService;
    public ExecutorCompletionServiceExample() {
        Executor executor = Executors.newFixedThreadPool(5);
        completionService = new ExecutorCompletionService<>(executor);
    }
    public List executeTasks(List> tasks) throws InterruptedException, ExecutionException {
        List> futures = new ArrayList<>();
        for (Callable task : tasks) {
            futures.add(completionService.submit(task));
        }
        List results = new ArrayList<>();
        for (Future future : futures) {
            results.add(completionService.take().get());
        }
        return results;
    }
}

In this example, the ExecutorCompletionServiceExample class uses an ExecutorCompletionService to execute a list of tasks asynchronously.
executeTasks() method submits the tasks to the completion service and retrieves their results in the order they complete using the take() method.

7. Can you explain the concept of thread-local allocation buffers (TLABs) in Java?

Thread-local allocation buffers (TLABs) are a mechanism used by the Java Virtual Machine (JVM) to reduce garbage collection pauses and improve performance.
TLABs are small regions of memory allocated to each thread, where objects are allocated and garbage collected locally.
When a thread allocates an object, the JVM first checks if there is enough space in the TLAB.
If there is, the object is allocated in the TLAB. If not, the JVM allocates a new TLAB or performs a garbage collection.
TLABs reduce garbage collection pauses because they allow threads to allocate objects independently, reducing contention and synchronization overhead.
They also improve performance by reducing the number of garbage collection cycles.

8. How do you use Java Flight Recorder (JFR) and Java Mission Control (JMC) for concurrency profiling and debugging?

Java Flight Recorder (JFR) is a profiling tool that provides detailed information about the JVM’s performance, including concurrency-related metrics. Java Mission Control (JMC) is a graphical interface that allows you to analyze and visualize JFR recordings.
To use JFR and JMC for concurrency profiling and debugging:

Enable JFR by adding the -XX:+FlightRecorder option to the JVM command line.
Start the application and perform the desired operations.
Use JMC to load the JFR recording and analyze the data.
Use the JMC GUI to visualize the concurrency-related metrics, such as thread contention, lock usage, and garbage collection pauses.

9. Can you explain the concept of biased locking in Java?
How does it impact performance?

Biased locking is a technique used by the JVM to optimize lock acquisition and release. When a thread acquires a lock, the JVM biases the lock towards that thread, allowing it to reacquire the lock quickly without contention.
Biased locking can improve performance by reducing the overhead of lock acquisition and release. However, it can also lead to performance issues if multiple threads contend for the same lock, causing biased lock revocation and increased contention.

Multithreading interview questions for 10 years experience

Here are the answers to the interview questions based on Java concurrency for 10 years of experience

1. Can you explain the concept of virtual threads in Java 21?
How do they differ from traditional threads?

Virtual threads are a new concurrency primitive introduced in Java 21.
They are lightweight, efficient, and scalable threads that can be used to write concurrent programs.
Unlike traditional threads, virtual threads are not bound to a specific operating system thread, which makes them more efficient in terms of resource usage and context switching.
Virtual threads are scheduled by the Java runtime, which allows for better control over thread scheduling and reduces the overhead of thread creation and context switching.
This makes virtual threads ideal for I/O-bound operations, such as network requests or database queries.
Here’s an example of creating a virtual thread using the Thread.ofVirtual() method:

Thread virtualThread = Thread.ofVirtual(() -> {
    // Perform some I/O-bound operation
    try (Socket socket = new Socket("example.com", 80)) {
        // Read from the socket
    }
});
virtualThread.start();

2. How do you use Structured Concurrency API in Java 21 for concurrent programming?

The Structured Concurrency API, also known as Project Loom, provides a high-level abstraction for writing concurrent programs using virtual threads.
It allows developers to write concurrent code in a structured way, making it easier to reason about and debug.
The API provides several classes, such as StructuredTaskScope and StructuredExecutor, which can be used to create and manage virtual threads.
Here’s an example of using the StructuredTaskScope class to perform concurrent tasks:

try (var scope = new StructuredTaskScope()) {
    scope.fork(() -> {
        // Perform some task
    });
    scope.fork(() -> {
        // Perform another task
    });
    scope.join();
}

3. Can you explain the concept of scoped values in Java 21?
How do you use them?

Scoped values are a new feature in Java 21 that allows developers to associate values with a scope, such as a virtual thread or a structured task scope.
These values can be accessed within the scope and are automatically cleaned up when the scope is closed.
Scoped values are useful for sharing data between threads or tasks without the need for synchronization.
Here’s an example of using scoped values to share data between tasks:

try (var scope = new StructuredTaskScope()) {
    scope.setScopedValue("data", "Hello, World!");
    scope.fork(() -> {
        String data = scope.getScopedValue("data");
        // Use the data
    });
    scope.join();
}

4. How do you use the new concurrency features in Java 21, such as `Thread.ofVirtual()` and `Thread.startVirtual()`?

The Thread.ofVirtual() method creates a new virtual thread, while the Thread.startVirtual() method starts a virtual thread.
These methods can be used to create and manage virtual threads, which are lightweight and efficient.
Here’s an example of using Thread.ofVirtual() and Thread.startVirtual() to create and start a virtual thread:

Thread virtualThread = Thread.ofVirtual(() -> {
    // Perform some task
});
virtualThread.startVirtual();

5. Can you explain the concept of cooperative scheduling in Java 21?
How does it impact concurrency?

Cooperative scheduling is a scheduling strategy used by the Java runtime to schedule virtual threads.
In cooperative scheduling, threads yield control back to the scheduler voluntarily, allowing for more efficient and fair scheduling.
Cooperative scheduling impacts concurrency by allowing for better responsiveness and throughput.
It enables the Java runtime to schedule threads more efficiently, reducing the overhead of context switching and improving overall system performance.

6. How do you use the `java.lang.Thread` API changes in Java 21, such as `Thread.isVirtual()` and `Thread.getThreadFactory()`?

The Thread.isVirtual() method checks whether a thread is a virtual thread, while the Thread.getThreadFactory() method returns the thread factory used to create the thread.
Here’s an example of using Thread.isVirtual() to check whether a thread is virtual:

Thread thread = Thread.currentThread();
if (thread.isVirtual()) {
    // The thread is virtual
} else {
    // The thread is not virtual
}

7. Can you explain the concept of platform threads in Java 21? How do they differ from virtual threads?

Platform threads are traditional threads that are bound to a specific operating system thread. They are heavyweight and less efficient than virtual threads.
Platform threads differ from virtual threads in that they are scheduled by the operating system, whereas virtual threads are scheduled by the Java runtime. Platform threads are also more resource-intensive and have higher overhead than virtual threads.

8. How do you use the `java.util.concurrent.Executor` API changes in Java 21, such as `Executor.newVirtualThreadExecutor()`?

The Executor.newVirtualThreadExecutor() method creates a new executor that uses virtual threads to execute tasks.
Here’s an example of using Executor.newVirtualThreadExecutor() to create an executor that uses virtual threads:

Executor executor = Executor.newVirtualThreadExecutor();
executor.execute(() -> {
    // Perform some task
});

9. Can you explain the concept of concurrent garbage collection in Java? How does it impact concurrency?

Concurrent garbage collection is a garbage collection strategy that runs concurrently with the application, reducing pause times and improving overall system responsiveness.
Concurrent garbage collection impacts concurrency by allowing the garbage collector to run in parallel with the application, reducing the impact of garbage collection on concurrent programs.

10. How do you use Java’s built-in concurrency support for distributed systems, such as RMI and CORBA?

Java provides built-in support for distributed systems through APIs such as RMI (Remote Method Invocation) and CORBA (Common Object Request Broker Architecture).
These APIs provide a way to write distributed applications that can communicate with each other over a network.
To use Java’s built-in concurrency support for distributed systems, you can use APIs such as java.rmi and org.omg.CORBA to create remote objects and invoke methods on them.
Here’s an example of using RMI to create a remote object:

import java.rmi.*;
public class RemoteObject extends UnicastRemoteObject {
    public void doSomething() throws RemoteException {
        // Perform some task
    }
}

Additional Interview questions on Executor Framework

Here are the answers to the interview questions:

1. Can you explain the concept of thread pools in Java? How do you use Executor framework to create thread pools?

A thread pool is a group of worker threads that are created beforehand and are waiting for tasks to be assigned to them.
When a task is submitted, the thread pool manager assigns it to an available thread in the pool.
This approach improves performance and reduces the overhead of creating new threads for each task.
In Java, you can use the Executor framework to create thread pools.
The Executor framework provides a high-level abstraction for executing tasks asynchronously.
Here’s an example of creating a thread pool using the Executors class:

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

public class ThreadPoolExample {
  public static void main(String[] args) {
    // Create a thread pool with 5 threads
    ExecutorService executor = Executors.newFixedThreadPool(5);
    // Submit tasks to the thread pool
    for (int i = 0; i < 10; i++) {
      Runnable task = new MyTask(i);
      executor.execute(task);
    }
    // Shut down the thread pool
    executor.shutdown();
  }
}

class MyTask implements Runnable {
  private int id;
  public MyTask(int id) {
    this.id = id;
  }
  @Override
  public void run() {
    System.out.println("Task " + id + " is running");
    // Perform some task
  }
}

In this example, we create a thread pool with 5 threads using Executors.newFixedThreadPool(5).
We then submit 10 tasks to the thread pool using executor.execute(task).
The thread pool will execute the tasks concurrently using the available threads.

2. How do you use ExecutorService interface in Java for asynchronous task execution?

The ExecutorService interface is used to manage a pool of threads that can execute tasks asynchronously.
You can submit tasks to the executor service, and it will execute them concurrently using the available threads in the pool.
Here’s an example of using ExecutorService to execute tasks asynchronously:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorServiceExample {
  public static void main(String[] args) {
    // Create an executor service with a thread pool
    ExecutorService executor = Executors.newFixedThreadPool(5);
    // Submit tasks to the executor service
    for (int i = 0; i < 10; i++) {
      Runnable task = new MyTask(i);
      executor.submit(task);
    }
    // Shut down the executor service
    executor.shutdown();
  }
}

class MyTask implements Runnable {
  private int id;
  public MyTask(int id) {
    this.id = id;
  }
  
  @Override
  public void run() {
    System.out.println("Task " + id + " is running");
    // Perform some task
  }
}

In this example, we create an executor service with a thread pool using Executors.newFixedThreadPool(5).
We then submit 10 tasks to the executor service using executor.submit(task).
The executor service will execute the tasks concurrently using the available threads in the pool.

3. Can you explain the concept of scheduled tasks in Java? How do you use ScheduledExecutorService interface?

Scheduled tasks are tasks that are executed at a specific time or after a certain delay.
In Java, you can use the ScheduledExecutorService interface to schedule tasks for execution.
Here’s an example of using ScheduledExecutorService to schedule tasks:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledTaskExample {
  public static void main(String[] args) {
    // Create a scheduled executor service
    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    // Schedule a task to run after 2 seconds
    scheduler.schedule(new MyTask(1), 2, TimeUnit.SECONDS);
    // Schedule a task to run every 5 seconds
    scheduler.scheduleAtFixedRate(new MyTask(2), 0, 5, TimeUnit.SECONDS);
    // Shut down the scheduled executor service
    scheduler.shutdown();
  }
}
class MyTask implements Runnable {
  private int id;
  public MyTask(int id) {
    this.id = id;
  }
    
  @Override
  public void run() {
    System.out.println("Task " + id + " is running");
    // Perform some task
  }
}

In this example, we create a scheduled executor service using Executors.newScheduledThreadPool(5).
We then schedule two tasks: one to run after 2 seconds using scheduler.schedule(task, 2, TimeUnit.SECONDS), and another to run every 5 seconds using scheduler.scheduleAtFixedRate(task, 0, 5, TimeUnit.SECONDS).

4. How do you use ExecutorCompletionService class in Java for asynchronous task execution?

The ExecutorCompletionService class is used to decouple task submission from task completion.
It allows you to submit tasks to an executor service and retrieve the results as they complete.
Here’s an example of using ExecutorCompletionService to execute tasks asynchronously:

import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorCompletionServiceExample {
    public static void main(String[] args) {
        // Create an executor service with a thread pool
        ExecutorService executor = Executors.newFixedThreadPool(5);
        // Create an executor completion service
        ExecutorCompletionService completionService = new ExecutorCompletionService<>(executor);
        // Submit tasks to the completion service
        for (int i = 0; i < 10; i++) {
            Callable task = new MyTask(i);
            completionService.submit(task);
        }
        // Retrieve the results as they complete
        for (int i = 0; i < 10; i++) {
            try {
                Future future = completionService.take();
                System.out.println("Task " + i + " completed: " + future.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        // Shut down the executor service
        executor.shutdown();
    }
}
class MyTask implements Callable {
    private int id;
    public MyTask(int id) {
        this.id = id;
    }
    @Override
    public String call() {
        System.out.println("Task " + id + " is running");
        // Perform some task
        return "Task " + id + " completed";
    }
}

In this example, we create an executor service with a thread pool using Executors.newFixedThreadPool(5).
We then create an ExecutorCompletionService using the executor service.
We submit 10 tasks to the completion service using completionService.submit(task).
Finally, we retrieve the results as they complete using completionService.take() and future.get().

5. Can you explain the concept of thread factory in Java?
How do you use ThreadFactory interface?

A thread factory is a mechanism for creating new threads in a thread pool.
In Java, you can use the ThreadFactory interface to create custom thread factories.
Here’s an example of using ThreadFactory to create custom threads:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
public class ThreadFactoryExample {
  public static void main(String[] args) {
    // Create a custom thread factory
    ThreadFactory threadFactory = new CustomThreadFactory();
    // Create an executor service with the custom thread factory
    ExecutorService executor = Executors.newFixedThreadPool(5, threadFactory);
    // Submit tasks to the executor service
    for (int i = 0; i < 10; i++) {
      Runnable task = new MyTask(i);
      executor.execute(task);
    }
    // Shut down the executor service
    executor.shutdown();
  }
}

class CustomThreadFactory implements ThreadFactory {
  @Override
  public Thread newThread(Runnable r) {
    Thread thread = new Thread(r);
    thread.setName("CustomThread-" + thread.getId());
    return thread;
  }
}

class MyTask implements Runnable {
  private int id;
  public MyTask(int id) {
    this.id = id;
  }
  
  @Override
  public void run() {
    System.out.println("Task " + id + " is running");
    // Perform some task
  }
}

In this example, we create a custom thread factory using CustomThreadFactory.
We then create an executor service using Executors.newFixedThreadPool(5, threadFactory), passing the custom thread factory as an argument.
The executor service will use the custom thread factory to create new threads for executing tasks.

Note that these questions are meant to be starting points and can be tailored to the specific requirements of the position and the company.
Additionally, the experience level is just a rough guide, and the actual difficulty of the questions may vary depending on the individual’s skills and knowledge.

Top Java Multithreading Interview Questions For Freshers And Experienced