线程间的通信机制介绍

左手的ㄟ右手 2024-03-30 12:34 30阅读 0赞

## 1.等待唤醒机制 ##

--------------------

### 1.1线程间通信 ###

**概念**：多个线程在处理同一个资源，但是处理的动作(线程的任务)却不相同。

比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作是生产，一个是消费，那么线程A与线程B之间存在线程通信问题。

![2cb4f564a4e84ca78c0535e37373d582.png][]

**1.1.1为什么要处理线程间通信：**

> 多个线程并发执行时,在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并目我们希望他们有规律的执行,那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

**1.1.2如何保证线程间通信有效利用资源:**

> 多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或损作。 就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即一**等待唤醒机制。**

### 1.2等待唤醒机制 ###

--------------------

**1.2.1什么是等待唤醒机制**

> 这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争( race )，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。
> 
> 就是在一个线程进行了规定操作后，就进入等待状态( wait) )，等待其他线程执行完他们的指定代码过后 再将其唤醒(notify0));在有多个线程进行等待时，如果需要，可以使用 notifyAll0来唤醒所有的等待线程。  
> wait/notify 就是线程间的一种协作机制。

**1.2.2等待唤醒中的方法**

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

> 1.  wait : 线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个**特别的动作**，也即是"**通知( notify )"**在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列( ready queue )中
> 2.  notify: 则选取所通知对象的 wait set 中的一个线程释放;例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
> 3.  notifyAll: 则释放所通知对象的 wait set 上的全部线程。

#### 1.2.3使用Object中的方法 ####

Object类中定义了wait/notify/notifyAll等线程间通信的方法。JDK官方文档中的解释：

//唤醒在此对象监视器上等待的单个线程
        public final native void notify()
    //唤醒在此对象监视器上等待的所有线程
        public final native void notifyAll()
    //导致当前的线程等待，直到其他线程 调用此对象的notify()方法或notifyAll()方法
        public final void wait() throws InterruptedException
    //导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者指定的时间过完
        public final native void wait(long timeout) throws InterruptedException
    //导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者其他线程打断了当前线程，或者指定的时间过完
        public final native void wait(long timeout,int nanos) throws InterruptedException

用通俗一点的语言来解释wait()和notify()：

> 1.  wait() ------> 我等会儿再用这把锁，CPU也让给你们，我先休息一会儿
> 2.  notify() ------> 我用完了，你们谁用？

简单总结：

> 1.  wait、notify、notifyAll都属于Object类，也就是每个对象都有wait、notify、notifyAll的功能，因为每个对象都有锁。
> 2.  调用使用wait、notify、notifyAll的时候，一定要对竞争资源进行加锁。如果不加锁的话，则会报 IllegalMonitorStateException 异常。
> 3.  调用wait方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
> 4.  调用wait进行线程等待时，必须要取得这个锁，一般是放到synchronized(obj)代码中。
> 5.  在while循环里而不是if语句下使用wait，这样，会在线程暂停恢复后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知。
> 6.  notify或notifyAll方法调用后，等待线程依旧不会从wait返回，需要调用notify或notifAll的线程释放锁之后，等待线程才有机会从wait返回。
> 7.  notify方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。

假设有三个线程执行了obj.wait，那么obj.notifyAll则能全部唤醒tread1，thread2，thread3，但是要继续执行obj.wait的下一条语句，必须获得obj锁。因此，tread1，thread2，thread3只有一个有机会获得锁继续执行，例如tread1，其余的需要等待thread1释放obj锁之后才能继续执行。

当调用obj.notify/notifyAll后，调用线程依旧持有obj锁，因此，thread1，thread2，thread3虽被唤醒，但是仍无法获得obj锁。直到调用线程退出synchronized块，释放obj锁后，thread1，thread2，thread3中的一个才有机会获得锁继续执行。

> **等待/通知机制**，指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

#### 注意： ####

**哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁( 很可能面临其它线程的竞争 )，成功后才能在当初调用 wait 方法之后的地方恢复执行。**  
总结如下:

