Understanding Java Multithreading: Threads, Synchronization, and Concurrency Utilities

Introduction

The article begins by distinguishing threads from processes and explains that multithreading is used to better utilize CPU resources, especially for scenarios like the producer‑consumer model.

Thread States

It defines the possible states of a Java thread (New, Runnable, Blocked, Waiting, Timed‑Waiting, Terminated) and describes how methods such as join(), sleep(), wait(), and yield() cause transitions between these states.

Object‑Level Synchronization

The concepts of synchronized, wait, and notify are introduced as monitor‑based tools that every Java object possesses. The article shows how these keywords must be used inside a synchronized block and explains the IllegalMonitorStateException that occurs when they are misused.

public class Thread1 implements Runnable {
   Object lock;
   public void run() {
       synchronized(lock) {
           // ...do something
       }
   }
}

public class Thread1 implements Runnable {
   public synchronized void run() {
       // ...do something
   }
}

A producer‑consumer example demonstrates the combined use of synchronized, wait, and notifyAll:

public synchronized void produce() {
    if (this.product >= MAX_PRODUCT) {
        try { wait(); }
        catch (InterruptedException e) { e.printStackTrace(); }
        return;
    }
    this.product++;
    System.out.println("Producer produced product " + this.product);
    notifyAll();
}

public synchronized void consume() {
    if (this.product <= MIN_PRODUCT) {
        try { wait(); }
        catch (InterruptedException e) { e.printStackTrace(); }
        return;
    }
    System.out.println("Consumer consumed product " + this.product);
    this.product--;
    notifyAll();
}

The volatile keyword is discussed as a way to prevent variable caching across threads, ensuring visibility of the latest value at the cost of performance.

Basic Thread Classes

The article reviews the core thread abstractions: Thread, Runnable, and Callable. It shows how to start a thread:

MyThread my = new MyThread();
my.start();

Key Thread methods are listed:

// Yield the CPU to another runnable thread
public static void yield();
// Pause execution for a given time
public static void sleep(long millis) throws InterruptedException;
// Wait for another thread to finish
public void join() throws InterruptedException;
// Set the interrupt flag
public void interrupt();

Interrupt handling is explained, emphasizing that only blocking calls (wait, sleep, join) react to the interrupt flag.

Advanced Concurrency Utilities (java.util.concurrent)

Several high‑level utilities are introduced:

ThreadLocal : provides a separate variable instance per thread, useful for per‑thread context such as session data.

Atomic classes (e.g., AtomicInteger, AtomicReference): offer lock‑free thread‑safe operations.

AtomicInteger.compareAndSet(int expect, int update);

Lock classes : ReentrantLock – explicit lock with lock(), lockInterruptibly(), and unlock().

static ReentrantLock r = new ReentrantLock();
r.lock();
// critical section
r.unlock();

ReentrantReadWriteLock

– separate read and write locks for higher concurrency.

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
ReadLock r = lock.readLock();
WriteLock w = lock.writeLock();

Concurrent collections : BlockingQueue – queue with put() and take() that block when full or empty, ideal for producer‑consumer patterns. ConcurrentHashMap – high‑performance thread‑safe hash map.

Thread pool management via ExecutorService and ThreadPoolExecutor:

ExecutorService e = Executors.newFixedThreadPool(3);
e.execute(new MyRunnableImpl());

The parameters of ThreadPoolExecutor (corePoolSize, maximumPoolSize, keepAliveTime, workQueue, threadFactory) are explained.

Conclusion

The article emphasizes best practices such as naming threads, using thread groups, and always releasing locks in a finally block to avoid deadlocks.