一，sleep和wait方法的区别
1.从源码来看
sleep 是Thread类的方法，而且时一个native修饰的方法,是一个原生的方法
/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds, subject to
* the precision and accuracy of system timers and schedulers. The thread
* does not lose ownership of any monitors.
*
* @param millis
* the length of time to sleep in milliseconds
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative
*
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* <i>interrupted status</i> of the current thread is
* cleared when this exception is thrown.
*/
public static native void sleep(long millis) throws InterruptedException;
wait方法是Object类的方法
/**
* Causes the current thread to wait until another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object.
* In other words, this method behaves exactly as if it simply
* performs the call {@code wait(0)}.
* <p>
* The current thread must own this object's monitor. The thread
* releases ownership of this monitor and waits until another thread
* notifies threads waiting on this object's monitor to wake up
* either through a call to the {@code notify} method or the
* {@code notifyAll} method. The thread then waits until it can
* re-obtain ownership of the monitor and resumes execution.
* <p>
* As in the one argument version, interrupts and spurious wakeups are
* possible, and this method should always be used in a loop:
* <pre>
* synchronized (obj) {
* while (<condition does not hold>)
* obj.wait();
* ... // Perform action appropriate to condition
* }
* </pre>
* This method should only be called by a thread that is the owner
* of this object's monitor. See the {@code notify} method for a
* description of the ways in which a thread can become the owner of
* a monitor.
*
* @throws IllegalMonitorStateException if the current thread is not
* the owner of the object's monitor.
* @throws InterruptedException if any thread interrupted the
* current thread before or while the current thread
* was waiting for a notification. The <i>interrupted
* status</i> of the current thread is cleared when
* this exception is thrown.
* @see java.lang.Object#notify()
* @see java.lang.Object#notifyAll()
*/
public final void wait() throws InterruptedException {
wait(0);
}
2.调用方式的不同
- sleep外部可以使。
- wait只能够在synchronized中使用(从上边方法的描述中也可以看出他的使用方式，方法的挂起必须要有notify或者notifyAll来通知他去开始竞争资源)
3.对资源的控制不同
sleep的时候是不会释放锁和cpu的，wait会释放资源（cpu,锁）
这也是下面例子中要着重说的
二，说明示例
代码段1：验证wait()方法是会释放锁和cpu资源的
线程A中使用wait去进行等待， 在启动完A时,A线程挂起，等待通知去竞争锁，主线程睡眠20毫秒,启动BBB线程,B线程睡20毫秒，之后通知A线程去竞争锁。
public static void main(String[] args) {
//创建锁对象
final Object lock = new Object();
// 线程AAA
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread AAA is waiting to get lock");
synchronized (lock) {
System.out.println("thread AAA get lock ");
try {
System.out.println("thread AAA do wait method");
//Thread.sleep(10);
lock.wait();
System.out.println("thread AAA is done");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
try {
//主线程睡眠10毫秒等待让两个线程启动有个竞争锁的过程
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 线程BBB
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread BBB is waiting to get lock");
synchronized (lock) {
System.out.println("thread BBB get lock ");
try {
Thread.sleep(20);
System.out.println("thread BBB do wait method");
System.out.println("thread BBB is done");
lock.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
执行上边代码结果(多次执行结果一致)
thread AAA is waiting to get lock
thread AAA get lock
thread AAA do wait method
thread BBB is waiting to get lock
thread BBB get lock
thread BBB do wait method
thread BBB is done
thread AAA is done
从打印的日志可以看出，AAA 拿到lock锁之后，执行wait方法被线程被挂起来了，然后BBB线程启动，但是BBB获取到了Lock锁，进行了下一步的执行，并通知A线程去竞争锁和资源，可以看出，AAA线程在wait方法挂起时是释放了锁和cpu等资源的，否则将会进入无期限的等待当中，不清楚的化可以对比执行第二段代码，只是将AAA中等待方法替换成了sleep等待方法
代码的2
此段代码中让线程AAA睡眠40毫秒，让线程BBB能够在AAA线程的执行过程中启动去竞争锁。
public static void main(String[] args) {
//创建锁对象
final Object lock = new Object();
// 线程AAA
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread AAA is waiting to get lock");
synchronized (lock) {
System.out.println("thread AAA get lock ");
try {
System.out.println("thread AAA do wait method");
Thread.sleep(40);
// Thread.sleep(20);
System.out.println("thread AAA is done");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
try {
//主线程睡眠10毫秒等待让两个线程启动有个竞争锁的过程
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 线程BBB
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread BBB is waiting to get lock");
synchronized (lock) {
System.out.println("thread BBB get lock ");
try {
Thread.sleep(20);
System.out.println("thread BBB do wait method");
System.out.println("thread BBB is done")；
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
多次执行结果如下
thread AAA is waiting to get lock
thread AAA get lock
thread AAA do wait method
thread BBB is waiting to get lock
thread AAA is done
thread BBB get lock
thread BBB do wait method
thread BBB is done
从执行结果可以看到，BBB的线程虽然是在AAA线程的执行过程中启动了，但是一直没有获取到lock锁，一直在等待，当AAA线程执行完之后，BBB才获取到锁，所以线程使用再使用sleep方法睡眠时并没有释放锁和cpu资源。
