黑马程序员技术交流社区

标题: 【西安校区】Java多线程之间的通信 [打印本页]

---

作者: 逆风TO    时间: 2019-10-14 15:39
标题: 【西安校区】Java多线程之间的通信
java多线程之间的通信
要实现多个线程之间的协同，如线程执行先后顺序、获取某个线程的执行结果等等。
涉及到线程之间的相互通信，分为下面四类：
1)文件共享
2)网络共享
3)变量共享
4)JDK提供的线程协调API
细分为：suspend/resume、wait/notify、park/unpark

1.文件共享


2.网络共享
尚在学习，之后的博客再作更新。

3.变量共享


4.JDK提供的线程协调API
JDK中对于需要多线程协作完成某一任务的场景，提供了对应的API支持。
多线程协作的典型场景是：生产者-消费者模型。（线程阻塞、线程唤醒）

示例：线程-1去买包子，没有包子，则不再执行。线程-2生产出包子，通知线程-1继续执行。



1）suspend/resume(被弃用)
调用suspend挂起目标线程，通过resume可以恢复线程执行。

        /** 正常的suspend/resume */
  public void suspendResumeTest() throws Exception {
          // 启动线程
          Thread consumerThread = new Thread(() -> {
                  if (baozidian == null) { // 如果没包子，则进入等待
                          System.out.println("1、进入等待");
                          Thread.currentThread().suspend();
                  }
                  System.out.println("2、买到包子，回家");
          });
          consumerThread.start();
          // 3秒之后，生产一个包子
          Thread.sleep(3000L);
          baozidian = new Object();
          consumerThread.resume();
          System.out.println("3、通知消费者");
  }

被弃用的主要原因，对使用要求非常严格，容易写出死锁的代码。

