Thread之线程间的通信--Wait()、Notify()和NotifyAll()

落日映苍穹つ 2022-04-22 05:10 168阅读 0赞

接上一篇：[Thread之结束线程(8)][Thread_8]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70][]

我们来看下Wait()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70 1][]

Wait()是归属于Object ，来看下API上怎么讲。

### wait ###

public final void wait(long timeout)
                    throws InterruptedException

导致当前线程等待，直到另一个线程调用此对象的`notify()`方法或`notifyAll()`方法，或指定的时间已过。

当前的线程必须拥有该对象的显示器。

此方法使当前线程（称为T ）将其放置在该对象的等待集中，然后放弃对该对象的任何和所有同步声明。 线程T变得禁用线程调度目的，并且休眠，直到发生四件事情之一：

然后从该对象的等待集中删除线程T ，并重新启用线程调度。 然后它以通常的方式与其他线程竞争在对象上进行同步的权限; 一旦获得了对象的控制，其对对象的所有同步声明就恢复到现状 - 也就是在调用`wait`方法之后的情况。 线程T然后从调用`wait`方法返回。 因此，从返回`wait`方法，对象和线程的同步状态`T`正是因为它是当`wait`被调用的方法。

线程也可以唤醒，而不会被通知，中断或超时，即所谓的*虚假唤醒* 。 虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。 换句话说，等待应该总是出现在循环中，就像这样：

synchronized (obj) {
             while (<condition does not hold>)
                 obj.wait(timeout);
             ... // Perform action appropriate to condition
         }

（有关此主题的更多信息，请参阅Doug Lea的“Java并行编程（第二版）”（Addison-Wesley，2000）中的第3.2.3节或Joshua Bloch的“有效Java编程语言指南”（Addison- Wesley，2001）。

如果当前线程interrupted任何线程之前或在等待时，那么`InterruptedException`被抛出。 如上所述，在该对象的锁定状态已恢复之前，不会抛出此异常。

请注意， `wait`方法，因为它将当前线程放入该对象的等待集，仅解锁此对象; 当前线程可以同步的任何其他对象在线程等待时保持锁定。

该方法只能由作为该对象的监视器的所有者的线程调用。 有关线程可以成为监视器所有者的方法的说明，请参阅`notify`方法。

参数

`timeout` \- 以毫秒为单位等待的最长时间。

异常

`IllegalArgumentException` \- 如果超时值为负。

`IllegalMonitorStateException` \- 如果当前线程不是对象监视器的所有者。

`InterruptedException` \- 如果任何线程在当前线程等待通知之前或当前线程中断当前线程。 当抛出此异常时，当前线程的*中断状态*将被清除。

另请参见：

`notify()` ， `notifyAll()`

