(九)、线程sleep和wait的区别

功能差不多，都用来进行线程控制。

sleep()方法

sleep是线程类（Thread）的静态方法。

sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行。

例如

try{
    System.out.println("I'm going to bed");
    Thread.sleep(1000);
    System.out.println("I wake up");
}catch(IntrruptedException e) {
}

让调用的线程进入指定时间睡眠状态，使得当前线程进入阻塞状态，告诉系统至少在指定时间内不需要为线程调度器为该线程分配执行时间片，给执行机会给其他线程（实际上，调用sleep()方法时并不要求持有任何锁，即sleep()可在任何地方使用。），但是监控状态依然保持，到时后会自动恢复。

sleep()休眠时间满后，该线程不一定会立即执行，这是因为其他线程可能正在运行而起没有被调度为放弃执行，除非此线程具有更高的优先级。

 sleep()必须捕获异常。

在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块(可能还有finally语句块)以及以后的代码。

在没有锁的情况下，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

wait()方法

wait()方法是Object类里的方法。

当一个线程执行wait()方法时，它就进入到一个和该对象相关的等待池中（进入等待队列，也就是阻塞的一种，叫等待阻塞），同时释放对象锁，并让出CPU资源，待指定时间结束后返还得到对象锁。

wait()使用notify()方法、notiftAll()方法或者等待指定时间来唤醒当前等待池中的线程。

try{
    obj.wait();  //suspend thread until obj.notify() is called
}catch(InterrputedException e) {
}

等待的线程只是被激活，但是必须得再次获得锁才能继续往下执行，也就是说只要锁没被释放，原等待线程因为为获取锁仍然无法继续执行。

notify的作用只负责唤醒线程，线程被唤醒后有权利重新参与线程的调度。

wait()方法、notify()方法和notiftAll()方法用于协调多线程对共享数据的存取，所以只能在同步方法或者同步块中使用，否则抛出IllegalMonitorStateException。

两者的区别

（1）属于不同的两个类，sleep()方法是线程类（Thread）的静态方法，wait()方法是Object类里的方法。

（2）sleep()方法不会释放锁，wait()方法释放对象锁。

（3）sleep()方法可以在任何地方使用，wait()方法则只能在同步方法或同步块中使用。

（4）sleep()必须捕获异常，wait()方法、notify()方法和notiftAll()方法不需要捕获异常。

（5）sleep()使线程进入阻塞状态（线程睡眠），wait()方法使线程进入等待队列（线程挂起），也就是阻塞类别不同。

   (6)  它们都可以被interrupted方法中断。

wait(1000)与sleep(1000)的区别

Thread.Sleep(1000) 

意思是在未来的1000毫秒内本线程不参与CPU竞争，1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束。

即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。

另外值得一提的是Thread.Sleep(0)的作用，就是触发操作系统立刻重新进行一次CPU竞争，竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。

wait(1000)

表示将锁释放1000毫秒，到时间后如果锁没有被其他线程占用，则再次得到锁，然后wait方法结束，执行后面的代码，如果锁被其他线程占用，则等待其他线程释放锁。

注意，设置了超时时间的wait方法一旦过了超时时间，并不需要其他线程执行notify也能自动解除阻塞，但是如果没设置超时时间的wait方法必须等待其他线程执行notify。

实例：

public class test{
    public static void main(String[] args) {
        Integer i = new Integer(1);
        new Thread(new waitThread(i)).start();
        new Thread(new notifyThread(i)).start();
    }
}

class waitThread implements Runnable{
    Integer i;
    public waitThread(Integer i){
        super();
        this.i = i;
    }

    @Override
    public void run(){
        try{
            synchronized(i){
                long start = System.currentTimeMillis();
                i.wait(1000);
                System.out.println("waitThread "+(System.currentTimeMillis()-start)+" done");
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}

class notifyThread implements Runnable{
    Integer i;
    public notifyThread(Integer i){
        super();
        this.i = i;
    }

    @Override
    public void run(){
        try{
            long start = System.currentTimeMillis();
            //如果此处设成1500，因为sleep没有占有锁，wait方法在1000ms后会自动再次获得锁然后解除阻塞执行。
            Thread.sleep(500); 
            synchronized(i){
                Thread.sleep(1500);
                //如果wait过了超时时间，无论有无notify，wait都会自动解除阻塞，即该句可以注释，不影响结果。
                //但是如果wait没有设置超时时间，该句必须存在，否则waitThread用于处于阻塞状态。
                i.notify();
                System.out.println("notifyThread "+(System.currentTimeMillis()-start)+" done");
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}

join()方法：

       join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉异常。

yield()方法:

       该方法与sleep()类似，都是可以让当前正在运行的线程暂停，区别在于yield()方法不会阻塞该线程，它只是将线程转换成就绪状态，让系统的调度器重新调度一次，并且yield()方法只能让优先级相同或许更高的线程有执行的机会。