Java中wait(),notify()线程等待与唤醒- Java多线程系列教程四

在Object.java中,定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用,则是唤醒当前对象上的等待线程;notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程。

方法定义

1. wait方法

对象的wait方法有三个,一个是令对象等待任何线程来调用notify或者notifyAll方法来令该对象在当前线程唤醒。另外两个将当前线程置于等待状态,等到特定的时间来唤醒。

wait()  让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)。

wait(long timeout)  让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。

wait(long timeout, int nanos)  让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量”,当前线程被唤醒(进入“就绪状态”)。

2. notify方法

notify方法仅仅唤醒一个线程,令线程开始执行。所以,如果有多个线程等待一个对象的时候,这个方法只能唤醒一个线程。而唤醒的线程的选择是依赖于操作系统对于线程的管理的。

3. notifyAll方法

notifyAll方法会唤醒所有等待改对象的线程,尽管哪一个线程会优先执行时取决于操作系统的线程调度的。

原理

Java中wait(),notify()原理

如图:当一个拥有Object锁的线程调用 wait()方法时,就会使当前线程加入object.wait 等待队列中,并且释放当前占用的Object锁,这样其他线程就有机会获取这个Object锁,获得Object锁的线程调用notify()方法,就能在Object.wait 等待队列中随机唤醒一个线程(该唤醒是随机的与加入的顺序无关,优先级高的被唤醒概率会高),若果调用notifyAll()方法就唤醒全部的线程。注意:调用notify()方法后并不会立即释放object锁,会等待该线程执行完毕后释放Object锁。

wait(),notify()例子

public class WaitTest {
    private static Object object=new Object();
    public static void main(String[] args) {
        Thread thread=new Thread(){
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName()+"进入启动");
                    try {
                        object.wait();//使当前线程进入等待(进入Object.wait队列)并释放对象锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName()+"线程执行结束"); 
                }
            }
        };
        thread.start();
      Thread thread_2=new Thread(){
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName()+"进入启动"); 
                    try {
                        object.notify();//随机在Object.waitd队列中唤醒一个正在等待该对象锁的线程
                        System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName()+"唤醒一个等待的线程");
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread_2.start();
    }
}

运行结果:

1473306408730:Thread-0进入启动
1473306408731:Thread-1进入启动
1473306408731:Thread-1唤醒一个等待的线程
1473306418731:Thread-0线程执行结束

从时间戳中可以看出 Thread-1 在通知Thread-0 继续执行后,Thread-0 并未立即执行,而是等待Thread-1 释放Object锁,在重新获得Object锁后,才能继续执行。(最后两个时间戳相减刚好是10秒)

wait(),notifyall()例子

//唤醒在此对象监视器上等待的所有线程。
public class NotifyAllTest {
    private static Object obj = new Object();
    public static void main(String[] args) {

        ThreadA t1 = new ThreadA("t1");
        ThreadA t2 = new ThreadA("t2");
        ThreadA t3 = new ThreadA("t3");
        t1.start();
        t2.start();
        t3.start();

        try {
            System.out.println(Thread.currentThread().getName()+" sleep(3000)");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        synchronized(obj) {
            // 主线程等待唤醒。
            System.out.println(Thread.currentThread().getName()+" notifyAll()");
            obj.notifyAll();
        }
    }

    static class ThreadA extends Thread{

        public ThreadA(String name){
            super(name);
        }

        public void run() {
            synchronized (obj) {
                try {
                    // 打印输出结果
                    System.out.println(Thread.currentThread().getName() + " wait");

                    // 唤醒当前的wait线程
                    obj.wait();

                    // 打印输出结果
                    System.out.println(Thread.currentThread().getName() + " continue");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果:

t1 wait
main sleep(3000)
t3 wait
t2 wait
main notifyAll()
t2 continue
t3 continue
t1 continue

(01) 主线程中新建并且启动了3个线程"t1", "t2"和"t3"。 (02) 主线程通过sleep(3000)休眠3秒。在主线程休眠3秒的过程中,我们假设"t1", "t2"和"t3"这3个线程都运行了。以"t1"为例,当它运行的时候,它会执行obj.wait()等待其它线程通过notify()或额nofityAll()来唤醒它;相同的道理,"t2"和"t3"也会等待其它线程通过nofity()或nofityAll()来唤醒它们。 (03) 主线程休眠3秒之后,接着运行。执行 obj.notifyAll() 唤醒obj上的等待线程,即唤醒"t1", "t2"和"t3"这3个线程。 紧接着,主线程的synchronized(obj)运行完毕之后,主线程释放“obj锁”。这样,"t1", "t2"和"t3"就可以获取“obj锁”而继续运行了!

下图说明说明了wait(),notifyall()的流程。

java wait(),notifyall()线程流程

总结

1. wait notify notifyAll 都是Object类的方法,都是对实例的wait set 进行操作,所以他们是Object的方法比较合适。

2. 调用obj的wait(), notify()方法前,必须获得obj锁,也就是必须写在synchronized(obj) {...} 代码段内。

3. 调用obj.wait()后,线程A就释放了obj的锁,否则线程B无法获得obj锁,也就无法在synchronized(obj) {...} 代码段内唤醒A,当obj.wait()方法返回后,线程A需要再次获得obj锁,才能继续执行。

4. 如果A1,A2,A3都在obj.wait(),则B调用obj.notify()只能唤醒A1,A2,A3中的一个(具体哪一个由JVM决定)。obj.notifyAll()则能全部唤醒A1,A2,A3,但是要继续执行obj.wait()的下一条语句,必须获得obj锁,因此,A1,A2,A3只有一个有机会获得锁继续执行,例如A1,其余的需要等待A1释放obj锁之后才能继续执行。当B调用obj.notify/notifyAll的时候,B正持有obj锁,因此,A1,A2,A3虽被唤醒,但是仍无法获得obj锁。直到B退出synchronized块,释放obj锁后,A1,A2,A3中的一个才有机会获得锁继续执行。

5. 注意有synchronized修饰的方法,当线程A对实例obj进行操作时 会加锁 别的线程不能进入 而obj.wait(),obj.notifyAll()方法调用时都需要线程获取实例的锁定,例如 A线程正在操作实例obj时 obj.wait(),则A线程进入obj的wait set,线程B就可以获取obj的锁定进行对obj的操作了,当B线程获取了锁定然后执行obj.notifyAll(),则此时线程A退出obj的wait set,但此时线程B还拿着obj的锁定,只有当线程B执行完放开锁定,线程A才有可能继续获得锁定执行wait()后的代码。