A multi-threaded application experiences poor performance despite having adequate CPU cores. Code inspection reveals frequent calls to synchronized blocks on shared objects. Which modern Java feature (2024-25) could optimize this without major refactoring?
AVirtual Threads with appropriate lock strategies
BIncreasing thread pool size
CUsing volatile keyword everywhere
DConverting all methods to static
Correct Answer:
A. Virtual Threads with appropriate lock strategies
EXPLANATION
Virtual Threads (Project Loom, stable in Java 21+) allow massive parallelism with lightweight threads, reducing contention overhead. They enable better scaling than increasing pool size. volatile doesn't help with synchronized block contention, and static conversion is inappropriate.
In a producer-consumer scenario using BlockingQueue, what happens when a consumer thread calls take() on an empty queue?
AIt throws NoSuchElementException immediately
BIt blocks until a producer adds an element
CIt returns null
DIt spins in a busy-wait loop
Correct Answer:
B. It blocks until a producer adds an element
EXPLANATION
BlockingQueue's take() method blocks the calling thread until an element becomes available. This is safer and more efficient than busy-waiting. NoSuchElementException is thrown by non-blocking operations like remove().
What exception does CyclicBarrier throw when a thread is interrupted while waiting?
AInterruptedException
BBrokenBarrierException
CCyclicBarrierException
DThreadInterruptedException
Correct Answer:
A. InterruptedException
EXPLANATION
When a thread waiting at a CyclicBarrier is interrupted, it throws InterruptedException. This breaks the barrier and causes other waiting threads to receive BrokenBarrierException.
What is the output of this code snippet?
ExecutorService es = Executors.newFixedThreadPool(2);
es.execute(() -> System.out.println("Task 1"));
es.shutdown();
ATask 1 will be executed before the program terminates
BTask 1 may or may not be executed
CCompilation error
DTask 1 will never execute
Correct Answer:
A. Task 1 will be executed before the program terminates
EXPLANATION
shutdown() gracefully shuts down the executor service by rejecting new tasks but allowing submitted tasks to complete. Task 1 is already submitted before shutdown(), so it will execute.
In Java 21, which new feature was introduced for concurrent programming?
AVirtual Threads (Project Loom)
BReentrantLock
CCountDownLatch
DPhaser
Correct Answer:
A. Virtual Threads (Project Loom)
EXPLANATION
Java 21 introduced Virtual Threads as part of Project Loom, which are lightweight threads that make it easier to write scalable concurrent applications.
What does the volatile keyword guarantee in multithreading?
APrevents thread access completely
BVisibility of changes across threads and prevents instruction reordering
CMakes operations atomic
DAutomatically synchronizes all methods
Correct Answer:
B. Visibility of changes across threads and prevents instruction reordering
EXPLANATION
volatile ensures that changes to a variable are immediately visible to all threads and prevents the JVM from reordering instructions. However, it doesn't make operations atomic.
Which Java class provides thread-safe operations using Compare-And-Swap (CAS)?
AVector
BCollections.synchronizedList()
CAtomicInteger
DConcurrentHashMap
Correct Answer:
C. AtomicInteger
EXPLANATION
AtomicInteger and other Atomic* classes use CAS operations for lock-free thread-safe operations. ConcurrentHashMap uses segment-based locking, not CAS.
What is the purpose of the yield() method in Java threading?
ATo permanently stop the current thread
BTo suggest that the current thread should yield CPU to other threads of equal priority
CTo make a thread wait indefinitely
DTo increase thread priority
Correct Answer:
B. To suggest that the current thread should yield CPU to other threads of equal priority
EXPLANATION
yield() is a hint to the thread scheduler that the current thread is willing to yield its current use of CPU. It doesn't guarantee the thread will yield, as scheduling is JVM-dependent.
Consider the code:
synchronized void method1() { wait(); }
If wait() is called without a lock, what happens?
AThe thread waits indefinitely
BIllegalMonitorStateException is thrown
CThe method returns normally
DCompilation error occurs
Correct Answer:
B. IllegalMonitorStateException is thrown
EXPLANATION
wait() must be called from within a synchronized block or method. If called outside synchronized context, it throws IllegalMonitorStateException at runtime.
