wait/notify,notifyAll

怼烎@ 2023-06-18 12:55 18阅读 0赞

*  wait之后，持有对象锁的线程 A会释放当前锁，释放 cpu 资源进入waiting状态.
 *  notify :表示持有对象锁的线程A 会释放当前锁，通知JVM唤醒某个竞争该对象锁线程的线程X，线程A的Synchronized代码块执行完并释放了锁之后，线程X会有机会获得对象锁的权限（注意这里线程X也不是一定会争抢到锁，因为线程A有可能会再次获取到锁），其他竞争线程继续等待。（即使线程X执行完毕，释放了对象锁，其他竞争线程仍然等待，直至有新的notify或者notifyAll）
 *  notifyAll： notify和notifyAll的区别在于，notifyAll会唤醒所有竞争同一个对象锁的线程，当已经获得锁的线程A释放锁之后，所有被唤醒的线程都有可能获得对象锁的权限。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70]
 *  调用wait首先会获取监视器锁，获得成功后，会让线程进入等待队列，并且释放锁。
 *  然后其他线程调用notify或者活notifyAll，会从等待队列中唤醒任意个线程
 *  执行完notify方法后，并不会立马唤醒线程，原因是当前线程仍然持有锁，必须等到当前线程执行完毕，按照monitorexit指令之后，也就是释放之后，处于等待队列的线程就可以开始竞争锁了（不是一定会竞争到锁，原来执行完毕notify的线程也可能会再次获取到锁）。
 *  #### 当把线程对象作为对象锁的时候，不需要调用notify方法，也可以唤醒线程。 ####

public class WaitTest2 { 
        public static void main(String[] args) throws InterruptedException { 
    
    
            final Thread t1 = new Thread("t1") { 
                @Override
                public void run() { 
                    // 将线程对象t1作为对象锁
                    synchronized (this) { 
                        try { 
                            System.out.println(Thread.currentThread().getName() + " 开始执行");
                            sleep(3000);
                            System.out.println(Thread.currentThread().getName() + " 执行完毕，开始notify");
                            // 注意这里并没有调用notify方法，是否会唤醒t2线程呢？
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            };
    
            Thread t2 = new Thread("t2") { 
                @Override
                public void run() { 
                    // 将线程对象t1作为对象锁
                    synchronized (t1) { 
                        try { 
                            System.out.println(Thread.currentThread().getName() + " 开始wait");
                            System.out.println(Thread.currentThread().getName() + " 开始wait 2s");
                            t1.wait();
                            System.out.println(Thread.currentThread().getName() + " 已经被唤醒执行");
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            };
            t2.start();
    
            t1.start();
        }
    }

注意上面一块代码，将t1作为对象锁，这里可以多运行几次，让t2先执行，t1后面执行，那么再t1执行完毕之后，是否会唤醒t2线程呢？ 这里并没有notify，看运行结果  
![在这里插入图片描述][2019120217160926.png]

可以发现，即使t1没有执行t1.notify，t2依然 被唤醒，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70 1]

如果这里对象锁不是线程Thread类型的，而且其他对象类型，比如String等，这种就必须要手动调用notify释放

# 锁池和等待池 #

锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。  
等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中  
所以我们可以很容易看到这两者的区别了：

如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。  
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191202164329561.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg=,size_16,color_FFFFFF,t_70
[2019120217160926.png]: https://img-blog.csdnimg.cn/2019120217160926.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191202172100364.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg=,size_16,color_FFFFFF,t_70

wait/notify,notifyAll

发表评论取消回复

还没有评论，来说两句吧...

相关阅读