Back to Thread Communication

Technical Explanation of Thread Communication

1. wait() and notify() Mechanism

Technical Explanation

  • Mechanism: Intrinsic thread communication methods
  • Purpose: Coordinate thread interactions
  • Synchronization: Used within synchronized context
  • Methods:
    • wait(): Releases lock and suspends thread
    • notify(): Wakes up a waiting thread
    • notifyAll(): Wakes up all waiting threads

public class WaitNotifyExample {
    private synchronized void producerMethod() throws InterruptedException {
        while (condition) {
            // Thread goes to waiting state
            wait();
        }
        // Perform production
        notify(); // Notify waiting consumer
    }
    
    private synchronized void consumerMethod() throws InterruptedException {
        while (anotherCondition) {
            // Thread goes to waiting state
            wait();
        }
        // Perform consumption
        notify(); // Notify waiting producer
    }
}

2. Blocking Queue Communication

Technical Explanation

  • Mechanism: Thread-safe data transfer mechanism
  • Implementation: Concurrent data structure
  • Key Methods:
    • put(): Adds element (blocks if full)
    • take(): Removes element (blocks if empty)
    • offer(): Adds element (returns false if full)
    • poll(): Removes element (returns null if empty)

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueExample {
    private BlockingQueue queue = 
        new LinkedBlockingQueue<>(10);
    
    public void producer() throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            // Blocks if queue is full
            queue.put(i);
        }
    }
    
    public void consumer() throws InterruptedException {
        while (true) {
            // Blocks if queue is empty
            Integer item = queue.take();
            processItem(item);
        }
    }
}

3. Condition Variables

Technical Explanation

  • Mechanism: Advanced thread synchronization
  • Flexibility: More precise than wait/notify
  • Key Components:
    • Lock for synchronization
    • Condition for thread waiting
    • Explicit signaling

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionVariableExample {
    private final Lock lock = new ReentrantLock();
    private final Condition dataAvailable = lock.newCondition();
    private boolean hasData = false;
    
    public void producer() throws InterruptedException {
        lock.lock();
        try {
            while (hasData) {
                // Wait if data is not consumed
                dataAvailable.await();
            }
            // Produce data
            hasData = true;
            dataAvailable.signal();
        } finally {
            lock.unlock();
        }
    }
    
    public void consumer() throws InterruptedException {
        lock.lock();
        try {
            while (!hasData) {
                // Wait if no data is available
                dataAvailable.await();
            }
            // Consume data
            hasData = false;
            dataAvailable.signal();
        } finally {
            lock.unlock();
        }
    }
}