*  一些其他线程调用该对象的`notify`方法，并且线程T恰好被任意选择为被唤醒的线程。
 *  某些其他线程调用此对象的`notifyAll`方法。
 *  一些其他线程interrupts线程T。
 *  指定的实时数量已经过去，或多或少。 然而，如果`timeout`为零，则不考虑实时，线程等待直到通知。
    
     *  ### **wait** ###
        
            public final void wait(long timeout,
                                   int nanos)
                            throws InterruptedException
        
        导致当前线程等待，直到另一个线程调用此对象的`notify()`方法或`notifyAll()`方法，或其他一些线程中断当前线程，或一定量的实时时间。
        
        这种方法类似于一个参数的`wait`方法，但它允许对放弃之前等待通知的时间进行更精细的控制。 以纳秒为单位的实时数量由下式给出：
        
        >     1000000*timeout+nanos
        
        在所有其他方面，该方法与一个参数的方法`wait(long)`相同。 特别是， `wait(0, 0)`意味着同样的事情`wait(0)` 。
        
        当前的线程必须拥有该对象的显示器。 线程释放此监视器的所有权，并等待直到发生以下两种情况之一：
        
        然后线程等待，直到它可以重新获得监视器的所有权并恢复执行。
        
        像在一个参数版本中，中断和虚假唤醒是可能的，并且该方法应该始终在循环中使用：
        
            synchronized (obj) {
                     while (<condition does not hold>)
                         obj.wait(timeout, nanos);
                     ... // Perform action appropriate to condition
                 }
        
        该方法只能由作为该对象的监视器的所有者的线程调用。 有关线程可以成为监视器所有者的方式的说明，请参阅`notify`方法。
        
        参数
        
        `timeout` \- 以毫秒为单位等待的最长时间。
        
        `nanos` \- 额外的时间，以纳秒范围0-999999。
        
        异常
        
        `IllegalArgumentException` \- 如果超时值为负值或 `IllegalArgumentException`值不在0-999999范围内。
        
        `IllegalMonitorStateException` \- 如果当前线程不是此对象的监视器的所有者。
        
        `InterruptedException` \- 如果任何线程在当前线程等待通知之前或当前线程中断当前线程。 当抛出此异常时，当前线程的*中断状态*将被清除。
        
         *  另一个线程通知等待该对象的监视器的线程通过调用`notify`方法或`notifyAll`方法来唤醒。
         *  由`timeout`毫秒加`nanos`纳秒参数指定的超时时间已过。
     *  ### **wait** ###
        
            public final void wait()
                            throws InterruptedException
        
        导致当前线程等待，直到另一个线程调用该对象的`notify()`方法或`notifyAll()`方法。 换句话说，这个方法的行为就好像简单地执行呼叫`wait(0)` 。
        
        当前的线程必须拥有该对象的显示器。 该线程释放此监视器的所有权，并等待另一个线程通知等待该对象监视器的线程通过调用`notify`方法或`notifyAll`方法`notifyAll` 。 然后线程等待，直到它可以重新获得监视器的所有权并恢复执行。
        
        像在一个参数版本中，中断和虚假唤醒是可能的，并且该方法应该始终在循环中使用：
        
            synchronized (obj) {
                     while (<condition does not hold>)
                         obj.wait();
                     ... // Perform action appropriate to condition
                 }
        
        该方法只能由作为该对象的监视器的所有者的线程调用。 有关线程可以成为监视器所有者的方式的说明，请参阅`notify`方法。
        
        异常
        
        `IllegalMonitorStateException` \- 如果当前线程不是对象监视器的所有者。
        
        `InterruptedException` \- 如果任何线程在当前线程等待通知之前或当前线程中断当前线程。 当抛出此异常时，当前线程的*中断状态*将被清除。
        
        另请参见：
        
        `notify()` ， `notifyAll()`

public final native void wait(long timeout) throws InterruptedException;
    
    
    
    public final void wait(long timeout, int nanos) throws InterruptedException {
            if (timeout < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
    
            if (nanos < 0 || nanos > 999999) {
                throw new IllegalArgumentException(
                                    "nanosecond timeout value out of range");
            }
    
            if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
                timeout++;
            }
    
            wait(timeout);
        }
    
    
     public final void wait() throws InterruptedException {
            wait(0);
        }

我们上面知道，使用Wait()需要使用synchronized同步代码块，并且需指定一个监控器。只有获得这个监控器的所有者才能调用Wait(),否则将抛出`IllegalMonitorStateException，如果`当对象处于wait()状态时，则意味着该线程放弃CPU执行权，放开所调用的资源。

那么我们如何将处于该状态的线程唤醒，继续工作呢？我们来看下Object类的Notify()和NotifyAll方法。

### notify ###

public final void notify()

唤醒正在等待对象监视器的单个线程。 如果任何线程正在等待这个对象，其中一个被选择被唤醒。 选择是任意的，并且由实施的判断发生。 线程通过调用`wait`方法之一等待对象的监视器。

唤醒的线程将无法继续，直到当前线程放弃此对象上的锁定为止。 唤醒的线程将以通常的方式与任何其他线程竞争，这些线程可能正在积极地竞争在该对象上进行同步; 例如，唤醒的线程在下一个锁定该对象的线程中没有可靠的权限或缺点。

该方法只能由作为该对象的监视器的所有者的线程调用。 线程以三种方式之一成为对象监视器的所有者：

一次只能有一个线程可以拥有一个对象的显示器。

异常

`IllegalMonitorStateException` \- 如果当前线程不是此对象的监视器的所有者。

另请参见：

`notifyAll()` ， `wait()`

*  通过执行该对象的同步实例方法。
 *  通过执行在对象上`synchronized` synchronized语句的正文。
 *  对于类型为`Class,`的对象，通过执行该类的同步静态方法。

### notifyAll ###

public final void notifyAll()

唤醒正在等待对象监视器的所有线程。 线程通过调用`wait`方法之一等待对象的监视器。

