sleep和wait有什么区别

### sleep和wait的区别有：
	  1、这两个方法来着不同的类
		  （1）sleep来自Thread类
		  （2）wait来自Object类。
	  2、是否释放锁
		  （1）sleep方法没有释放锁
		  （2）wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
	  3、使用的区别
		  （1）wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用
		  （2）sleep可以在任何地方使用。
	   4、是否捕获异常，
		   （1）sleep和wait都需要捕获异常
	   5、都不占用cpu分片时间 
	   
	   
### 1、是否释放锁
#### 1.1 sleep方法

```java

/**
 * 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
 * interrupted status of the current thread is
 * cleared when this exception is thrown.
 */
 public static native void sleep(long millis) throws InterruptedException;
```

描述中有句“The thread does not lose ownership of any monitors.”即“线程不会失去任何监视器的所有权"，所以证明sleep方法会一直持有锁。

```
public class LockReleaseTest extends Thread{
    private static final Object lock = new Object();
    public static void main(String[] args) {
        new LockReleaseTest().start();
        new LockReleaseTest().start();
    }

@Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName()+":持有锁");
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + ":释放锁");
    }
}
```
控制台打印

Thread-0:持有锁
	Thread-0:释放锁
	Thread-1:持有锁
	Thread-1:释放锁
	
可以看出Thread-0中调用sleep时Thread-1无法获取锁

#### 1.2 wait方法

```java
 /**
 * 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)}.
 * 
 * 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.
 * 
 * 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 interrupted
 * status 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);
 }
```

描述中有句“The thread releases ownership of this monitor and waits until another thread  notifies threads waiting on this object's monitor to wake up”即“线程释放此监视器的所有权并等待，直到另一个线程通知等待此对象监视器的线程唤醒。

```java
public class LockReleaseTest extends Thread{
    private static final Object lock = new Object();
    public static void main(String[] args) {
        new LockReleaseTest().start();
        new LockReleaseTest().start();
    }

@Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName()+":持有锁");
                lock.wait(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + ":释放锁");
            }
        }
    }
}
```
控制台打印

Thread-0:持有锁
	Thread-1:持有锁
	Thread-1:释放锁
	Thread-0:释放锁
可以看出Thread-0中调用wait时Thread-1已经获取锁