Java 基础——线程间通信

已于 2022-01-26 16:33:00 修改
阅读量889 收藏 1
点赞数
分类专栏： Java 并发编程 文章标签： java 多线程
于 2021-11-03 09:31:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT__learning/article/details/121078109
版权

概述

线程与线程之间不是相互独立的个体，它们彼此之间需要相互通信和协作，最典型的例子就是生产者-消费者问题。虽然通常每个子线程只需要完成自己的任务，但是有时我们希望多个线程一起工作来完成一个任务，这就涉及到线程间通信。线程通信主要可以分为三种方式，分别为共享内存、消息传递和管道流：

（1）共享内存

1）volatile 关键字
2）synchronized 关键字
3）Lock 锁

（2）消息传递

1）Object 的 join()/notify() 机制；
2）Lock 和 Condition 的 await()/signal() 机制；
3）join() 方法
4）CountdownLatch；
5）CyclicBarrier；

（3）管道通信

1、线程同步

线程同步可以通过 synchronized 关键字和 Lock 锁来实现线程间的通信。
这种方式，本质上就是“共享内存”式的通信。多个线程需要访问同一个共享变量，谁拿到了锁（获得了访问权限），谁就可以执行。

// 共享对象
class MyObject {
 synchronized public void methodA() {
 //do something....
 }
 synchronized public void methodB() {
 //do some other thing
 }
}

// 线程 A
class ThreadA extends Thread {
 private MyObject object;
//省略构造方法
 @Override
 public void run() {
 super.run();
 object.methodA();
 }
}

// 线程 B
class ThreadB extends Thread {
 private MyObject object;
//省略构造方法
 @Override
 public void run() {
 super.run();
 object.methodB();
 }
}

// 主类
public class Main {
 public static void main(String[] args) {
 MyObject object = new MyObject();
 //线程A与线程B 持有的是同一个对象:object
 ThreadA a = new ThreadA(object);
 ThreadB b = new ThreadB(object);
 a.start();
 b.start();
 }
}

由于线程 A 和线程 B 持有同一个 MyObject 类的对象 object，尽管这两个线程需要调用不同的方法，但是它们是同步执行的，线程 B 需要等待线程 A 执行完了 methodA() 方法之后，它才能执行 methodB() 方法。这样，线程 A 和线程 B 就实现了 通信。

2、join() 等待执行

thread.join() 方法的作用：阻塞父线程，如果一个线程 A 执行了 thread.join() 语句，则线程 A 被阻塞，线程 A 必须要等待调用该 join() 方法的线程 thread 执行完毕后再从 join() 方法处返回再继续执行父线程 A。
该方法常用的场景就是：子线程阻塞主线程(main函数所在线程)，必须等子线程执行结束后主线程再去执行。

假设有两个线程，一个是线程 A，另一个是线程 B，两个线程分别依次打印 1-3 三个数字即可。

public class test implements Runnable{
    @Override
    public void run() {
        {
            int i = 0;
            while (i++ < 3) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " print: " + i);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        test test1 = new test();
        Thread thread1= new Thread(test1, "lhj");
        Thread thread2= new Thread(test1, "zj");
        thread1.start();
        thread2.start();
    }
}

结果如下：
在这里插入图片描述
可以看到线程 lhj 和 zj 是同时打印的。那么，如果我们希望线程 zj 在线程 lhj 全部执行完后再执行，我们可以利用 thread.join() 方法，代码如下：

public class test implements Runnable{
    @Override
    public void run() {
        {
            int i = 0;
            while (i++ < 3) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " print: " + i);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        test test1 = new test();
        Thread thread1= new Thread(test1, "lhj");
        Thread thread2= new Thread(test1, "zj");
        thread1.start();
        thread1.join();    // 阻塞父线程（主线程），使父线程（主线程）必须等待其执行完再继续执行；
        thread2.start();	// thread1 线程执行完后，父线程（主线程）再让 thread2 线程开始执行；
    }
}

结果如下：
在这里插入图片描述

thread1.join() 阻塞父线程（主线程），使父线程（主线程）必须等待其执行完再继续执行；thread1 线程执行完后，父线程（主线程）从 thread1.join() 处返回再继续执行 thread2.start(); 即让 thread2 线程开始执行。
因此可以看到 join() 方法会让线程 zj 一直等待直到线程 lhj 运行完毕再去执行。

