Java中的线程间通信：从wait/notify到CountDownLatch的应用

Java中的线程间通信：从wait/notify到CountDownLatch的应用

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

线程间通信是多线程编程中的一个重要主题，它涉及到线程之间的协调与数据共享。在Java中，有多种机制可以实现线程间的通信，包括 wait/notify、CountDownLatch、Semaphore、CyclicBarrier 等。本文将重点探讨 wait/notify 和 CountDownLatch 的应用，并通过代码示例来展示它们的实际使用场景。

1. wait/notify 机制

wait 和 notify 是 Java 中实现线程间通信的基础方法。这些方法是 Object 类的一部分，线程可以通过它们在对象的监视器上进行通信。

基本原理：

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

示例代码：

public class WaitNotifyExample {
    private static final Object lock = new Object();
    private static boolean isReady = false;

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Producer is running...");
                    Thread.sleep(2000); // Simulate some work
                    isReady = true;
                    lock.notify(); // Notify the consumer that the work is done
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            synchronized (lock) {
                while (!isReady) {
                    try {
                        System.out.println("Consumer is waiting...");
                        lock.wait(); // Wait until the producer signals
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("Consumer received notification. Processing data...");
            }
        });

        producer.start();
        consumer.start();
    }
}

分析：

在上述代码中，producer 线程完成工作后调用 notify()，以唤醒正在等待的 consumer 线程。这种机制允许线程之间有效地同步状态。

2. CountDownLatch 机制

CountDownLatch 是一个同步辅助工具，用于在多线程环境下控制线程的等待。它的工作原理是一个计数器，允许一个或多个线程等待，直到其他线程完成某些操作。

基本原理：

• CountDownLatch(int count): 创建一个 CountDownLatch 实例，其计数器初始值为 count。
• await(): 使当前线程等待，直到计数器为零。
• countDown(): 减少计数器的值，如果计数器为零，则唤醒所有等待的线程。

示例代码：

import java.util.concurrent.CountDownLatch;

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

        Runnable task = () -> {
            try {
                System.out.println(Thread.currentThread().getName() + " is working...");
                Thread.sleep((int) (Math.random() * 1000)); // Simulate work
                System.out.println(Thread.currentThread().getName() + " has finished.");
                latch.countDown(); // Decrement the count of the latch
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

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

        try {
            System.out.println("Main thread is waiting for tasks to complete...");
            latch.await(); // Wait until countDown() has been called numberOfTasks times
            System.out.println("All tasks completed.");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

分析：

在上述代码中，主线程通过 CountDownLatch 等待所有子线程完成任务。在每个子线程完成后，调用 countDown() 方法将计数器减一，直到所有任务完成，主线程才继续执行。这种机制适用于需要等待多个任务完成后的场景。

比较与应用场景

• wait/notify:

  • 适用场景: 适用于需要在某些条件下线程间同步的情况，例如生产者-消费者问题。
  • 优点: 简单、直接，但需要在锁管理上小心，避免死锁和条件竞争问题。
  • 缺点: 编码复杂，难以调试。

• CountDownLatch:

  • 适用场景: 适用于需要等待一组任务完成的情况，例如测试启动之前等待所有线程准备好。
  • 优点: 设计简洁，线程安全，易于理解和使用。
  • 缺点: 一旦计数器变为零，不能重置，适合一次性使用的场景。

总结

在Java中，线程间通信的机制包括多种选择，其中 wait/notify 和 CountDownLatch 是常用的两种方式。wait/notify 更适合需要动态线程间同步的场景，而 CountDownLatch 更适用于任务同步的场景。选择合适的机制可以有效地提高程序的性能和可维护性。

本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！