a.同步代码中使用
        /** 死锁的suspend/resume。 suspend并不会像wait一样释放锁，故此容易写出死锁代码 */
        public void suspendResumeDeadLockTest() throws Exception {
                // 启动线程
                Thread consumerThread = new Thread(() -> {
                        if (baozidian == null) { // 如果没包子，则进入等待
                                System.out.println("1、进入等待");
                                // 当前线程拿到锁，然后挂起
                                synchronized (this) {
                                        Thread.currentThread().suspend();
                                }
                        }
                        System.out.println("2、买到包子，回家");
                });
                consumerThread.start();
                // 3秒之后，生产一个包子
                Thread.sleep(3000L);
                baozidian = new Object();
                // 争取到锁以后，再恢复consumerThread
                synchronized (this) {
                        consumerThread.resume();
                }
                System.out.println("3、通知消费者");
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
b.suspend比resume后执行
        /** 先执行resume，后执行suspend，导致程序永久挂起，出现死锁 */
        public void suspendResumeDeadLockTest2() throws Exception {
                // 启动线程
                Thread consumerThread = new Thread(() -> {
                        if (baozidian == null) {
                                System.out.println("1、没包子，进入等待");
                                try { // 为这个线程加上一点延时
                                        Thread.sleep(5000L);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                                // 这里的挂起执行在resume后面
                                Thread.currentThread().suspend();
                        }
                        System.out.println("2、买到包子，回家");
                });
                consumerThread.start();
                // 3秒之后，生产一个包子
                Thread.sleep(3000L);
                baozidian = new Object();
                consumerThread.resume();
                System.out.println("3、通知消费者");
                consumerThread.join();
        }

2）wait/notify
只能由同一对象锁的持有者线程调用，也就是写在同步代码块里面，否则会抛出IllegalMonitorStateException异常。

wait方法使当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁。
notify/notifyAll方法唤醒一个或所有正在等待这个对象锁的线程。

注意：虽然会wait自动解锁，但是对顺序有要求，如果在notify被调用之后，才开始wait方法的调用，线程会永远处于WAITING状态。

a.正常输出
1.进入等待

3.通知消费者

2.买到包子，回家

        /** 正常的wait/notify */
        public void waitNotifyTest() throws Exception {
                // 启动线程
                new Thread(() -> {
                        if (baozidian == null) { // 如果没包子，则进入等待
                                synchronized (this) {
                                        try {
                                                System.out.println("1、进入等待");
                                                this.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
                        System.out.println("2、买到包子，回家");
                }).start();
                // 3秒之后，生产一个包子
                Thread.sleep(3000L);
                baozidian = new Object();
                synchronized (this) {
                        this.notifyAll();
                        System.out.println("3、通知消费者");
                }
        }

b.死锁输出
3.通知消费者

1.进入等待

…不动了

        public void waitNotifyDeadLockTest() throws Exception {
                // 启动线程
                new Thread(() -> {
                        if (baozidian == null) { // 如果没包子，则进入等待
                                try {
                                        Thread.sleep(5000L);
                                } catch (InterruptedException e1) {
                                        e1.printStackTrace();
                                }
                                synchronized (this) {
                                        try {
                                                System.out.println("1、进入等待");
                                                this.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
                        System.out.println("2、买到包子，回家");
                }).start();
                // 3秒之后，生产一个包子
                Thread.sleep(3000L);
                baozidian = new Object();
                synchronized (this) {
                        this.notifyAll();
                        System.out.println("3、通知消费者");
                }
        }

3）park/unpark
线程调用park则等待“许可”，unpark方法未指定线程提供“许可（permit）”。

不要求park和unpark的调用顺序。

多次调用unpark之后，再调用park，线程会直接运行。
但不会叠加，也就是说，连续多次调用unpark方法，再调用park方法，第一次会拿到“许可”直接运行，后续调用park会进入等待。

注意：park/unpark没有顺序要求，但是park并不会释放锁，所有在同步代码中使用要注意

a.正常情况
        /** 正常的park/unpark */
        public void parkUnparkTest() throws Exception {
                // 启动线程
                Thread consumerThread = new Thread(() -> {
                        if (baozidian == null) { // 如果没包子，则进入等待
                                System.out.println("1、进入等待");
                                LockSupport.park();
                        }
                        System.out.println("2、买到包子，回家");
                });
                consumerThread.start();
                // 3秒之后，生产一个包子
                Thread.sleep(3000L);
                baozidian = new Object();
                LockSupport.unpark(consumerThread);
                System.out.println("3、通知消费者");
        }

b.死锁情况
        /** 死锁的park/unpark */
        public void parkUnparkDeadLockTest() throws Exception {
                // 启动线程
                Thread consumerThread = new Thread(() -> {
                        if (baozidian == null) { // 如果没包子，则进入等待
                                System.out.println("1、进入等待");
                                // 当前线程拿到锁，然后挂起（锁已经随着线程挂起，获取不到了）
                                synchronized (this) {
                                        LockSupport.park();
                                }
                        }
                        System.out.println("2、买到包子，回家");
                });
                consumerThread.start();
                // 3秒之后，生产一个包子
                Thread.sleep(3000L);
                baozidian = new Object();
                // 争取到锁以后，再恢复consumerThread
                synchronized (this) {
                        LockSupport.unpark(consumerThread);
                }
                System.out.println("3、通知消费者");
        }

小结
suspend/resume：容易死锁，也容易导致永久挂起。

wait/notify：要求在同步关键字里面使用，免去了死锁的困扰，但是一定要先调用wait，再调用notify，否则会永久等待。

park/unpark：没有顺序要求，但是park并不会释放锁，所有在同步代码中使用要注意。

伪唤醒
警告！之前代码中用if语句来判断，是否进入等待状态，是错误的！

官方建议应该在循环中检查等待条件，原因是处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足条件结束的情况下退出。

正确示例

        public void waitNotifyTest() throws Exception {
                // 启动线程
                new Thread(() -> {
                                synchronized (this) {
                                        while (baozidian == null) { // 如果没包子，则进入等待
                                        try {
                                                System.out.println("1、进入等待");
                                                this.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                        System.out.println("2、买到包子，回家");
                }).start();
                // 3秒之后，生产一个包子
                Thread.sleep(3000L);
                baozidian = new Object();
                synchronized (this) {
                        this.notifyAll();
                        System.out.println("3、通知消费者");
                }
        }
伪唤醒时至线程并非因为notify、notifyAll、unpark等API调用而唤醒，是更底层的原因导致的。

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2