Concurrency Terminology — Interview Reference

Why this matters in interviews

Senior interviewers expect you to use precise vocabulary without hesitation. Saying "the thread can see stale data because of caching" is weaker than "without a happens-before edge, the JMM permits the JIT to keep the value in a register — there's no visibility guarantee." This lesson is a reference dictionary: read it before your interview, use it during.

Concept

Thread & Scheduling

---

Memory & Visibility

---

Synchronization Primitives

---

Concurrency Problems

---

Lock-Free / CAS

---

Thread Pool

---

Async / Future

---

Synchronizers

Key rules / gotchas

• Happens-before is transitive: A hb B and B hb C implies A hb C. Chain these rules to reason about any visibility guarantee.
• volatile ≠ atomic: volatile int i; i++ is still a race condition — read-modify-write is three steps.
• Deadlock requires four conditions: mutual exclusion, hold-and-wait, no preemption, circular wait. Breaking any one prevents it.
• Lock-free ≠ wait-free: lock-free only guarantees some thread makes progress. Under extreme contention one thread may keep losing the CAS retry.
• Thread pool sizing is workload-dependent: never use a magic number — measure your wait/compute ratio.
• thenApply vs thenCompose: same as map vs flatMap — use thenCompose when the next step itself returns a CompletableFuture.

Code example

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;

public class JavaLabRunner {
    // Demonstrates several vocabulary terms in one place
    static final ReentrantLock mutex = new ReentrantLock(true); // fair mutex
    static final AtomicInteger casCounter = new AtomicInteger(0);
    static final Semaphore permits = new Semaphore(2); // max 2 concurrent
    static volatile boolean stop = false; // visibility guarantee via happens-before

    public static void main(String[] args) throws Exception {
        // CAS — compare-and-swap
        boolean swapped = casCounter.compareAndSet(0, 42);
        System.out.println("CAS succeeded: " + swapped + ", value: " + casCounter.get());

        // Mutex (fair ReentrantLock) — reentrant
        mutex.lock();
        try {
            System.out.println("Hold count (reentrant depth): " + mutex.getHoldCount()); // 1
            mutex.lock(); // reentrant — same thread can lock again
            try {
                System.out.println("Hold count after reentry: " + mutex.getHoldCount()); // 2
            } finally { mutex.unlock(); }
        } finally { mutex.unlock(); }

        // Semaphore — limits concurrency to 2
        ExecutorService pool = Executors.newFixedThreadPool(4);
        CountDownLatch done = new CountDownLatch(4); // one-shot barrier
        for (int i = 0; i < 4; i++) {
            final int id = i;
            pool.submit(() -> {
                try {
                    permits.acquire(); // blocks if 2 already inside
                    System.out.println("Thread " + id + " acquired permit");
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    permits.release();
                    done.countDown(); // decrement latch
                }
            });
        }
        done.await(); // main thread blocks until all 4 finish
        System.out.println("All threads completed (CountDownLatch released)");

        // volatile stop flag — visibility via happens-before
        Thread worker = new Thread(() -> {
            while (!stop) { /* spin */ }
            System.out.println("Worker saw stop=true (volatile visibility)");
        });
        worker.start();
        Thread.sleep(5);
        stop = true; // volatile write happens-before the next volatile read
        worker.join();

        pool.shutdown();
    }
}

Interview questions you should be able to answer

• Q: What is the difference between a race condition, a deadlock, and a livelock?

  Race condition: non-deterministic outcome from unsynchronized shared access. Deadlock: circular lock dependency — all threads block forever. Livelock: threads keep reacting to each other but no thread makes progress (no blocking, but no work either).

• Q: What does "happens-before" mean in the JMM?

  A formal ordering guarantee: if action A happens-before action B, all writes visible at A are guaranteed to be visible at B. Sources include: program order, monitor release/acquire, volatile write/read, thread start/join, and transitivity.

• Q: What is the difference between lock-free and wait-free?

  Lock-free guarantees that at least one thread makes progress system-wide — other threads may starve. Wait-free guarantees every thread completes in a bounded number of steps regardless of contention. Wait-free is strictly stronger and harder to implement.

• Q: What is false sharing and how do you fix it?

  Two variables on the same 64-byte CPU cache line. When Thread A writes one, Thread B's cache line for the other is invalidated — causing cache thrashing with no logical sharing. Fix: pad structs to 64 bytes, or use @Contended (JVM flag -XX:-RestrictContended). LongAdder avoids this by distributing counters across separate cache lines (cells).

• Q: When would you use CallerRunsPolicy as a rejection policy?

  When you want natural backpressure — if the pool is saturated, the submitting thread executes the task itself, slowing down the producer and giving workers time to drain the queue. Avoids dropping tasks or throwing exceptions.

• Q: What is the ABA problem and which Java class solves it?

  A CAS reads value A, another thread changes it to B then back to A. The CAS succeeds even though the state changed — in linked structures this can cause a node to be relinked incorrectly. AtomicStampedReference adds a version stamp alongside the value so compareAndSet checks both the reference and the stamp.

Further reading

• JSR-133 Java Memory Model
• Java Concurrency in Practice — Goetz et al.
• OpenJDK: AbstractQueuedSynchronizer