Java线程中的wait()，notify()与sleep()

在Java中可以通过wait()与notify()或notifyAll()实现线程协作。简要总结有如下几点：
1.wait()让线程进入等待状态，并释放锁（而sleep等待的同时并不释放锁）
2.notify()通知wait的线程尝试获取对象锁，在此线程任务执行完后，wait的线程就会重新获得锁，继续运行。
3.wait与notify均是Object的方法，调用这两个方法需要在synchronized代码块或函数中执行，否则会抛出异常。

下面通过一些代码来验证。

public class TestAlpha {

    Object mLock = new Object();

    Runnable mRunnableOne = new Runnable() {
        @Override
        public void run() {
            try {
                // 由于没有在synchronized块中调用，会抛出异常
                mLock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };

    public static void main(String[] args){
        TestAlpha test = new TestAlpha();

        Thread threadOne = new Thread(test.mRunnableOne);
        threadOne.start();
    }

}

首先这段代码开启一个线程并执行wait，由于并没有在synchronized块中执行，因此会直接抛出错误：

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.example.threadtest.TestAlpha$1.run(TestAlpha.java:11)
    at java.lang.Thread.run(Thread.java:745)

接下来添加一些打印，并将wait调用放到synchronized代码块中：

Runnable mRunnableOne = new Runnable() {
    @Override
    public void run() {
        synchronized (mLock) {
            try {
                System.out.println("ThreadOne start");
                mLock.wait();
                System.out.println("ThreadOne end");    // 此行不会打印
            } catch (InterruptedException e) {
                    e.printStackTrace();
            }
        }
    }
};

由于wait后没有其他线程调用notify，因此这个线程一直在等待状态，后面的打印也就无法执行了。

下面开启另一个线程，调用notify函数：

public class TestAlpha {

    Object mLock = new Object();

    Runnable mRunnableOne = new Runnable() {
        @Override
        public void run() {
            synchronized (mLock) {
                try {
                    System.out.println("ThreadOne start");
                    mLock.wait();
                    System.out.println("ThreadOne end");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    Runnable mRunnableTwo = new Runnable() {
        @Override
        public void run() {
            synchronized (mLock) {
                try {
                    System.out.println("ThreadTwo start");
                    // 运行1s后触发notify调用
                    Thread.sleep(1000);
                    mLock.notify();
                    System.out.println("ThreadTwo end");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    public static void main(String[] args) {
        TestAlpha test = new TestAlpha();

        Thread threadOne = new Thread(test.mRunnableOne);
        threadOne.start();

        Thread threadTwo = new Thread(test.mRunnableTwo);
        threadTwo.start();
    }

}

可以看到程序输出：

ThreadOne start
ThreadTwo start
ThreadTwo end
ThreadOne end

第二个线程调用notify后，并且执行完后序代码，线程一就会重新获得对象锁，并继续执行。可以在第二个线程nofity后加入更多耗时操作进一步验证。

再接下来，将线程一中的wait换成Thread.sleep()，例如设定等待10s。

Runnable mRunnableOne = new Runnable() {
    @Override
    public void run() {
        synchronized (mLock) {
            try {
                System.out.println("ThreadOne start");
                Thread.sleep(10000);
                System.out.println("ThreadOne end");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
};

这样情况下，由于线程一在等待时没有释放锁，因此线程二不能执行synchronized中的内容，只能等待线程一结束后再运行。

ThreadOne start
ThreadOne end
ThreadTwo start
ThreadTwo end