Concurrency

Question 1

Synchronization

Answer 1

It is a JVM feature that ensures that two or more concurrent threads dont simultaneously execute a critical section.

Question 2

Visibility

Answer 2

It ensures that a thread executing in a critical section always sees the most recent changes to shared variables.
It reads these variables from main memory on entry to the critical section and writes their values to main memory on exit.

Question 3

Deadlock

Answer 3

Thread 1 waits for a resource that thread 2 is holding
exclusively and thread 2 is waiting for a resource that thread 1 is holding exclusively. Neither thread can make progress.

Question 4

Livelock

Answer 4

Thread x keeps retrying an operation that will always
fail. It cannot make progress for this reason.

Question 5

Starvation

Answer 5

Thread x is continually denied (by the scheduler)
access to a needed resource in order to make progress. Perhaps the scheduler executes higher-priority threads before lower-priority threads and there is always a higher-priority thread available for execution. Starvation is also commonly referred to as
indefinite postponement.

Question 6

🔒 ReentrantLock

Answer 6

A mutual exclusion lock with advanced features like try-lock, fairness, and interruptible lock acquisition.

Question 7

Semaphore

Answer 7

Controls access to a resource via a set number of permits. Think of it as a counter.

Question 8

CountDownLatch

Answer 8

Waits until a certain number of events (threads) complete before continuing.

Question 9

CyclicBarrier

Answer 9

Waits until a group of threads reach a common barrier point, then lets all proceed. Can be reused.

Question 10

Phaser

Answer 10

A flexible synchronizer for phased tasks (like CyclicBarrier but more dynamic).
dynamic version of CyclicBarrier

Question 11

Exchanger

Answer 11

Allows two threads to exchange data at a synchronization point.

Question 12

SynchronousQueue

Answer 12

A queue with zero capacity — each insert must wait for a remove. Used for handoffs.

Question 13

Core Java Concurrency Classes

Answer 13

1. Executors and Thread Pools
2. Task Interfaces
3. Synchronization Utilities
4. Concurrent Collections
5. Locks and Synchronizations
6. Atomic Variables

Question 14

Executors and Thread Pools

Answer 14

-Executor
-ExecutorService
-ScheduledExecutorService​

Question 15

Task Interfaces

Answer 15

Define tasks for concurrent execution.

-Runnable
-Callable
-Future
-CompletableFuture

Question 16

Synchronization Utilities

Answer 16

-CountDownLatch
-CyclicBarrier
-Semaphore
-Exchanger
-Phaser

Question 17

Concurrent Collections

Answer 17

ConcurrentHashMap
CopyOnWriteArrayList
ConcurrentLinkedQueue
BlockingQueue
DelayQueue

Question 18

Locks and Synchronizers

Answer 18

ReentrantLock
ReadWriteLock
StampedLock
LockSupport​

Question 19

newSingleThreadExecutor()

Answer 19

Creates executor that uses a single worker thread operating off an unbounded queue

Question 20

newFixedThreadPool(int nThreads)

Answer 20

Creates a thread pool with a fixed number of threads.

Question 21

newCachedThreadPool()

Answer 21

Creates a thread pool that creates new threads as needed and reuses previously constructed threads when available.

Question 22

newScheduledThreadPool(int corePoolSize)

Answer 22

Creates a thread pool that can schedule commands to run after a delay or periodically.

Question 23

newSingleThreadScheduledExecutor()

Answer 23

Creates a thread pool that can schedule commands to run after a delay or periodically.
Same as above, but uses only one thread.

Question 24

newWorkStealingPool()

Answer 24

Creates a work-stealing thread pool using multiple queues (Java 8+).

Question 25

execute(Runnable) vs submit(Callable)

Answer 25

-no return value -returns a Future Runnable has no return value. Only Callable can return a result.

Question 26

Runnable short summary

Answer 26

No result, no exception handling. Just "run it." ❌ No return value ❌ No throwing checked exception ❌ No chaining ✅ Supports Asynch

Question 27

Callable short summary

Answer 27

Runnable’s Smarter Cousin ✅ Returns value ✅ Throws Checked exception ✅ Suppots Asynch ❌ No chaining Use Callable when you want the task to return a result or throw exceptions.

Question 28

Future short summary

Answer 28

The Promise of a Result ❌ No chaining ❌ No Asynch Support (Not native) ✅ Returns value ✅ Throws Checked exception -get()

Question 29

CompletableFuture short summary

Answer 29

Non-blocking, reactive-style async programming. ✅ Returns Value ✅ Throws Checked Exception ✅ Asynch Support ✅ Chaining

Question 30

ConcurrentHashMap

Answer 30

The most commonly used atomic collection. Allows thread-safe read and write operations. Segmented internally for high performance under concurrency.

Question 31

CopyOnWriteArrayList

Answer 31

Thread-safe version of ArrayList. Best for read-heavy, write-rarely use cases. On every mutation, it creates a new copy of the array.

Question 32

CopyOnWriteArraySet

Answer 32

Backed by CopyOnWriteArrayList. Ensures no duplicates. Safe iteration without ConcurrentModificationException.

Question 33

ConcurrentLinkedQueue

Answer 33

A non-blocking, thread-safe FIFO queue. Ideal for high-concurrency environments. Based on a lock-free algorithm using CAS (Compare-And-Swap).

Question 34

ConcurrentLinkedDeque

Answer 34

Same as ConcurrentLinkedQueue but double-ended (can add/remove from both ends).

Question 35

LinkedBlockingQueue LinkedBlockingDeque

Answer 35

Blocking versions of queues and deques. Support blocking take/put operations using wait() internally. A FIFO (First-In-First-Out) blocking queue backed by a linked list. Thread-safe Allows blocking put() and take() Used in producer-consumer designs

Question 36

When to Use Atomic Classes

Answer 36

-You need lightweight, lock-free thread safety. -Replacing synchronized or volatile for performance. -You want low-level control over concurrency (e.g., counters, flags, shared data). -You're building custom concurrent structures.

Question 37

AtomicInteger

Answer 37

A thread-safe integer that supports atomic operations like incrementAndGet(), compareAndSet(), etc. Use Case: Atomic counters

Question 39

AtomicLong

Answer 39

Same as AtomicInteger, but for long values. Useful for unique IDs, timestamps, counters across threads.

Question 40

AtomicBoolean

Answer 40

-Useful when you want to track a flag atomically — like a toggle or a running status. -Great for one-time initialization or ensuring a task runs once.

Question 41

AtomicReference

Answer 41

Allows atomic operations on object references. Great for immutability, shared mutable state, or custom compare-and-set logic.

Question 42

AtomicStampedReference / AtomicMarkableReference

Answer 42

These help with versioning or avoiding ABA problems in lock-free algorithms. AtomicStampedReference → Holds a reference and a version number (stamp). AtomicMarkableReference → Holds a reference and a boolean flag (mark). Advanced use in lock-free data structures, not common in business apps.

Question 43

🔧 What is Compare-And-Swap (CAS)?

Answer 43

CAS is a low-level atomic instruction used to safely update a variable in memory only if it hasn't been changed by another thread. It's like saying: "I'll only set this value if it's still what I last saw." Imagine you're updating a whiteboard score with a marker: You read the score: 42. You go to write 43, but before you do, someone else changes it to 44. Your update would be invalid, because the original value isn’t 42 anymore. So you recheck the value before updating — that's CAS.

Question 44

What compareAndSet(10, 11) does:

Answer 44

If current value is 10, it sets it to 11. If current value is not 10, it does nothing and returns false.