3、wait/notify 机制（等待/通知机制）

在基于“锁”的方式中，线程需要不断地去尝试获得锁，如果失败了，再继续尝试，这可能会耗费服务器资源。而等待/通知机制是另一种方式。
Java 多线程的等待/通知机制是基于 Object 类的 wait() 方法、notify() 和 notifyAll() 方法来实现的。

（1）wait() ：在执行 wait() 方法前，当前线程必须已获得锁。调用它时会立即阻塞当前线程，在当前 wait() 处暂停线程进入等待状态。同时，wait() 方法执行后，会立即释放获得的对象锁。
（2）notify()：在执行 notify() 方法前，当前线程也必须已获得锁。调用 notify() 方法后，会通知一个执行了 wait() 方法的阻塞等待线程，使该等待线程重新获取到对象锁，然后继续执行 wait() 后面的代码。
（3）如果有多个等待状态的线程，则需多次调用 notify() 方法，通知到线程顺序则根据执行 wait() 方法的先后顺序进行通知。如果是想通知所有等待状态的线程，可使用 notifyAll() 方法，就能唤醒所有线程。
在这里插入图片描述
注：线程执行 notify() 后不会立即释放对象锁，而是等该线程执行结束后才会释放锁，所以接收通知的 wait() 线程也不会立即获得锁，也需要等待执行 notify() 方法的线程释放锁后再获取锁。

原理图：
在这里插入图片描述
wait 与 sleep 区别
在这里插入图片描述
示例：

public class test{

    public static void main(String[] args) throws InterruptedException {

        Object lock = new Object();
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("A 1");
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("A 2");
                    System.out.println("A 3");
                }
            }
        });
        Thread B = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("B 1");
                    System.out.println("B 2");
                    lock.notify();
                    System.out.println("B 3");
                }
            }
        });

        A.start();
        B.start();
    }
}

结果如下：
在这里插入图片描述
上述代码的执行流程如下：首先我们创建一个由 A 和 B 共享的对象锁：Object lock = new Object()；当 A 拿到锁时，先打印1，然后调用 lock.wait() 方法进入等待状态，然后释放锁； A 调用 lock.wait() 方法释放锁后 B 获得锁开始执行；B 拿到锁后打印1、2、3，然后调用 lock.notify() 方法唤醒正在等待的 A；A 唤醒后继续打印剩余的 2，3。

从执行结果中可以看到，B 线程执行 notify() 方法后，A 线程没有立即获得锁，notify() 方法并不会立即释放锁。

注意：

必须是 synchronized(lock) 而不能是 synchronized(this)，否则会抛出 IllegalMonitorStateException 异常。因为 synchronized(lock) 是定义的共享锁，线程A和B用的是同一把锁，所以可以互相唤醒；而 synchronized(this) 锁定的是调用同步块的当前线程，所以线程A和B用的不是同一把锁。

4、Condition 的 await()/signal()

Condition 是在 java 1.5中出现的，它用来替代传统的 Object 的 wait()/notify() 实现线程间的协作，它的使用依赖于 Lock，Condition、Lock 和 Thread 三者之间的关系如下图所示。
在这里插入图片描述
相比使用 Object 的 wait()/notify()，使用 Condition 的 await()/signal() 这种方式能够更加安全和高效地实现线程间协作。Condition 是个接口，基本的方法就是 await()和signal() 方法。

Condition 依赖于 Lock 接口，Condition 对象的获取主要是通过 Lock.newCondition() 方法。一个 Lock 对象可以返回多个 Condition 对象。

必须要注意的是，Condition 的 await()/signal() 使用都必须在 lock 保护之内，也就是说，必须在 lock.lock() 和 lock.unlock 之间才可以使用。

原理

condition 是要和 lock 配合使用的，创建一个 condition 对象是通过 lock.newCondition()，而这个方法实际上是会 new 出一个 ConditionObject 对象，该类是 AQS 的一个内部类。我们知道在锁机制的实现上，AQS 内部维护了一个同步队列，如果是独占式锁的话，所有获取锁失败的线程的尾插入到同步队列，同样的，condition 内部也是使用同样的方式，内部维护了一个等待队列，等待队列是一个单向队列，所有调用 condition.await 方法的线程会加入到等待队列中，并且线程状态转换为等待状态。另外注意到 ConditionObject 中有两个成员变量：

