Java 多线程编程：线程通信

在多线程编程中，线程之间的通信是一个重要的主题。线程通信允许多个线程之间交换信息，以便协调它们的行为。Java 提供了多种机制来实现线程之间的通信，包括 wait()、notify()、notifyAll() 方法，以及更高级的工具如 BlockingQueue 和 CountDownLatch。在本教程中，我们将深入探讨这些机制，并提供示例代码来帮助理解。

1. 线程通信的基本概念

线程通信是指多个线程之间通过某种方式交换信息或协调执行。由于线程的执行是并发的，直接共享数据可能会导致数据不一致或竞争条件。因此，线程通信的主要目的是确保线程之间的协调和数据的一致性。

1.1 线程通信的必要性

• 数据共享：多个线程可能需要访问共享数据，线程通信可以确保数据的一致性。
• 协调执行：某些线程可能需要等待其他线程完成某些任务后才能继续执行。
• 资源管理：在资源有限的情况下，线程需要协调对资源的访问。

2. 线程通信的基本方法

Java 提供了多种方法来实现线程之间的通信，以下是最常用的几种。

2.1 使用 wait() 和 notify()

wait() 和 notify() 是 Object 类的方法，用于实现线程之间的通信。它们的工作原理是基于对象的监视器锁。

2.1.1 wait() 方法

当一个线程调用某个对象的 wait() 方法时，它会释放该对象的监视器锁，并进入等待状态，直到其他线程调用同一对象的 notify() 或 notifyAll() 方法。

2.1.2 notify() 和 notifyAll() 方法

• notify()：唤醒一个在该对象监视器上等待的线程。
• notifyAll()：唤醒所有在该对象监视器上等待的线程。

示例代码

class SharedResource {
    private int data;
    private boolean available = false;

    public synchronized int getData() throws InterruptedException {
        while (!available) {
            wait(); // 等待数据可用
        }
        available = false; // 数据被消费
        notify(); // 通知生产者
        return data;
    }

    public synchronized void setData(int data) throws InterruptedException {
        while (available) {
            wait(); // 等待数据被消费
        }
        this.data = data;
        available = true; // 数据可用
        notify(); // 通知消费者
    }
}

class Producer extends Thread {
    private SharedResource resource;

    public Producer(SharedResource resource) {
        this.resource = resource;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                resource.setData(i);
                System.out.println("Produced: " + i);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

class Consumer extends Thread {
    private SharedResource resource;

    public Consumer(SharedResource resource) {
        this.resource = resource;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                int data = resource.getData();
                System.out.println("Consumed: " + data);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

public class ThreadCommunicationExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Producer producer = new Producer(resource);
        Consumer consumer = new Consumer(resource);
        producer.start();
        consumer.start();
    }
}

优点

• 简单易用，适合基本的生产者-消费者问题。
• 直接使用 Java 的内置机制，无需额外的库。

缺点

• 需要手动管理线程的状态，容易出错。
• 可能导致死锁，特别是在复杂的线程交互中。

注意事项

• wait() 和 notify() 必须在同步块中调用。
• 使用 while 循环而不是 if 来检查条件，以防止虚假唤醒。

2.2 使用 BlockingQueue

BlockingQueue 是 Java 提供的一个线程安全的队列实现，适合用于生产者-消费者模式。它提供了阻塞的插入和移除操作，简化了线程通信的复杂性。

示例代码

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class Producer implements Runnable {
    private BlockingQueue<Integer> queue;

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                queue.put(i);
                System.out.println("Produced: " + i);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

class Consumer implements Runnable {
    private BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                int data = queue.take();
                System.out.println("Consumed: " + data);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
        Thread producer = new Thread(new Producer(queue));
        Thread consumer = new Thread(new Consumer(queue));
        producer.start();
        consumer.start();
    }
}

优点

• 简化了线程通信的复杂性，减少了出错的可能性。
• 内置的阻塞机制，避免了手动管理线程状态。

缺点

• 可能会引入额外的性能开销，尤其是在高并发场景下。
• 需要理解 BlockingQueue 的特性和使用方法。

注意事项

• 选择合适的 BlockingQueue 实现（如 ArrayBlockingQueue、LinkedBlockingQueue）以满足特定需求。
• 注意处理 InterruptedException，以确保线程能够正确响应中断。

2.3 使用 CountDownLatch

CountDownLatch 是一个同步辅助类，允许一个或多个线程等待直到在其他线程中执行的一组操作完成。它适用于需要等待多个线程完成某个任务的场景。

示例代码

import java.util.concurrent.CountDownLatch;

class Task implements Runnable {
    private CountDownLatch latch;

    public Task(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {
        try {
            // 模拟任务执行
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " completed.");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            latch.countDown(); // 任务完成，计数减一
        }
    }
}

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int numberOfTasks = 3;
        CountDownLatch latch = new CountDownLatch(numberOfTasks);

        for (int i = 0; i < numberOfTasks; i++) {
            new Thread(new Task(latch)).start();
        }

        latch.await(); // 等待所有任务完成
        System.out.println("All tasks completed.");
    }
}

优点

• 简化了线程间的等待和通知机制。
• 适合用于等待多个线程完成某个任务的场景。

缺点

• 一旦计数器达到零，CountDownLatch 不能重用。
• 需要合理设计任务的数量和计数器的初始值。

注意事项

• 确保在所有线程完成后调用 await()，以避免主线程提前结束。
• 适合用于一次性任务的场景，不适合重复使用。

3. 总结

线程通信是多线程编程中不可或缺的一部分。Java 提供了多种机制来实现线程之间的通信，包括 wait()/notify()、BlockingQueue 和 CountDownLatch。每种机制都有其优缺点和适用场景，开发者需要根据具体需求选择合适的方式。

在使用线程通信时，务必注意线程安全和避免死锁等问题。通过合理的设计和使用 Java 提供的工具，可以有效地实现线程之间的协调与通信，从而提高程序的性能和可靠性。