Master Java Thread Scheduling, Pools, and Synchronization: A Complete Guide

Thread Scheduling and States

Thread is the smallest unit of CPU scheduling, each having its own program counter, JVM stack, and native method stack. The lifecycle includes Created, Runnable, Running, Blocked, and Terminated.

State transitions are illustrated with diagrams.

Blocking and Wakeup

Calling wait(), notify(), or notifyAll() moves a thread to the object's wait queue, releasing the monitor until it is notified or interrupted.

wait vs sleep

wait must be called inside synchronized code; sleep does not.

wait releases the monitor; sleep does not.

wait blocks indefinitely until notified; sleep blocks for a specified time.

wait/notify are Object methods; sleep is a Thread method.

Creating Threads

Common ways to create threads in Java:

public class RunnableThread implements Runnable {
    @Override
    public void run() {
        System.out.println("Using Runnable to create a thread");
    }
}

class CallableTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return new Random().nextInt();
    }
}

public class ExtendsThread extends Thread {
    @Override
    public void run() {
        System.out.println("Using Thread subclass");
    }
}

Thread Pools

Thread pools reuse existing threads to reduce resource consumption, increase response speed, and simplify monitoring.

Constructor signature:

public ThreadPoolExecutor(int corePoolSize,
                           int maximumPoolSize,
                           long keepAliveTime,
                           TimeUnit unit,
                           BlockingQueue<Runnable> workQueue,
                           ThreadFactory threadFactory,
                           RejectedExecutionHandler handler) { }

Task handling steps:

When pool size < corePoolSize, a new thread is created for each task.

When pool reaches corePoolSize, tasks are placed in the work queue.

If the queue is full and maximumPoolSize > corePoolSize, new threads are created.

If tasks exceed maximumPoolSize, the RejectedExecutionHandler processes them.

Idle threads beyond corePoolSize are terminated after keepAliveTime.

Rejection policies:

AbortPolicy – throws RejectedExecutionException.

CallerRunsPolicy – runs the task in the calling thread.

DiscardOldestPolicy – discards the oldest queued task.

DiscardPolicy – silently discards the new task.

Executors utility methods:

newSingleThreadExecutor()

newCachedThreadPool()

newFixedThreadPool()

newScheduledThreadPool()

newWorkStealingPool()

Lock Mechanisms

Optimistic lock (CAS) enables lock‑free updates but can suffer from the ABA problem and high contention. synchronized provides intrinsic locking with lock‑upgrade states: no‑lock, biased, lightweight, and heavyweight. ReentrantLock offers explicit lock control, optional fairness, interruptibility, and manual unlocking.

Lock optimization techniques include reducing lock scope, decreasing lock granularity, lock coarsening, using read‑write locks, and applying CAS where appropriate.

ThreadLocal

ThreadLocal

stores data per thread using an internal ThreadLocalMap, preventing shared mutable state. Remember to call remove() to avoid memory leaks.

Concurrent Collections and Immutability

HashMap

is not thread‑safe; use ConcurrentHashMap in multithreaded contexts.

String immutability provides thread safety, constant hash codes, and efficient map keys.

Java Memory Model

The Java Memory Model (JMM) defines guarantees for atomicity, visibility, and ordering. volatile ensures visibility and prevents instruction reordering; synchronized also provides these guarantees. volatile is implemented with a memory barrier (lock prefix) that flushes caches and enforces ordering.

AbstractQueuedSynchronizer (AQS)

AQS underlies many java.util.concurrent synchronizers such as Lock, CountDownLatch, Semaphore, etc., managing thread queues and state atomically.