>  *  如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
>  *  否则，从wait set 出来，又进入 entry set，线程就从WAITING 状态又变成 BLOCKED 状态。

#### **1.2.4wait、notify、notifyAll的使用** ####

一个线程因其执行目标动作所需的保护条件未满足而被暂停的过程称为等待，一个线程更新了系统的状态，使得其他线程所需的保护条件得以满足的时候唤醒哪些被暂停的线程的过程称为通知。

> Object.wait()/Object.wait(long)以及Object.notify()/Object.notifyAll()可应用于实现等待和通知。

#### 1.2.5wait的作用 ####

Object.wait()的作用是使其执行线程被暂停，直到接到通知或被中断为止，该方法可用于实现等待。

在调用 wait方法之前，线程必须要获得锁，即只能在同步方法或同步块中调用wait方法。调用wait方法之后，当前线程会释放锁。如果再次获取到锁的话，当前线程才能从wait方法处成功返回。

使用Object.wait()实现等待，示例：

//调用wait方法之前获得相应对象的内部锁
        synchronized (someObject){
            while (保护条件不成立){
                //调用Object.wait()暂停当前线程
                somObject.wait();
            }
            //代码执行到这里说明保护条件以满足，执行目标动作
            doAction();
        }

#### 1.2.6notify和notifyAll的作用 ####

notify()方法也要在同步方法或同步块中调用，即在调用前，线程也必须要获得锁

notify()方法任意从处于WAITTING状态的线程中挑选一个进行唤醒，使得调用 wait方法的线程从等待队列移入到同步队列中，从而使得调用 wait()方法的线程能够从 wait()方法处退出。

调用notify()后，当前线程不会马上释放该对象锁，要等到程序退出同步块后，当前线程才会释放锁。

notifyAll()与notify()作用类似，不同的地方：notifyAll()的作用是唤醒正在等待对象监视器的所有线程。

使用Object.notify()实现通知，示例：

synchronized (somObject){
            //更新等待线程的保护条件涉及的共享变量
            updateSharedState();
            //唤醒其他线程
            somObject.notify();
        }

#### 1.2.7notify/notifyAll选择 ####

Object.notify()可能导致信号丢失这样的正确性问题，而Object.notifyAll()虽然效率不高，但在正确性方面有保障。

一种较流行的保守方法：优先使用Object.notifyAll()保障正确性，只有在有证据表明使用Object.notify()足够的情况下才使用Object.notify()。

使用Object.notify()需要满足的两个条件：

> 1.  一次通知仅需要唤醒最多一个线程；
> 2.  相应对象的等待集中仅包含同质等待线程。（同质等待线程是指这些线程用同一个保护条件，并且这些线程在Object.wait()调用返回后的处理逻辑一致。最经典的同质线程是使用同一个Runnable接口实例创建的不同线程或者从同一个Thread子类的new出来的多个线程）。

#### 1.2.8wait/notify/notifyAll使用示例 ####

*  #### 例子1：单个wait和notify ####

结果：

T1 start!
    T2 start!
    T2 end!
    T1 end!

这个例子中，两个线程用同一把锁，T1里面主要写了个wait()，而T2里面主要写了个notify()。  
代码执行流程：T1启动，让出锁，让出CPU；T2获得CPU，启动，唤醒使用了object的休眠的线程，T1被唤醒后等待启动；T2继续执行，T2执行完，T1获得CPU后继续执行。

*  #### 例子2：多个wait和notify ####