/** First node of condition queue. */
private transient Node firstWaiter;
/** Last node of condition queue. */
private transient Node lastWaiter;

可以看出来 ConditionObject 通过持有等待队列的头尾指针来管理等待队列，而且 Node 类复用了在 AQS 中的 Node 类。

我们可以多次调用 lock.newCondition() 方法创建多个 condition 对象，也就是一个 lock 可以持有多个等待队列。而在之前使用 Object 的 wait()/notify() 方式实际上是指在对象 Object 对象监视器上只能拥有一个同步队列和一个等待队列，而并发包中的 Lock 拥有一个同步队列和多个等待队列。

（1）await 实现原理

当调用 condition.await() 方法后会使得当前获取 lock 的线程封装成 Node 通过尾插入的方式进入到等待队列，等待队列是一个不带头结点的链式队列。

（2）signal/signalAll 实现原理

调用 condition 的 signal 的前提条件是当前线程已经获取了 lock，调用 condition 的 signal 或者 signalAll 方法可以将等待队列中等待时间最长的节点移动到同步队列中，使得该节点能够有机会获得 lock，同步队列是一个带头结点的链式队列。按照等待队列是先进先出（FIFO）的，所以等待队列的头节点必然会是等待时间最长的节点，也就是每次调用 condition 的 signal 方法是将头节点移动到同步队列中，而移入到同步队列后才有机会使得等待线程被唤醒，即从 await 方法中的 LockSupport.park(this) 方法中返回，从而才有机会使得调用 await 方法的线程成功退出。

示例

public class ConditionTest{
    public static ReentrantLock lock=new ReentrantLock();
    public static Condition condition =lock.newCondition();

    public static void main(String[] args) {

        new Thread(){
            @Override
            public void run() {
                lock.lock(); // 必须先请求锁
                try{
                    System.out.println(Thread.currentThread().getName()+"==》进入等待");
                    condition.await(); // 设置当前线程进入等待
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    lock.unlock(); // 必须释放锁
                }
                System.out.println(Thread.currentThread().getName()+"==》继续执行");
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                lock.lock(); // 必须先请求锁
                try{
                    System.out.println(Thread.currentThread().getName()+"==》进入等待");
                    condition.await(); // 设置当前线程进入等待
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    lock.unlock(); // 必须释放锁
                }
                System.out.println(Thread.currentThread().getName()+"==》继续执行");
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                lock.lock(); // 必须请求锁
                try{
                    System.out.println(Thread.currentThread().getName()+"=》进入");
                    Thread.sleep(2000); // 休息2秒
                    condition.signal(); // 唤醒等待队列中的第一个线程
                    System.out.println(Thread.currentThread().getName()+"休息结束");
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    lock.unlock(); // 必须释放锁
                }
            }
        }.start();
    }
}

运行结果：
在这里插入图片描述
上述代码中，有两个线程 Thread-0 和 Thread-1 都通过 await() 方法进入等待队列，在 Thread-1 中使用 signal() 方法后会唤醒等待队列中的第一个线程进入同步队列，因此 Thread-0 被唤醒继续执行，由于 signal() 方法只使用一次因此 Thread-1 线程没有被唤醒而继续等待。若要唤醒多个等待队列中的线程需要多次调用 signal() 方法。

public class ConditionTest{
    public static ReentrantLock lock=new ReentrantLock();
    public static Condition condition =lock.newCondition();

