Java 线程间的协作(wait/notify/sleep/yield/join)

今天说说这个看了很多遍，又忘了很多遍的知识点:Java线程间的协作。

一、线程的状态

 首先我们需要了解线程在生命周期内经历的几种状态：

1. 新建状态(New)：当线程创建完成时为新建状态，还没有调用start方法时，线程处于新建状态。

2. 就绪状态(Runnable)：就绪状态，当调用线程的的start方法后，线程进入就绪状态，等待CPU资源。处于就绪状态的线程由Java运行时系统的线程调度程序(thread scheduler)来调度。

3. 运行状态(Running)：运行状态，就绪状态的线程获取到CPU执行权以后进入运行状态，开始执行run方法。

4. 阻塞状态(Blocked)：阻塞状态，线程没有执行完，由于某种原因（如，I/O操作等）让出CPU执行权，自身进入阻塞状态。

5. 死亡状态(Dead)：死亡状态，线程执行完成或者执行过程中出现异常，线程就会进入死亡状态。

这五种状态之间的转换关系如下图所示：

有了对这五种状态的基本了解，现在我们来看看Java中是如何实现这几种状态的转换的。

二、wait/notify/notifyAll方法的使用

wait()方法是Object根类中的方法，JDK中提供了两个方法：

 (1)wait()方法的作用是将当前运行的线程挂起（即让其进入阻塞状态），直到notify()或notifyAll()方法来唤醒线程.

 (2)wait(long timeout)，该方法与wait()方法类似，唯一的区别就是在指定时间内，如果没有notify()或notifAll()方法的唤醒，也会自动唤醒。

 下面我们通过一个简单的例子来演示wait()方法的使用：

package concurrent;
/**
 * 让线程暂停一秒后再执行
 * @author Liuwei
 *
 */
public class WaitTest {
    /**
     * 注意需要加synchronized关键字，不然会报IllegalMonitorStateException
     */
    public synchronized void testWait() {
        System.out.println("Thread Start");
        try {
            wait(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread End");
    }

    public static void main(String[] args) {
        final WaitTest test = new WaitTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.testWait();
            }
        }).start();
    }

}

这段代码的意图很简单，就是程序执行以后，让其暂停一秒，然后再执行。值得注意的就是testWait()方法必须加synchronized修饰符，不然会抛IllegalMonitorStateException异常，原因就是调用wait方法时没有获取到monitor对象的所有权,而Java中只能通过Synchronized关键字来获得该对象，monitor对象具体内容这里不多讲，大家可另行参考。

所以，通过这个例子，大家应该很清楚，wait方法的使用必须在同步的范围内，否则就会抛出IllegalMonitorStateException异常，wait方法的作用就是阻塞当前线程等待notify/notifyAll方法的唤醒，或等待超时后自动唤醒。

notify/notifyAll方法

  同样，这两个方法也是由Object类提供，他们是和wait()方法配套使用的，同一对象上去调用notify/notifyAll方法，就可以唤醒对应等待的线程了。notify和notifyAll的区别在于前者只能唤醒一个线程，对其他线程没有影响，而notifyAll则唤醒所有的线程。通过下面的例子很容易理解这两者的差别：

public synchronized void testWait(){
        System.out.println(Thread.currentThread().getName() +"Start----");
        try {
            wait(0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() +"End------");
    }

    public static void main(String[] args) throws InterruptedException {
        final NotifyTest test = new NotifyTest();
        for(int i=0;i<4;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    test.testWait();
                }
            }).start();
        }

        synchronized (test) {
            test.notify();
        }
        Thread.sleep(100);
        System.out.println("-------------------------");

        synchronized (test) {
            test.notifyAll();
        }
    }

  输出结果如下：

Thread-0 Start-----
Thread-0 End-------
Thread-2 Start-----
Thread-3 Start-----
Thread-1 Start-----
-------------------------
Thread-1 End-------
Thread-3 End-------
Thread-2 End-------

  从结果可以看出调用notify方法时只有线程Thread-0被唤醒，但是调用notifyAll时，所有的线程都被唤醒了。

三、sleep/yield/join方法解析

   区别于上面的wait和notify方法，sleep/yield/join这几个并非Object中的方法，而是Thread中的方法，现在我们来逐个研究下:

1、sleep方法

   sleep方法的作用是让当前线程暂停指定的时间（毫秒），需要注意的是其与wait方法的区别。最简单的区别是，wait方法依赖于同步，而sleep方法可以直接调用。而更深层次的区别在于sleep方法只是暂时让出CPU的执行权，并不释放锁，而wait方法则需要释放锁。简单点理解就是使用sleep方法，线程是处于阻塞状态的，而调用wait方法，线程会在被唤醒后重新进入就绪状态竞争CPU资源。

2、yield方法

　　yield方法的作用是暂停当前线程，以便其他线程有机会执行，不过不能指定暂停的时间，并且也不能保证当前线程马上停止。yield方法只是将线程转变为就绪状态。与wait方法类似，但是线程在调用yield方法后，不需要被唤醒，而是直接进入就绪参加CPU资源竞争。
　　在实际开发过程中这个方法的使用场景很少，主要使用的地方是调试和测试。

3、join方法

　　join方法的作用是父线程等待子线程执行完成后再执行，换句话说就是将异步执行的线程合并为同步的线程。JDK中提供三个版本的join方法，其实现与wait方法类似，join()方法实际上执行的join(0)，而join(long millis, int nanos)也与wait(long millis, int nanos)的实现方式一致，暂时对纳秒的支持也是不完整的。我们可以看下join方法的源码，这样更容易理解：
　　

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

　　大家重点关注一下join(long millis)方法的实现，可以看出join方法就是通过wait方法来将线程的阻塞，如果join的线程还在执行，则将当前线程阻塞起来，直到join的线程执行完成，当前线程才能执行。不过有一点需要注意，这里的join只调用了wait方法，却没有对应的notify方法，原因是Thread的start方法中做了相应的处理，所以当join的线程执行完成以后，会自动唤醒主线程继续往下执行。所以调用join方法之后，就可以把程序看做顺序执行就可以了。