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不能结束。意味着执行顺序不能依赖代码先后顺序。