Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Java · Question Set
Java Concurrency & Executors interview questions for placements and exams.
Questions
13
Included in this set
Subject
Java
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Java.
Executors pool and reuse threads, reducing overhead and providing lifecycle control. Ordering and mutual exclusion are not guaranteed unless you choose specific executors or add your own coordination.
For complete preparation, combine this set with full subject-wise practice for Java. You can also explore other subjects and sets from the links below.
Future.get() is a blocking wait. Use the timed overload to bound waiting, and handle InterruptedException, ExecutionException, or CancellationException.
Blocking queues provide built-in backpressure: producers wait when full, consumers wait when empty. Fairness and ordering depend on the specific implementation.
Runnable separates the work from the execution mechanism, allowing reuse with pools and avoiding subclassing limits. You start a thread with start(), which calls run() internally. A terminated thread cannot be restarted.
Only start() creates a new OS-level thread managed by the JVM. Calling run() is just a normal method call on the current thread.
Entering a synchronized block acquires the monitor; exiting establishes a happens-before edge that flushes writes to main memory. It ensures mutual exclusion and visibility but not fairness.
volatile provides visibility and ordering for single-variable reads/writes. It does not provide atomicity for compound operations like increment; use synchronization or atomic classes for that.
ReentrantLock supports tryLock (with or without timeout) and lockInterruptibly, plus optional fairness policy at construction. It does not inherently prevent deadlocks.
Atomic classes provide non-blocking, single-variable atomicity. They do not group multiple variables atomically; for that, use locks or higher-level constructs.
Deadlock occurs when threads hold locks the others need, and none can proceed. Avoidance strategies: 1) Establish a global lock ordering and always acquire locks in that order. 2) Use tryLock with timeout to detect and back off. Additional tips: minimize lock scope, prefer immutable data, and use higher-level concurrent structures.
1) Immutability: immutable objects can be shared freely—no races on state. 2) Confinement: keep mutable state confined to a single thread (e.g., ThreadLocal or task confinement) to avoid sharing. 3) Stateless functions and message passing: prefer pure functions; exchange data via queues, reducing shared mutable state. These reduce contention and simplify reasoning.
thenApply maps a result; thenCompose chains async stages avoiding nested futures. thenRun ignores the value; handle observes both result and exception. allOf returns a CompletableFuture<Void>.
Fork/Join targets divide-and-conquer algorithms. Workers steal tasks from others’ deques to stay busy. It’s not intended for I/O-heavy workloads nor does it preserve order.