final Object object = new Object();
    		Thread t1 = new Thread() {
    			public void run(){
    				synchronized (object) {
    					System.out.println("T1 start!");
    		            try {
    		            	object.wait();
    		            } catch (InterruptedException e) {
    		            	e.printStackTrace();
    		            }
    		            System.out.println("T1 end!");
    				}
    			}
    		};
    		Thread t2 = new Thread() {
    			public void run(){
    				synchronized (object) {
    					System.out.println("T2 start!");
    					object.notify();
    					System.out.println("T2 end!");
    				}
    			}
    		};
    		Thread t3 = new Thread() {
    			public void run(){
    				synchronized (object) {
    					System.out.println("T3 start!");
    					object.notify();
    					System.out.println("T3 end!");
    				}
    			}
    		};
    		Thread t4 = new Thread() {
    			public void run(){
    				synchronized (object) {
    					System.out.println("T4 start!");
    		            try {
    		            	object.wait();
    		            } catch (InterruptedException e) {
    		            	e.printStackTrace();
    		            }
    		            System.out.println("T4 end!");
    				}
    			}
    		};
    		t1.start();
    		t2.start();
    		t3.start();
    		t4.start();

这个例子有两种结果：

> 1.  刚好wait两次，notify两次，notify在wait之后执行，刚好执行完。
> 2.  也是刚好wait两次，notify两次，但是，notify在wait之前执行，于是，至少会有一个线程由于后面没有线程将它notify而无休止地等待下去。

结果示例1：

T1 start!
    T2 start!
    T2 end!
    T1 end!
    T4 start!
    T3 start!
    T3 end!
    T4 end!

这个结果对应的执行流程：执行流程是：T1启动后wait，T2获得锁和CPU，T2宣布锁用完了其它线程可以用了，然后继续执行；T2执行完，T1被刚才T2唤醒后，等待T2执行完后，抢到了CPU，T1执行。

T1执行完，T4获得CPU，启动，wait,T3获得了锁和CPU执行，宣布锁用完其它线程可以用了，然后继续执行，T3执行完，已经被唤醒并且等待已久的T4得到CPU，执行。

结果示例2：

T1 start!
    T2 start!
    T2 end!
    T1 end!
    T3 start!
    T3 end!
    T4 start!

这个结果对应的执行流程：T1启动，wait，让出CPU和锁，T2得以启动。T2启动，并唤醒一个线程，自己继续执行。被唤醒的线程，也就是T1等待启动机会。  
T2执行完，T1抢到了CPU，执行，并结束。

这时，只剩下T3和T4。T3抢到了CPU，于是它执行了，而且唤醒了线程，虽然此时并没有线程休眠。说白了，它浪费了一次notify。T3顺利执行完。这时，终于轮到了T4，它启动了，wait了，但是，后面已经没有线程了，它的wait永远不会有线程帮它notify了。

*  #### 例子3：只使用notify ####

final Object object = new Object();
    	    Thread t1 = new Thread() {
    	    	public void run(){
    	    		synchronized (object) {
    	    			System.out.println("T1 start!");
    	                object.notify();
    	                System.out.println("T1 end!");
    	            }
    	        }
    	    };
    	    t1.start();

结果：

T1 start!
    T1 end!

这个例子说明：如果没有线程在wait，调用notify是不会有什么问题的。

**wait原理**

![d9f18f68fbd5cb2aefa68e8fdc309986.png][]

> EntrySet：入口集；WaitSet：等待集；The owner：线程拥有锁。
> 
> **锁的运行原理：开始线程在入口集和等待集竞争锁【1】，此时线程A获取到了锁【2】，入口集和等待集中的线程进入BLOCKED。此时A可以正常运行完释放锁【6】，也可以调用wait释放锁进入等待集【3】。等待集线程被唤醒【4】后，进入另一个等待集，与入口集的线程一起竞争锁【5】。**

**1.2.9调用wait和notify方法需要注意的细节**

> 1.  wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
> 2.  wait方法与notify方法是属于object类的方法的。因为: 锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
> 3.  wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这2个方法。

### 1.3生产者与消费者问题 ###

--------------------

等待唤醒机制其实就是经典的"生产者与消费者”的问题。

就拿生产包子消费包子来说等待唤醒机制如何有效利用资源:

