欢迎使用CSDN-markdown编辑器

Java的notify()和wait()

作为线程间通信很重要的机制，wait()和notify()函数想必大家都是很熟悉的，但是今天阅读Object源码的时候碰到这样一件有趣的事情：/**
* Causes a thread which is waiting on this object's monitor (by means of
* calling one of the {@code wait()} methods) to be woken up. If more than
* one thread is waiting, one of them is chosen at the discretion of the
* VM. The chosen thread will not run immediately. The thread
* that called {@code notify()} has to release the object's monitor first.
* Also, the chosen thread still has to compete against other threads that
* try to synchronize on the same object.
* <p>
* This method can only be invoked by a thread which owns this object's
* monitor. A thread becomes owner of an object's monitor
* </p>
* <ul>
* <li>by executing a synchronized method of that object;</li>
* <li>by executing the body of a {@code synchronized} statement that
* synchronizes on the object;</li>
* <li>by executing a synchronized static method if the object is of type
* {@code Class}.</li>
* </ul>
*
* @see #notifyAll
* @see #wait()
* @see #wait(long)
* @see #wait(long,int)
* @see java.lang.Thread
*/
public final native void notify();
可以看到这样一句话，notify()并不会使得调用相应wait()函数的线程立即执行，而是要等到调用notify()函数的线程释放掉相应的监视器占用，而且即使这样，它也可能需要和其他线程继续竞争相应的监视器，我们可以构造如下进行验证：

public class Test {    public static void main(String[] args) throws InterruptedException {        final Integer tp = 0;        final long start = System.currentTimeMillis();        Thread aThread = new Thread() {            public void run() {                synchronized (tp) {                    try {                        tp.wait();                        System.out.println("" + (System.currentTimeMillis() - start));                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            };        };        Thread bThread = new Thread() {            public void run() {                synchronized (tp) {                    try {                        tp.notify();                        System.out.println("" + (System.currentTimeMillis() - start));                        sleep(5 * 1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            };        };        aThread.start();        bThread.start();        aThread.join();        bThread.join();    }}

结果为: 0 5001，可以很清晰的理解这个东西了。