    public static void main(String[] args) {

        new Thread(){
            @Override
            public void run() {
                lock.lock(); // 必须先请求锁
                try{
                    System.out.println(Thread.currentThread().getName()+"==》进入等待");
                    condition.await(); // 设置当前线程进入等待
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    lock.unlock(); // 必须释放锁
                }
                System.out.println(Thread.currentThread().getName()+"==》继续执行");
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                lock.lock(); // 必须先请求锁
                try{
                    System.out.println(Thread.currentThread().getName()+"==》进入等待");
                    condition.await(); // 设置当前线程进入等待
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    lock.unlock(); // 必须释放锁
                }
                System.out.println(Thread.currentThread().getName()+"==》继续执行");
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                lock.lock(); // 必须请求锁
                try{
                    System.out.println(Thread.currentThread().getName()+"=》进入");
                    Thread.sleep(2000); // 休息2秒
                    condition.signal(); // 唤醒等待队列中的第一个线程
                    condition.signal(); // 继续唤醒等待队列中的第一个线程
                    System.out.println(Thread.currentThread().getName()+"休息结束");
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    lock.unlock(); // 必须释放锁
                }
            }
        }.start();
    }
}

结果：
在这里插入图片描述
由于 Thread-2 多次调用 signal() 方法，因此 Thread-0 和 Thread-1 均被唤醒继续执行。

在调用 await() 方法前线程必须获得重入锁，调用 await() 方法后线程会释放当前占用的锁。同理在调用signal()方法时当前线程也必须获得相应重入锁，调用 signal() 方法后系统会从 condition.await() 等待队列中唤醒一个线程。当线程被唤醒后，它就会尝试重新获得与之绑定的重入锁，一旦获取成功将继续执行。所以调用 signal() 方法后一定要释放当前占用的锁，这样被唤醒的线程才能有获得锁的机会，才能继续执行。

4、管道通信

管道流是是一种使用比较少的线程间通信方式，Java 中管道输入/输出流主要包括 4 种具体的实现：PipedOutputStrean、PipedInputStrean、PipedReader 和 PipedWriter，前两种面向字节，后两种面向字符。

Java 的管道的输入和输出实际上使用的是一个循环缓冲数组来实现的，默认为 1024，输入流从这个数组中读取数据，输出流从这个数组中写入数据，当这个缓冲数组已满的时候，输入流所在的线程就会被阻塞，当向这个缓冲数组为空时，输出流所在的线程就会被阻塞。

在这里插入图片描述

buffer：缓冲数组，默认为1024；
out：从缓冲数组中读数据；
in：从缓冲数组中写数据；

