Java 线程通信的多种实现方法

Java 线程通信的实现方法

在 Java 编程中，线程通信是一个重要的概念，特别是在多线程环境下，线程之间需要协调工作以确保数据的一致性和程序的正确性。本文将介绍几种常见的线程通信方法，包括 wait() 和 notify()、BlockingQueue、CountDownLatch 等。

1. 使用 wait() 和 notify()

Java 中的 wait() 和 notify() 方法是实现线程间通信的基础。它们用于控制线程的执行顺序，通常在共享资源的访问中使用。

工作原理

• wait()：使当前线程等待，直到其他线程调用 notify() 或 notifyAll()。
• notify()：唤醒在此对象监视器上等待的单个线程。
• notifyAll()：唤醒所有等待的线程。

示例代码

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

    public synchronized int getValue() throws InterruptedException {
        while (!available) {
            wait(); // 等待数据可用
        }
        available = false;
        notify(); // 通知生产者可以生产
        return value;
    }

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

class Producer extends Thread {
    private SharedResource resource;

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

    @Override
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                resource.setValue(i);
                System.out.println("Produced: " + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Consumer extends Thread {
    private SharedResource resource;

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

    @Override
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                int value = resource.getValue();
                System.out.println("Consumed: " + value);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

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;
    }

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

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

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

    @Override
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                int value = queue.take();
                System.out.println("Consumed: " + value);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

3. 使用 CountDownLatch

CountDownLatch 是另一种用于线程间通信的工具，允许一个或多个线程等待直到一组操作完成。

示例代码

import java.util.concurrent.CountDownLatch;

class Task implements Runnable {
    private CountDownLatch latch;

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

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

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) {
            new Thread(new Task(latch)).start();
        }
        latch.await(); // 等待所有任务完成
        System.out.println("All tasks completed.");
    }
}

总结

Java 提供了多种方法来实现线程之间的通信，包括 wait() 和 notify()、BlockingQueue、CountDownLatch 等。根据具体的应用场景选择合适的方法，可以有效提高程序的效率和可读性。了解这些通信机制将帮助开发者更好地处理多线程环境中的数据共享和协作问题。