线程通讯的三种方法

线程通讯的三种方法

线程通信是指多个线程之间通过某种机制进行协调和交互，例如，线程等待和通知机制就是线程通讯的主要手段之

一。

在 Java 中，线程等待和通知的实现手段有以下几种方式：

• Object 类下的 wait()、notify() 和 notifyAll() 方法；
• Condition 类下的 await()、signal() 和 signalAll() 方法；
• LockSupport 类下的 park() 和 unpark() 方法。

为什么一个线程等待和通知机制就需要这么多的实现方式呢？

别着急，咱们先来看实现，再来说原因。

1、wait/notify/notifyAll

Object 类的方法说明：

• wait()：让当前线程处于等待状态，并释放当前拥有的锁；
• notify()：随机唤醒等待该锁的其他线程，重新获取锁，并执行后续的流程，只能唤醒一个线程；
• notifyAll()：唤醒所有等待该锁的线程（锁只有一把，虽然所有线程被唤醒，但所有线程需要排队执行）。

示例代码如下：

package com.example;

public class Test1 {
    public static void main(String[] args) {
        Object lock = new Object();
        // 创建线程并执行
        new Thread(() -> {
            System.out.println("线程1：开始执行");
            synchronized (lock) {
                try {
                    System.out.println("线程1：进入等待");
                    lock.wait();
                    System.out.println("线程1：继续执行");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1：执行完成");
            }
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock) {
            // 唤醒线程
            System.out.println("执行 notifyAll()");
            lock.notifyAll();
        }
    }
}

# 程序输出
线程1：开始执行
线程1：进入等待
执行 notifyAll()
线程1：继续执行
线程1：执行完成

2、await/signal/signalAll

Condition 类的方法说明：

• await()：对应 Object 的 wait() 方法，线程等待；
• signal()：对应 Object 的 notify() 方法，随机唤醒一个线程；
• signalAll()：对应 Object 的 notifyAll() 方法，唤醒所有线程。

示例代码如下：

package com.example;

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

public class Test2 {
    public static void main(String[] args) {
        // 创建 Condition 对象
        Lock lock = new ReentrantLock();
        // lock 下可创建多个 Condition
        Condition condition = lock.newCondition();
        // 创建线程并执行
        new Thread(() -> {
            // 加锁
            lock.lock();
            System.out.println("线程1：开始执行");
            try {
                System.out.println("线程1：进入等待");
                condition.await();
                System.out.println("线程1：继续执行");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                // 解锁
                lock.unlock();
            }
            System.out.println("线程1：执行完成");
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        // 唤醒线程
        System.out.println("执行 signalAll()");
        condition.signalAll();
        lock.unlock();
    }
}

# 程序输出
线程1：开始执行
线程1：进入等待
执行 signalAll()
线程1：继续执行
线程1：执行完成

3、park/unpark

LockSupport 类的方法说明：

• LockSupport.park()：休眠当前线程。
• LockSupport.unpark(线程对象)：唤醒某一个指定的线程。

PS：LockSupport 无需配锁（synchronized 或 Lock）一起使用。

示例代码如下：

package com.example;

import java.util.concurrent.locks.LockSupport;

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            LockSupport.park();
            System.out.println("线程1");
        }, "线程1");
        t1.start();
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("唤醒线程1");
            LockSupport.unpark(t1);
        }, "线程2");
        t2.start();
    }
}

# 程序输出
唤醒线程1
线程1

4、小结

为什么一个线程等待和唤醒的功能需要这么多的实现呢？

1、LockSupport 存在的必要性：前两种方法 notify 方法以及 signal 方法都是随机唤醒，如果存在多个等待线程

的话，可能会唤醒不应该唤醒的线程，因此有 LockSupport 类下的 park 和 unpark 方法指定唤醒线程是非常有必

要的。

2、Condition 存在的必要性：Condition 相比于 Object 类的 wait 和 notify/notifyAll 方法，前者可以创建多个等

待集，例如，我们可以创建一个生产者等待唤醒对象，和一个消费者等待唤醒对象，这样我们就能实现生产者只能

唤醒消费者，而消费者只能唤醒生产者的业务逻辑了，如下代码所示：

// 创建 Condition 对象
private Lock lock = new ReentrantLock();
// 生产者的 Condition 对象
private Condition producerCondition = lock.newCondition();
// 消费者的 Condition 对象
private Condition consumerCondition = lock.newCondition();

也就是 Condition 是 Object 等待唤醒模型的升级，Object 类可以实现的功能它都能实现，但 Condition 能实现的

功能，Object 却不能实现，这就是 Condition 类存在的必要性。

那问题来了，为什么还有会 Object 的 wait 和 notify 方法呢？因为 Object 类诞生的比较早，也就是说

Condition 和 LockSupport 都是 JDK 后期版本才出现的功能，所以就有了现在这么多线程唤醒和等待的方法

了。