> **包子铺线程生产包子，吃货线程消费包子。当包子没有时( 包子状态为false )，吃货线程等待，包子铺线理生产包子( 即包子状态为true )，并通知吃货线程( 解除货的等待状,因为已经有包子了，那么包子铺线程进入等待状接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完(包子状态为false )，并通知包子铺线程( 解除包子铺的等待状,吃货程进入等待。包子铺线程能否进一步执行则决于锁的获取情况。**

**代码演示：**

包子资源类：

package xiancheng3;
    
    /**
     * 贷源类对象:多个线程共同操作的对亲
     */
    public class BaoZi {
        String name;//包于名称
        boolean flag;//包于的状态 (true表示存在 false表示不存在)
    
    }

吃货线程类：

package xiancheng3;
    
    public class ChiHuo extends Thread{
        BaoZi baoZi;
    
        //构造方法: 用来指定线程的名字和要操作的资源
        public ChiHuo(String name,BaoZi bz){
            super(name);
            this.baoZi=bz;
        }
    
        /**
         * 对于吃货------ 消费者:
         * 如果包子 不存在   进入等状态
         * 如果包子 存在进入执行状态，吃包子。吃完之后包子变为不存在 此时唤醒早餐店制作包了
         */
        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            int count=0;
            while (true){
                synchronized (baoZi){
                    count++;
                    if (count>10){
                        break;
                    }
    
                    if (baoZi.flag){ //如果包子存在
                        System.out.println(threadName+"开始吃"+baoZi.name);//吃包子
                        baoZi.flag=false;//修改状态
                        baoZi.notify();//唤醒同一资源下的其他线程
                    }else {//如果包子不存在
                        try {
                            baoZi.wait();//进入等待状态
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

早餐店线程类：

package xiancheng3;
    
    public class ZaoCanDian extends Thread{
        BaoZi baozi;
    
        //构造方法: 用来指定线程的名字和要操作的资源
       public ZaoCanDian(String name,BaoZi bz){
           super(name);
           this.baozi=bz;
       }
    
        /**
         *  对于早餐店----生产者:
         *  如果包子 不存在进入执行状态，制造包子。制作完毕包子存在，唤醒吃货
         *  如果包子 存在进入等待状态
         */
        @Override
        public void run() {
            //获取当前线程的名称
            String threadName = Thread.currentThread().getName();
            int count=0;
            while (true){
                synchronized (baozi){
                    count++;
                    if (count>10){
                        break;
                    }
                    if (baozi.flag){//如果包子存在
                        try {
                            baozi.wait();
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }else {//如果包子不存在
                        System.out.println(threadName+"开始制作"+baozi.name);//制作包子
                        baozi.flag=true;//更改包子状态
                        baozi.notify();//唤醒同一资源下的其他线程
                    }
                }
            }
        }
    }

测试类：

package xiancheng3;
    
    public class ThreadTest1 {
        public static void main(String[] args) {
            //定义资源对象
            BaoZi baoZi=new BaoZi();
            baoZi.name="韭菜鸡蛋";
            baoZi.flag=true;
    
            //定义两个线程，起名字日作同一个对象
            ChiHuo ch=new ChiHuo("猪八戒",baoZi);
            ZaoCanDian zcd=new ZaoCanDian("春光早餐",baoZi);
    
            //启动线程
            zcd.start();
            ch.start();
        }
    }

测试结果：

猪八戒开始吃韭菜鸡蛋
    春光早餐开始制作韭菜鸡蛋
    猪八戒开始吃韭菜鸡蛋
    春光早餐开始制作韭菜鸡蛋
    猪八戒开始吃韭菜鸡蛋
    春光早餐开始制作韭菜鸡蛋
    猪八戒开始吃韭菜鸡蛋
    春光早餐开始制作韭菜鸡蛋
    猪八戒开始吃韭菜鸡蛋
    春光早餐开始制作韭菜鸡蛋

[2cb4f564a4e84ca78c0535e37373d582.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/071ef7a16e8c484eafcdeda5e642b130.png
[d9f18f68fbd5cb2aefa68e8fdc309986.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5779bd50f74b4714b8205204a20b280f.png