Comprehensive Guide to Java Concurrency: Concepts, Synchronization, Thread Pools, and the Java Memory Model

Introduction The article is based largely on the book "JAVA High Concurrency Programming" and serves as a detailed note and extension on Java concurrency concepts.

Synchronous vs Asynchronous A synchronous method call blocks the caller until the method returns, whereas an asynchronous call returns immediately, allowing the caller to continue while the method executes in another thread.

Concurrency vs Parallelism Concurrency refers to the logical interleaving of tasks, while parallelism describes actual simultaneous execution on multiple cores. A link to a separate article explains the distinction.

Critical Section A critical section is a shared resource that only one thread may access at a time, similar to a single printer being used by multiple users.

Blocking vs Non‑Blocking Blocking occurs when a thread waits for a critical section, causing it to be suspended. Non‑blocking means no thread can prevent others from progressing; threads keep attempting forward execution.

Deadlock, Starvation, Livelock These are thread liveness problems. Deadlock is the worst case where threads hold each other's resources forever. Starvation occurs when a thread never acquires needed resources, often due to low priority. Livelock happens when threads repeatedly yield resources without making progress.

Concurrency Levels Based on control strategies, concurrency can be classified as blocking, starvation‑free, obstruction‑free, lock‑free, and wait‑free. Blocking threads wait for a lock; starvation‑free threads use fair locks; obstruction‑free threads may roll back on conflict; lock‑free guarantees at least one thread finishes in bounded steps; wait‑free ensures all threads finish in bounded steps.

Amdahl’s and Gustafson’s Laws Amdahl’s law defines speedup as the ratio of original to optimized execution time and shows that adding more CPUs yields diminishing returns if the serial portion remains large. Gustafson’s law argues that if the parallel portion dominates, speedup scales linearly with the number of processors.

Java Memory Model (JMM) JMM defines the guarantees for atomicity, visibility, and ordering in multithreaded programs. Atomicity – an operation is indivisible; e.g., assigning an int is atomic, but assigning a long on a 32‑bit JVM is not. i = Integer.valueOf(i.intValue() + 1); Visibility – changes to a shared variable become visible to other threads, which can be broken by CPU caches or compiler optimizations. Ordering – instruction reordering can change the apparent execution order, leading to subtle bugs.

Thread Lifecycle All thread states are defined in Thread.State. The article references a diagram of the lifecycle.

Basic Thread Operations Start, interrupt, isInterrupted, and interrupted methods are described, with signatures wrapped in

tags:<br/><code>public void Thread.interrupt()

public boolean Thread.isInterrupted()

public static boolean Thread.interrupted()

wait() and notify() These Object methods enable thread coordination. A thread must hold the object's monitor to call wait or notify; wait releases the monitor, notify wakes a waiting thread.

Suspend/Resume (Deprecated) Suspend does not release locks, leading to deadlock; resume restarts a suspended thread. The article shows image examples.

Thread Interruption vs stop() Interrupt is a safe way to request termination; stop() is unsafe and deprecated.

Thread Priority Higher‑priority threads have a better chance of acquiring resources, but scheduling depends on the OS.

synchronized Keyword Provides mutual exclusion, visibility, and ordering guarantees. Usage examples include locking on an object, instance methods, static methods, and common pitfalls such as locking on immutable Integer objects.

Thread Pools ThreadPoolExecutor is the core implementation. Executors factory methods (fixed, single, cached, scheduled) create pools with different characteristics. The article explains work queues (SynchronousQueue, ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue) and their impact on thread creation and task handling.

Rejection Policies When the pool and queue are saturated, four built‑in policies are available: AbortPolicy, CallerRunsPolicy, DiscardOldestPolicy, and DiscardPolicy.

ReentrantLock Replaces synchronized with better flexibility. Methods like lockInterruptibly() allow a waiting thread to be interrupted. The article also covers tryLock, fair vs non‑fair locks, and Condition objects (await, signal, etc.).

Semaphore, ReadWriteLock, CountDownLatch, CyclicBarrier These concurrency utilities provide counting semaphores, read/write separation, thread coordination, and barrier synchronization.

LockSupport Provides park/unpark methods for low‑level blocking without needing a monitor.

Concurrent Collections JDK offers thread‑safe containers: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, BlockingQueue implementations, and SkipList‑based ConcurrentSkipListMap. The article explains their use cases and internal structures.

Summary Effective Java concurrency requires understanding of synchronization primitives, memory visibility, thread lifecycle, and the rich set of utilities provided by the JDK. Proper selection of locks, thread‑pool configurations, and concurrent collections enables scalable, correct multithreaded applications.