唤醒的线程将无法继续，直到当前线程释放该对象上的锁。 唤醒的线程将以通常的方式与任何其他线程竞争，这些线程可能正在积极地竞争在该对象上进行同步; 例如，唤醒的线程在下一个锁定该对象的线程中不会有可靠的特权或缺点。

该方法只能由作为该对象的监视器的所有者的线程调用。 有关线程可以成为监视器所有者的方法的说明，请参阅`notify`方法。

异常

`IllegalMonitorStateException` \- 如果当前线程不是此对象的监视器的所有者。

另请参见：

`notify()` ， `wait()`

public final native void notify();
    public final native void notifyAll();

将线程唤醒，回归到可运行(Runnable)状态。

`接着我们来实现前面所讲的线程间的通信:`

Demo One

public class WaitAndNotify02 {
    	private int i = 1;
    	final private Object LOCK = new Object();
    	boolean isWait = false;
    	private void produce(){
    		synchronized (LOCK){
    			if(isWait){
    				try {
    					LOCK.wait();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}else{
    				System.out.println(Thread.currentThread().getName()+"_"+"p->"+(i++));
    				isWait = true;
    			}
    
    		}
    
    		}
    
    	private void consume(){
    		synchronized (LOCK){
    			if(!isWait){
    				LOCK.notify();
    			}else{
    				System.out.println(Thread.currentThread().getName()+"_"+"c->"+i);
    				isWait = false;
    			}
    		}
    
    	}
    
    	public static void main(String[] args) {
    		final WaitAndNotify02 wn = new WaitAndNotify02();
    		new Thread("p"){
    			@Override
    			public void run() {
    				while (true)
    				wn.produce();
    			}
    		}.start();
    		new Thread("p2"){
    			@Override
    			public void run() {
    				while (true)
    					wn.produce();
    			}
    		}.start();
    		new Thread("p3"){
    			@Override
    			public void run() {
    				while (true)
    					wn.produce();
    			}
    		}.start();
    		new Thread("p4"){
    			@Override
    			public void run() {
    				while (true)
    					wn.produce();
    			}
    		}.start();
    		new Thread("c"){
    			@Override
    			public void run() {
    				while (true)
    				wn.consume();
    			}
    		}.start();
    		new Thread("c1"){
    			@Override
    			public void run() {
    				while (true)
    					wn.consume();
    			}
    		}.start();
    		new Thread("c3"){
    			@Override
    			public void run() {
    				while (true)
    					wn.consume();
    			}
    		}.start();
    		new Thread("c4"){
    			@Override
    			public void run() {
    				while (true)
    					wn.consume();
    			}
    		}.start();
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70 2][]

Demo Two

public class WaitAndNotifyAll {
    	int i  = 0;
    	final Object LOCK = new Object();
    	boolean isProduce = false;
    
    	private void produce(){
    		synchronized (LOCK){
    			while (isProduce){
    				try {
    					LOCK.wait();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    			i++;
    			System.out.println(Thread.currentThread().getName()+"_p_"+i);
    			LOCK.notifyAll();
    			isProduce = true;
    		}
    	}
    
    	private void consume(){
    		synchronized (LOCK){
    			while (!isProduce){
    				try {
    					LOCK.wait();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    			System.out.println(Thread.currentThread().getName()+"_c_"+i);
    			LOCK.notifyAll();
    			isProduce = false;
    		}
    	}
    
    	public static void main(String[] args) {
    		final WaitAndNotifyAll wna = new WaitAndNotifyAll();
    		for (int i = 0; i < 4; i++) {
    			new Thread("p"+i){
    				@Override
    				public void run() {
    					while (true)
    						wna.produce();
    				}
    			}.start();
    			new Thread("c"+i){
    				@Override
    				public void run() {
    					while (true)
    						wna.consume();
    				}
    			}.start();
    
    		}
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70 3][]

[Thread_8]: https://blog.csdn.net/st1527960117/article/details/83447267
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70]: /images/20220422/8bcf35501714499aac45af9f2f7356cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70 1]: /images/20220422/4fbb95d4dd054282b06955aabc6fc2bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70 2]: /images/20220422/34f8641f40da48499971be2a70209953.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_16_color_FFFFFF_t_70 3]: /images/20220422/b6d07fe9603e454288e31cc3aed3e76a.png