并发编程(六)：wait、notify

wait/notify原理

1. Owner线程发现条件不满足，则调用wait方法，即可进入WaitSet变为WAITING状态
2. BLOCKED和WAITING的线程都处于阻塞状态，不占用CPU时间片
3. BLOCK线程会在Owner线程释放锁时唤醒

4. WAITING线程会在Owner线程调用notify或notifyAll时唤醒，但唤醒后并能立即获得锁，仍需要进入EntryList重新竞争

   
   wait/notify原理.png

wait、notifyAPI

• obj.wait() 进入object监视器的线程到WaitSet等待
• obj.notify() 在object上正在WaitSet等待的线程唤醒，唤醒后的线程进入到EntryList中
• obj.notifyAll() 唤醒所有WaitSet等待的线程，唤醒的线程进入到EntryList中
• 以上三个方法是Object上方法，必须获得该对象的锁，才能调用者3个方法
• wait(long timeout, int nanos)Object提供wait两个参数方法不会精确到纳秒，如果第二个参数在合理范围，毫秒数+1

    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 > 0) {
            timeout++;
        }

        wait(timeout);
    }

sleep(long n)和wait(long n)的区别

1. sleep是Thread静态方法，wait是Object方法
2. sleep不需要强制和synchronized配合使用，但wait需要和synchronized一起用
3. sleep在睡眠的同时不会释放锁对象，但是notify在等待的时候会释放对象锁
4. 进入sleep和wait后都进入到TIMEINGWAITING，有时限的等待

正确使用wait、notify

synchronized(lock){
    while(条件不成立){
        lock.wait();
    }
    //获得锁后执行后面逻辑
}

//另外一个线程
synchronized(lock){
    lock.notifyAll();
}

@Slf4j(topic = "ants.NotifyAll")
public class NotifyAll {
    private final static Object lock = new Object();
    static boolean t1Status;
    static boolean t2Status;

    public static void main(String[] args) {
        new Thread("t1") {
            @SneakyThrows
            @Override
            public void run() {
                synchronized (lock) {
                    while (!t1Status) {
                        lock.wait();
                    }
                    log.debug("t1线程状态{}", t1Status);
                    if (t1Status) {
                        log.debug("t1干剩下的活");
                    } else {
                        log.debug("t1干不了剩下的活");
                    }
                }
            }
        }.start();
        new Thread("t2") {
            @SneakyThrows
            @Override
            public void run() {
                synchronized (lock) {
                    while (!t2Status) {
                        log.debug("t2线程状态{}", t2Status);
                        lock.wait();
                    }
                    log.debug("t2干剩下的活");
                }
            }
        }.start();

        synchronized (lock) {
            t1Status = true;
            lock.notifyAll();
        }
        synchronized (lock) {
            t2Status = true;
            lock.notifyAll();
        }
    }
}

在使用Lock中的await()/signal()可以唤醒指定的线程对象，详细在ReentrantLock将讲述。