JDK源码笔记--Object
public final native Class<?> getClass(); public native int hashCode(); public boolean equals(Object obj) { return (this == obj); } protected native Object clone() throws CloneNotSupportedException; public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } public final native void notify(); public final native void notifyAll(); public final native void wait(long timeout) throws InterruptedException; public final void wait() throws InterruptedException { wait(0); } protected void finalize() throws Throwable { }
重点看看wait(),notify(),notifyAll()方法
首先是都是final native 修饰的。
monitor
暂且译成监听器,相当于对象锁。
notify的注释:
/** * Wakes up a single thread that is waiting on this object's * monitor. If any threads are waiting on this object, one of them * is chosen to be awakened. The choice is arbitrary and occurs at * the discretion of the implementation. A thread waits on an object's * monitor by calling one of the {@code wait} methods.
唤醒正在等待该对象的单个线程,如果有多个线程在等待获取某个对象的监听器,只唤醒其中一个。
@throws IllegalMonitorStateException if the current thread is not * the owner of this object's monitor.
如果当前线程没拥有监听器就抛异常 IllegalMonitorStateException,这就是为什么notify,notifyAll必须在synchronized代码中执行。
notifyAll的注释:
/** * Wakes up all threads that are waiting on this object's monitor. A * thread waits on an object's monitor by calling one of the * {@code wait} methods.
唤醒在该对象监视器上等待的所有线程,但是只有一个最终获得监听器。
@throws IllegalMonitorStateException if the current thread is not * the owner of this object's monitor.
同上。
wait的注释:
/** * Causes the current thread to wait until either another thread invokes the * {@link java.lang.Object#notify()} method or the * {@link java.lang.Object#notifyAll()} method for this object, or a * specified amount of time has elapsed.
* <ul> * <li>Some other thread invokes the {@code notify} method for this * object and thread <var>T</var> happens to be arbitrarily chosen as * the thread to be awakened. * <li>Some other thread invokes the {@code notifyAll} method for this * object. * <li>Some other thread {@linkplain Thread#interrupt() interrupts} * thread <var>T</var>. * <li>The specified amount of real time has elapsed, more or less. If * {@code timeout} is zero, however, then real time is not taken into * consideration and the thread simply waits until notified. * </ul>
导致当前线程等待,直到另一个线程调用notify(),notifyAll(),线程中断,或者超过指定的时间。
当调用wait(),实际上是调用的wait(0)表示无限等下去,也可以指定如wait(1000)表示等待一秒就继续执行。
wait()方法会放弃对象锁,sleep()不会。
* the condition that should have caused the thread to be awakened, and * continuing to wait if the condition is not satisfied. In other words, * waits should always occur in loops, like this one: * <pre> * synchronized (obj) { * while (<condition does not hold>) * obj.wait(timeout); * ... // Perform action appropriate to condition * } * </pre>
建议wait(time)的方法放在while循环中。
* @throws IllegalArgumentException if the value of timeout is * negative. * @throws IllegalMonitorStateException if the current thread is not * the owner of the object's monitor. * @throws InterruptedException if any thread interrupted the
当时间参数not in the range 0-999999,抛异常IllegalArgumentException
当线程未获得对象锁,抛异常IllegalMonitorStateException。这就是wait()要在synchronized中执行。
当线程被中断,抛异常InterruptedException
一个栗子:
public class Test2 implements Runnable { static Object a = new Object(); public static void main(String[] args) throws InterruptedException { Test2 t2 = new Test2(); Thread thread = new Thread(t2); thread.start(); //TimeUnit.MILLISECONDS.sleep(1000); synchronized (a) { System.out.println("notify start"+System.currentTimeMillis()); a.notify(); System.out.println("notify end"+System.currentTimeMillis()); } } @Override public void run() { synchronized (a) { try { System.out.println("wait start" + System.currentTimeMillis()); a.wait(); System.out.println("wait end" + System.currentTimeMillis()); } catch (InterruptedException e) { e.printStackTrace(); } } } }
当TimeUnit.MILLISECONDS.sleep(1000);注释掉时,控制台:
notify start1517303479751 notify end1517303479752 wait start1517303479752
notify执行完了才执行wait,导致wait不能结束。意味着执行顺序不能依赖代码先后顺序。