IT__learning
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程通信图解
11-29
一张图方便理解和掌握java 多线程之间通信的实质 java 多线程 其实就是每个线程都拥有自己的内存空间，多线程之间的通信，比例A线程修改了主内存（main方法的线程）变量，需要把A线程修改的结果同步到主线程中，这时B线程再从主线程获取该变量的值，这样就实现了线程之间的通信。在A线程修改的过程中， 通过加锁的方法防止B线程获取该共享变量的值。锁的机制说白了，就是在获取共享变量的时候，增加了字段标识该字段是否已经被其他线程修改中
JAVA多线程基础篇-线程通信(wait/notify)
qq_33479841的博客
07-10 1817
在JAVA多线程中，线程通信是重要概念之一。线程通信能够使系统之间的交互性更强大，在大大提高CPU利用率的同时还会使程序员对各线程在任务处理过程中进行有效把控。本文将针对使用wait/notify进行线程之间通信进行分析，详述其实现过程、原理以及相关注意事项。.........
Java多线程--线程间的通信
人生得意须尽欢
02-02 1083
Java多线程--线程间的通信
java线程通信方式的理解
YINZONGCHAO的博客
09-14 248
多线程和并发，在平时开发中有些小伙伴用的不多，但是有些工作经验的面试中还是容易被问到的，故在之后几期先整理一些常见的多线程面试题供参考。 通信方式 ①同步 ②while轮询的方式 ③wait/notify机制 ④管道通信 一，介绍 本文总结我对于JAVA多线程中线程之间的通信方式的理解，主要以代码结合文字的方式来讨论线程间的通信，故摘抄了书中的一些示例代码。 二，线程间的通信方式 ①同步 这里讲的同步是指多个线程通过synchronized关键字这种方式来实
Java并发学习 7: 线程之间的通信
过道
04-10 2801
3.1 继承 Thread类 // 继承，则Demo1 也成为了一个线程 public class Demo1 extends Thread { // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么. @Override public void run() { // 这个新类，只需要打印出自己的名字(每个线程都有自己的Name属性并提供g...
Java线程之线程通信
weixin_66813230的博客
03-22 269
一、概述 所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。 形式：通过共享一个数据的方式实现，根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。 实际应用场景： 生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据 要求：生产者生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。 二、案例 方法为什么要用同步锁对象调用（虽然可以用任意对象调用）：因为只有同步锁对象才知道是谁需要等待，需要唤醒谁。 否
Java 如何实现线程间通信
weixin_34252090的博客
09-13 529
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点： thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, ...
Java里如何实现线程间通信？
djwmzyl的专栏
04-17 3607
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点：thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, Callable 等。 下面我从几个例子作为切入点
Java多线程间的通信
热门推荐
it_man的专栏
01-12 2万+
Java多线程间的通信   Java还提供了一种线程间通信的机制，这种通信通什么实现？ wait，notify等机制   或使用pipeInputStream和pipeOutputStream    1. 线程的几种状态 线程有四种状态，任何一个线程肯定处于这四种状态中的一种： 1) 产生（New）：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没
【转】Java学习：Java中的线程之线程间的通信
weixin_30929195的博客
06-30 108
hello各位小伙伴 今天我们来搞一下 线程之间的通信 ( • ̀ω•́ )✧ 让线程按照我们的想法来执行 两个线程间的通信 这是我们之前的线程。 执行效果：谁抢到资源，谁运行~ 实现线程交替执行： 这里主要用到了两个内容 1）创建一个标记 flag，让程序进行判断： 当flag != 1 时，print1 进入等待，执行 print2，然后让 flag=1，唤醒...
java线程的通信_java线程之间的通信
weixin_34861332的博客
02-20 70
1.常用的方法sleep() 该线程进入等待状态,不释放锁wait()该线程进入等待状态,释放锁notify()随机唤醒一个线程notifyAll()唤醒全部线程getName()获取线程对象的名称。默认情况下，名字的组成 Thread-编号(编号从0开始)setName(String name)设置线程名称currentThread()返回当前正在执行的线程对象引用sleep(Long time...
Java 线程间通信，生产者与消费者模型
07-26
使用wait()和notify()实现的生产者与消费者模型，可以了解如何使用wait()和notify()进行线程间通信。（上一次上传的代码有一个问题没有考虑到，这次修补了——CSDN没法撤销资源，只能再上传了）
Java学习源码Java多线程的代码
06-15
在char03包里放置了Java线程间通信的知识的代码。内容如下： 等待/通知机制 join方法的使用 在char04包里放置了Java中Lock类的知识的代码，内容如下： Lock类 Lock类其他功能 Condition类 Condition类其他...
Java JDK实例宝典
06-16
4 Applet间通信 15. 5 汉诺塔游戏 第16章 J2SE 5. 0新特性 16. 1 自动装箱和拆箱 16. 2 新的for循环 16. 3 枚举类型 16. 4 静态导入 16. 5 可变长参数Varargs 16. 6 格式化输出 ...
Android程序设计基础
08-03
7.3 JavaScript与Java通信 115 7.4 使用Web服务 121 7.5 快速阅读指南 131 第8章 定位与环境感知 133 8.1 位置，位置，位置 133 8.1.1 我在哪里 135 8.1.2 更新位置 137 8.1.3 模拟说明 138 8.2 充分利用...
如何在Java中正确使用 wait, notify 和 notifyAll
12-22
　在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者，让消费者开始消耗数据，因为队列缓冲区中有内容待...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 894
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 867
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 269
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
java线程间通信sync
10-16
Java中的线程间通信可以使用synchronized关键字来实现。具体来说，可以使用wait()方法使线程进入等待状态，直到其他线程调用notify()或notifyAll()方法来唤醒它们。在使用wait()和notify()时，必须先获得对象的锁，因此通常会将它们放在synchronized块中。 例如，以下代码演示了两个线程之间的通信： ``` public class ThreadCommunication { public static void main(String[] args) { final Object lock = new Object(); Thread t1 = new Thread(() -> { synchronized (lock) { System.out.println("Thread 1 is waiting"); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Thread 1 is notified"); } }); Thread t2 = new Thread(() -> { synchronized (lock) { System.out.println("Thread 2 is running"); lock.notify(); } }); t1.start(); t2.start(); } } ``` 输出结果为： ``` Thread 1 is waiting Thread 2 is running Thread 1 is notified ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值