Java多线程中sleep和wait区别

/*
wait方法会导致当前线程等待，直到其他线程调用notify和notifyAll方法，或者达到了指定的等待时间
使用wait方法的前提是当前线程拥有该对象的监视器也就是锁
该方法会导致当前线程T(调用wait方法的线程)将自己放到该对象的等待集合中，然后会放弃此对象上的所有同步声明，也就是会放弃对象的锁
该等待线程不会被调度并且处于休眠状态，直到以下四种情况之一发生：
1、其他线程调用等待对象notify方法，并且当前线程T被随机选为要唤醒的方法时，线程将会退出休眠状态
2、其他线程调用等待对象的notifyAll方法
3、其他线程中断当前线程T
4、超过指定的等待时间。如果等待时间为0的话，时间因素将不会被考虑，那线程将等待直到被通知唤醒
当发生上述四种情况时，线程T将会从该对象的等待集合中移除，并且可以重新被调度。然后它以通常的方式与其他线程竞争对象上的同步锁，一旦它获得了对对象的控制权，它对对象的所有同步声明将会恢复到原来的状态，也就是说，恢复到调用wait方法时的状态。然后线程T将会从调用wait方法的方法中返回。因此，从wait方法返回时，对象和线程T的同步状态与调用wait方法时的状态完全相同。
如果当前线程在等待之前或者等待时被中断，会抛出InterruptedException异常。
注意，等待方法将当前线程防止到该对象的等待集合时，只解锁此对象；在线程等待时，当前线程同步的其他任何对象都将保持锁定状态。
wait方法仅能被持有对象监视器的线程调用(对象监视器就相当于对象的锁)
通过如下方法可以获得对象的监视器:
1、通过执行该对象的同步方法(也就是synchronized关键字修饰的方法)
2、通过执行该对象的同步代码块(synchronized(Object) {})
3、通过执行类的同步静态代码块(也就是synchronized关键字修饰的静态方法)
*/
public final native void wait(long timeout) throws InterruptedException;

/*
唤醒一个等待对象锁的线程
如果有多个线程在等待该对象，会随机唤醒一个线程
在当前线程放弃该对象的锁之前，唤醒的线程将无法继续执行
唤醒的线程将以通常的方式与其他线程竞争，这些线程会公平地在这个对象上进行同步竞争。例如，被唤醒的线程在竞争对象的锁时没有特权或者缺点
该方法仅在线程持有对象的监视器时才能被调用，获取对象的监视器有如下方法：也就是synchronized关键字修饰的方法、静态方法以及代码块等
*/
public final native void notify();
/*
唤醒所有等待该对象监视器的线程
在当前持有对象锁的线程放弃对象锁之前，被唤醒的线程无法执行
*/
public final native void notifyAll();

/*
根据系统计时器和调度程序的精度和准确性，使当前执行的线程休眠（暂时停止执行）指定的毫秒数
线程不会释放持有的锁
该方法响应中断，当遇到中断时会抛出InterruptedException异常，并且会清除当前线程的中断状态
*/
public static native void sleep(long millis) throws InterruptedException;
/*
使当前执行的线程休眠（临时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统计时器和调度程序的精度和准确性
线程不会释放持有的锁
nanos的范围:0-999999
*/
public static void sleep(long millis, int nanos)
    throws InterruptedException {
        // 判断millis和nanos是否符合条件
        if (millis < 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 && millis == 0)) {
            millis++;
        }
        // 调用原生sleep方法
        sleep(millis);
    }

try {
    Thread.sleep(3000L);
} catch (InterruptedException e) {
    e.printStackTrace();
}

synchronized (lock){
    try {
        lock.wait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

synchronized (lock) {
    // 随机唤醒
    lock.notify();
    // 唤醒全部
    lock.notifyAll();
}

public static native void sleep(long millis) throws InterruptedException;

public final native void wait(long timeout) throws InterruptedException;

Object lock = new Object();
synchronized (lock) {
    try {
        lock.wait(3000L);
        Thread.sleep(2000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}