多线程线程通信调度等待集 wait() notify()

Posted 2022-06-28 Perceus

@TOC

---

对象等待集来干预线程的调度

wait 和 notify 为了处理线程调度随机性的问题。

还是那句话，多线程的调度，因为它的随机性，就导致代码谁先执行，谁后执行，存在太多的变数。

而我们程序员是不喜欢随机性，我们喜欢确定的东西。

需要能够让线程彼此之间，有一个固定的顺序。

之前讲到的 join 也是一种控制顺序的方式，但是 join更倾向于控制线程结束。因此 join 是有使用的局限性。

就不像 wait 和 notify 用起来更加合适。

---

wait 方法

其实wait()方法就是使线程停止运行。

1. 方法wait()的作用是使当前执行代码的线程进行等待，wait( )方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
2. wait( )方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
3. wait( )方法执行后，当前线程释放锁，并一直处于等待通知状态, 直到其他线程唤醒该线程后与其它线程竞争重新获取锁。

调用 wait 方法的线程，就会陷入阻塞，阻塞到有其它线程通过 notify 来通知。

public class ThreadTest2 
    public static void main(String[] args) 
        Object locker = new Object();
        Thread t = new Thread() 
            @Override
            public void run() 
                synchronized (locker) 
                    System.out.println("t 开始运行");
                    try 
                        locker.wait();
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    System.out.println(" t 运行结束");
                
            
        ;
        t.start();
    

---

notify 方法

notify方法就是使停止的线程继续运行

1. 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。
2. 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

public class Test18 
    // 为了两个线程能够顺利交互，我们创建一个锁对象
    private static Object locker = new Object();

    public static void main(String[] args) throws InterruptedException 
        Thread t1 = new Thread(()->
            //进行 wait
            synchronized (locker)
                System.out.println("wait 之前");
                try 
                    locker.wait();
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
                System.out.println("wait 之后");
            
        );
        t1.start();

        // 为了大家能更清楚的观察到现象，我这里使用 sleep 延迟3s
        Thread.sleep(3000);

        Thread t2 = new Thread(()->
            // 进行 notify
            synchronized (locker)
                System.out.println("notify 之前");
                locker.notify();
                System.out.println("notify 之后");
            
        );
        t2.start();
    

根据这种机制我们可以编排多个线程的顺序

---

notifyAll 方法

前面说的 wait 和 notify 都是针对同一个对象来操作。

例如：

---

wait方法总结

特别注意

4. wait() 和 notify() 操作必须放在 synchronized 的代码块之内使用 否则会报异常

5. 调用wait() 和 notify() 的对象必须是同一个对象 才能起到等待和唤醒操作

   更准确的说： 因为wait 和 notify 要在 synchronized 的代码块内 所以上锁的对象也应该和 wait() 和 notify() 的对象必须是同一个对象 这样就是4个对象得保持一致

---

notify方法总结

• 一个线程执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。
• notify方法就是使停止的线程继续运行。

1. 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。
2. 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

注意：

唤醒线程不能过早，如果在还没有线程在等待中时，过早的唤醒线程，这个时候就会出现先唤醒，在等待的效果了。

这样 就没有必要在去运行wait方法了。导致竞态条件问题

public class ThreadTest3 
    public static void main(String[] args) 
        Object locker = new Object();
        Thread t = new Thread() 
            @Override
            public void run() 
                try 
                    Thread.sleep(2000);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
                synchronized (locker) 
                    System.out.println(" t 开始运行");
                    try 
                        locker.wait();
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    System.out.println(" t 运行结束");
                
            
        ;
        t.start();

        Thread t1 = new Thread() 
            @Override
            public void run() 
                synchronized (locker) 
                    System.out.println(" t1 开始运行");
                    locker.notify();
                    System.out.println(" t1 运行结束");
                
            
        ;
        t1.start();

        Thread t2 = new Thread() 
            @Override
            public void run() 
                synchronized (locker) 
                    System.out.println(" t2 开始运行");
                    System.out.println(" t2 运行结束");
                
            
        ;
        t2.start();
    

运行结果：

---

竞态条件问题

---

wait与sleep的对比

---