Process: independent memory space

Thread: lightweight execution unit within a process, shares memory

Concurrency: interleaving tasks on one/more cores

Parallelism: truly simultaneous execution on multiple cores

NEW

RUNNABLE

BLOCKED

WAITING

TIMED_WAITING

TERMINATED

OS/JVM scheduling is not deterministic

Priority hints (1–10) are not guarantees

Visibility, atomicity, ordering

Happens-before relationships (e.g., locks, volatile, thread start/join)

Override `run()`, start with `start()`

Limitations: single inheritance, less flexible

Implement `run()`, pass to `new Thread(r).start()`

Preferred for separating task from thread

`Callable<V>` returns a value, can throw checked exceptions

Execute via `ExecutorService.submit()` → `Future<V>`

`Executors.newFixedThreadPool(n)`

`Executors.newCachedThreadPool()`

`Executors.newSingleThreadExecutor()`

Benefits: reuse threads, manage queueing, control resources

`ForkJoinPool`, `RecursiveTask/RecursiveAction`

Work-stealing for divide-and-conquer tasks

`supplyAsync/runAsync`, chaining with `thenApply/thenCompose`

Combine tasks: `allOf/anyOf`

`synchronized` methods/blocks (monitor lock)

Guarantees mutual exclusion + visibility (happens-before on unlock/lock)

Visibility + ordering guarantees

Not sufficient for compound atomic operations (e.g., `count++`)

`AtomicInteger/AtomicLong/AtomicReference`

Non-blocking updates via compare-and-swap

`ReentrantLock`

Read/Write Locks

StampedLock

`wait/notify/notifyAll` (must hold intrinsic lock)

`Condition.await/signal/signalAll` (with `Lock`)

Higher-level utilities

`ConcurrentHashMap`

`CopyOnWriteArrayList` (read-heavy, write-light)

Blocking Queues

Use `BlockingQueue` for backpressure and safe handoff

Prefer `ExecutorService` over manual thread management

Reduce synchronization needs, safer sharing

Use local variables, `ThreadLocal` for per-thread state

Unsafely shared mutable state

Fix: synchronization, atomics, confinement, immutability

Circular lock acquisition

Mitigation: lock ordering, timeouts, reduce lock scope

Threads active but no progress / unfair scheduling

Mitigation: fairness, backoff, avoid excessive contention

Stale reads without proper happens-before (need locks/volatile)

Reduced throughput, contention hot spots

`shutdown()` / `shutdownNow()` and await termination

Stress tests, race detection tools, thread dumps

`jstack`, IDE tools, `jcmd Thread.print`

JFR (Java Flight Recorder), VisualVM, Mission Control

Include thread names/ids; avoid excessive synchronized logging;