Unlocking Java Concurrency: Master Threads, Locks, and Thread Pools

Concurrency is essential for handling thousands of simultaneous requests in modern IT systems and everyday services like train stations and elevators.

Why Java Concurrency?

Java aims to reduce programmer complexity; despite slower performance, its evolving runtime improves efficiency.

Key Metrics

Response Time : time from request receipt to response.

Throughput : number of requests processed per unit time.

Concurrent Users : number of users the system can serve simultaneously.

Improving Concurrency

Upgrade hardware (more CPU cores, SSDs, memory).

Optimize architecture (e.g., use in‑memory data instead of frequent DB access).

Scale out with more servers.

Fundamentals of Concurrent Programming

Benefits include full utilization of multi‑core CPUs, easier business decomposition, and better performance for high‑traffic scenarios. Drawbacks are potential memory leaks, context switches, thread‑safety issues, and deadlocks.

Three Pillars of Thread Safety

Atomicity : operations are indivisible.

Visibility : changes made by one thread become visible to others (e.g., synchronized, volatile).

Ordering : program execution follows the programmer‑specified order (prevented by reordering).

Common Causes of Thread‑Safety Problems

Atomicity loss during thread switches.

Cache‑induced visibility gaps.

Compiler optimizations that reorder instructions.

Solutions include using JDK atomic classes, synchronized, Lock, and the Happens‑Before rule.

Concurrency vs Parallelism vs Serial Execution

Concurrency : multiple tasks share a CPU core via time‑slicing.

Parallelism : multiple cores execute tasks truly simultaneously.

Serial : a single thread processes tasks one after another.

Threads, Processes, and Their Differences

Processes have independent memory; threads share the same address space. Threads are lighter weight, but a thread crash can bring down its process.

Thread Lifecycle and States

New

Runnable

Running

Blocked (waiting, synchronized, sleep, I/O)

Dead

Thread Scheduling

JVM uses pre‑emptive scheduling; higher‑priority threads may be chosen, but the OS ultimately decides.

Synchronization Primitives

wait()

, notify(), notifyAll() (must be called inside synchronized blocks). sleep() (static, does not release locks). yield() (static, hints scheduler). interrupt() and related methods.

Daemon vs User Threads

Daemon threads run in the background and do not prevent JVM shutdown; user threads keep the JVM alive.

Detecting and Analyzing Threads

On Linux, kill -3 PID; on Windows, Ctrl+Break generate thread dumps.

Deadlock

Occurs when two or more threads hold resources the others need, forming a circular wait.

Four necessary conditions: mutual exclusion, hold‑and‑wait, no preemption, circular wait. Breaking any one prevents deadlock.

Deadlock Example

public class DeadLockDemo {
    private static Object resource1 = new Object();
    private static Object resource2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (resource1) {
                System.out.println(Thread.currentThread() + " get resource1");
                try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(Thread.currentThread() + " waiting for resource2");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread() + " get resource2");
                }
            }
        }, "Thread 1").start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + " get resource2");
                try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(Thread.currentThread() + " waiting for resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + " get resource1");
                }
            }
        }, "Thread 2").start();
    }
}

Output demonstrates the circular wait.

Preventing Deadlock

Avoid hold‑and‑wait by acquiring all needed locks at once.

Allow preemption (release locks if unable to acquire others).

Impose a strict lock acquisition order.

Thread Creation Methods

Extend Thread.

Implement Runnable.

Implement Callable (returns a result).

Use Executors to obtain thread pools.

Runnable vs Callable

Runnable’s run() returns void and cannot throw checked exceptions; Callable’s call() returns a value and can throw exceptions, used with Future.

Thread Pools

Created via Executors or directly with ThreadPoolExecutor. Core parameters: corePoolSize, maximumPoolSize, workQueue, keepAliveTime, rejection policy.

Executor vs Executors

Executor

executes tasks; ExecutorService adds lifecycle management and result retrieval.

Common Thread‑Pool Rejection Policies

AbortPolicy (throws RejectedExecutionException).

CallerRunsPolicy (caller thread runs the task).

DiscardPolicy (silently drops task).

DiscardOldestPolicy (drops oldest queued task).

Lock Implementations

synchronized

(built‑in, can be biased, lightweight, or heavyweight). ReentrantLock (explicit lock, supports fairness, interruptible lock acquisition).

Read/Write locks ( ReentrantReadWriteLock).

Volatile

Ensures visibility and prevents instruction reordering; does not guarantee atomicity except for long/double on some JVMs.

Atomic Classes

Classes like AtomicInteger, AtomicLong provide lock‑free thread‑safe operations using CAS.

Concurrent Collections

Examples: ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue implementations. They use fine‑grained locking or lock‑free algorithms to achieve high throughput.

BlockingQueue

Provides automatic waiting when the queue is empty (consumer) or full (producer). Used for producer‑consumer patterns.

Other Concurrency Utilities

Semaphore

– limits concurrent access. CountDownLatch – one‑or‑many threads wait for a count to reach zero. CyclicBarrier – a reusable barrier for a fixed number of threads. Exchanger – swaps data between two threads.

Understanding these concepts enables developers to design scalable, high‑performance Java applications.