Core Concepts
Process vs Thread
Process: independent memory space, heavier context switching
Thread: shared memory within a process, lighter context switching
Concurrency vs Parallelism
Concurrency: multiple tasks make progress via time-slicing
Parallelism: tasks run simultaneously on multiple cores
Thread Lifecycle (Java `Thread.State`)
NEW: created but not started
RUNNABLE: ready/running on CPU
BLOCKED: waiting to acquire a monitor lock
WAITING: waiting indefinitely (e.g., `Object.wait()`, `LockSupport.park()`, `Thread.join()`)
TIMED_WAITING: waiting with timeout (e.g., `sleep`, timed `wait/join`, `parkNanos`)
TERMINATED: finished execution
Scheduling & Priorities
JVM delegates scheduling to OS (mostly preemptive)
`setPriority` is advisory and platform-dependent
Memory Model Basics (JMM)
Shared variables live in main memory; threads may cache values
Happens-before rules define visibility and ordering guarantees
Data race: unsynchronized concurrent access where at least one is a write
Creating & Running Threads
Extending `Thread`
Override `run()`, call `start()` to create a new OS thread
Limitations: single inheritance, mixes task with thread control
Implementing `Runnable`
Pass task to `new Thread(runnable).start()`
Preferred for separating task from thread
Implementing `Callable<V>`
Returns a value and can throw checked exceptions
Used with `FutureTask` or Executor framework
Executor Framework (Recommended)
Benefits
Thread reuse, resource management, task queuing
Separation of submission from execution policy
Common Executors / Factories
`Executors.newFixedThreadPool(n)`: bounded number of threads
`Executors.newCachedThreadPool()`: elastic threads, may grow unbounded
`Executors.newSingleThreadExecutor()`: single worker thread, ordered tasks
`Executors.newScheduledThreadPool(n)`: delayed/periodic tasks
`ThreadPoolExecutor` (fine-grained control)
Work queue types
`LinkedBlockingQueue`: potentially unbounded queueing
`ArrayBlockingQueue`: bounded queueing
`SynchronousQueue`: direct handoff, favors scaling threads
Rejection policies
`AbortPolicy`, `CallerRunsPolicy`, `DiscardPolicy`, `DiscardOldestPolicy`
Thread factory: naming, daemon threads, uncaught exception handler
Fork/Join Framework
`ForkJoinPool`, `RecursiveTask/RecursiveAction`
Work-stealing for divide-and-conquer workloads
Virtual Threads (Project Loom, Java 21+)
Lightweight threads for high-concurrency I/O-bound workloads
Create via `Thread.ofVirtual().start(...)` or `Executors.newVirtualThreadPerTaskExecutor()`
Still need synchronization correctness; blocking is cheaper
Synchronization & Mutual Exclusion
Intrinsic Locks (`synchronized`)
Monitor per object; mutual exclusion + visibility guarantees
Forms
Synchronized instance method: locks `this`
Synchronized static method: locks `Class` object
Synchronized block: locks specified monitor
Reentrancy: same thread can re-acquire the same monitor
Pitfalls
Locking on publicly accessible objects (e.g., `String`) risks interference
Deadlocks via inconsistent lock ordering
Explicit Locks (`java.util.concurrent.locks`)
`ReentrantLock`
`lock()/unlock()` must be in `try/finally`
Features: fairness option, `tryLock`, interruptible lock acquisition
`ReadWriteLock` / `ReentrantReadWriteLock`
Multiple readers, single writer
Useful for read-heavy shared data
`StampedLock`
Optimistic reads, read/write stamps
Not reentrant; careful with validation and upgrade patterns
Atomic Variables (Lock-free basics)
`AtomicInteger/Long/Reference`, `AtomicStampedReference`, `LongAdder`, `LongAccumulator`
CAS (Compare-And-Set) semantics
Use cases
Counters, flags, simple state transitions
`LongAdder` for high-contention counters
Immutability & Thread Confinement
Immutable objects are inherently thread-safe
Confinement patterns
Stack confinement (local variables)
ThreadLocal storage (`ThreadLocal<T>`)
Single-threaded ownership (actor-like)
Visibility, Ordering, and `volatile`
`volatile` guarantees
Visibility: writes by one thread become visible to others
Ordering: prevents reordering around volatile reads/writes (happens-before)
What `volatile` does NOT guarantee
Atomicity for compound actions (e.g., `i++`, check-then-act)
Common patterns
Volatile flag for shutdown/cancellation
Safe publication of immutable objects via volatile reference
Coordination & Communication Between Threads
`wait/notify/notifyAll` (Object monitors)
Must hold the same monitor to call `wait/notify`
Use `while` loops to guard against spurious wakeups
Prefer higher-level constructs when possible
`Condition` (with `Lock`)
Multiple wait-sets per lock (`newCondition()`)
More flexible signaling than monitor methods
Latches, Barriers, Phasers
`CountDownLatch`: one-time gate, await until count reaches zero
`CyclicBarrier`: reusable barrier for phases, optional barrier action
`Phaser`: dynamic parties, multiple phases
Semaphores & Exchangers
`Semaphore`: permits to bound concurrency (resource pool)
`Exchanger`: two threads swap data at rendezvous
Blocking Queues (Producer–Consumer)
Types: `ArrayBlockingQueue`, `LinkedBlockingQueue`, `PriorityBlockingQueue`, `DelayQueue`, `SynchronousQueue`
Methods
`offer/poll` with timeout for responsiveness
Futures and Completions
`Future`
`get()` blocks, cancellation via `cancel(true)`
`CompletableFuture`
Async pipelines: `thenApply/thenCompose/thenCombine`
Error handling: `exceptionally/handle/whenComplete`
Custom executors to avoid common pool issues
Common Concurrency Problems
Race Conditions
Lost updates, inconsistent reads
Fix: synchronize, atomic variables, confinement, immutable state
Deadlock
Circular wait on multiple locks
Prevention
Reduce lock scope, avoid nested locks
Livelock
Threads react to each other but make no progress
Mitigation: backoff, randomness, redesign protocol
Starvation
Thread never gets CPU/lock due to unfair scheduling
Mitigation: fairness locks, balanced work, avoid long critical sections
Priority Inversion
Low-priority thread holds lock needed by high-priority thread
Mitigation: minimize lock hold time, OS support (limited), design changes
False Sharing
Independent variables share a cache line causing contention
Mitigation: padding, `@Contended` (with JVM flags), redesign data layout
Thread Safety & Safe Publication
Thread-safe classes
Properly synchronized mutable objects
Safe publication techniques
Final fields and correct construction
Publish via `volatile` reference
Publish via thread-safe collections
Static initialization (class initialization is thread-safe)
Common anti-patterns
Escaping `this` during construction
Double-checked locking without `volatile` (pre-Java 5 issue; now requires `volatile`)
Concurrent Collections & Utilities
Concurrent Maps/Sets
`ConcurrentHashMap`
High concurrency, non-blocking reads
Atomic operations: `compute`, `computeIfAbsent`, `merge`
`ConcurrentSkipListMap/Set`: sorted, scalable
Copy-on-write collections
`CopyOnWriteArrayList/Set`
Great for read-mostly, expensive for writes
Queues/Deques
`ConcurrentLinkedQueue/Deque`: lock-free non-blocking
`LinkedBlockingDeque`: blocking double-ended
Synchronizers and Locks utilities
`LockSupport`: park/unpark primitives
`AbstractQueuedSynchronizer (AQS)`: foundation for many locks/synchronizers
Best Practices & Design Guidelines
Prefer higher-level concurrency constructs
Executors, concurrent collections, atomic classes, latches/barriers
Keep critical sections small
Reduce contention and risk of deadlocks
Avoid shared mutable state when possible
Immutable data, message passing, confinement
Define clear lock ordering
Document locking strategy and invariants
Use timeouts and cancellation
`tryLock(timeout)`, `Future.get(timeout)`, cooperative cancellation
Handle interrupts correctly
Don’t swallow `InterruptedException`
Restore interrupt status when needed: `Thread.currentThread().interrupt()`
Naming and monitoring threads
Meaningful thread names, uncaught exception handlers
Metrics: queue sizes, pool utilization, rejection counts
Testing, Debugging & Observability
Testing strategies
Stress tests, randomized scheduling, repeated runs
Use tools/libraries (e.g., jcstress) for memory-model edge cases
Diagnostics tools
`jstack`: thread dumps, deadlock detection
Java Flight Recorder (JFR): profiling contention, blocking
VisualVM / JMC: CPU, threads, monitors
Logging considerations
Avoid logging inside hot locks
Include thread name and correlation IDs
Typical Use Cases & Patterns
Producer–Consumer
Blocking queues, backpressure
Read-mostly caches
`ConcurrentHashMap` + `computeIfAbsent`
Immutable snapshots, COW lists
Parallel computation
Fork/Join, parallel streams (with care), custom pools
Async I/O workflows
`CompletableFuture`, virtual threads, reactive frameworks (conceptually)
Apply the right abstraction to the workload (queues for handoff, pools for execution policy, fork/join for CPU parallelism, virtual threads for I/O), then enforce safety via visibility + synchronization rules.
Wondershare EdrawMind
