暴力突破 Java 并发 - 线程间的协作（wait、notify、notifyAll、yield、join）

Lerendan

于 2020-04-08 10:33:16 发布

阅读量210

点赞数

分类专栏：并发

本文链接：https://blog.csdn.net/u010289802/article/details/105379358

版权

并发专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、线程的状态

Java 中线程中状态可分为五种：

New：新建状态，当线程创建完成时为新建状态，即new Thread(...)，还没有调用start方法时，线程处于新建状态。
Runnable：就绪状态，当调用线程的的start方法后，线程进入就绪状态，等待CPU资源。处于就绪状态的线程由Java运行时系统的线程调度程序(thread scheduler)来调度。
Running：运行状态，就绪状态的线程获取到CPU执行权以后进入运行状态，开始执行run方法。
Blocked：阻塞状态，线程没有执行完，由于某种原因（如，I/O操作等）让出CPU执行权，自身进入阻塞状态。
Dead：死亡状态，线程执行完成或者执行过程中出现异常，线程就会进入死亡状态。

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

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

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

2.1、wait 方法

JDK中一共提供了这三个版本的方法，

wait()方法的作用是将当前运行的线程挂起（即让其进入阻塞状态），直到notify或notifyAll方法来唤醒线程。
wait(long timeout)，该方法与wait()方法类似，唯一的区别就是在指定时间内，如果没有notify或notifAll方法的唤醒，也会自动唤醒。
至于wait(long timeout,long nanos)，本意在于更精确的控制调度时间，不过从目前版本来看，该方法貌似没有完整的实现该功能。

虽然JDK提供了这三个版本，其实最后都是调用wait(long timeout)方法来实现的，wait()方法与wait(0)等效，而wait(long timeout,int nanos)从上面的源码可以看到也是通过wait(long timeout)来完成的。下面我们通过一个简单的例子来演示wait()方法的使用：

public class WaitTest {
    public void testWait(){
        System.out.println("Start-----");
        try {
            wait(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("End-------");
    }

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

这段代码的意图很简单，就是程序执行以后，让其暂停一秒，然后再执行。运行上述代码，查看结果：

Start-----
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at com.paddx.test.concurrent.WaitTest.testWait(WaitTest.java:8)
    at com.paddx.test.concurrent.WaitTest$1.run(WaitTest.java:20)
    at java.lang.Thread.run(Thread.java:745)

这段程序并没有按我们的预期输出相应结果，而是抛出了一个异常。大家可能会觉得奇怪为什么会抛出异常？而抛出的 IllegalMonitorStateException 异常又是什么？我们可以看一下 JDK 中对 IllegalMonitorStateException 的描述：

Thrown to indicate that a thread has attempted to wait on an object's monitor or to 
notify other threads waiting on an object's monitor without owning the specified monitor.

这句话的意思大概就是：线程试图等待对象的监视器或者试图通知其他正在等待对象监视器的线程，但本身没有对应的监视器的所有权。wait方法是一个本地方法，其底层是通过一个叫做监视器锁的对象来完成的。所以上面之所以会抛出异常，是因为在调用wait方式时没有获取到monitor对象的所有权，那如何获取monitor对象所有权？Java中只能通过Synchronized关键字来完成，修改上述代码，增加Synchronized关键字：

public class WaitTest {
    public synchronized void testWait(){//增加Synchronized关键字
        System.out.println("Start-----");
        try {
            wait(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("End-------");
    }

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

现在再运行上述代码，就能看到预期的效果了。所以，通过这个例子，大家应该很清楚，wait方法的使用必须在同步的范围内，否则就会抛出IllegalMonitorStateException异常，wait方法的作用就是阻塞当前线程等待notify/notifyAll方法的唤醒，或等待超时后自动唤醒。

2.2、notify/notifyAll方法

有了对wait方法原理的理解，notify方法和notifyAll方法就很容易理解了。既然wait方式是通过对象的monitor对象来实现的，所以只要在同一对象上去调用notify/notifyAll方法，就可以唤醒对应对象monitor上等待的线程了。notify和notifyAll的区别在于前者只能唤醒monitor上的一个线程，对其他线程没有影响，而notifyAll则唤醒所有的线程，看下面的例子很容易理解这两者的差别：

public class NotifyTest {
    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<5;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    test.testWait();
                }
            }).start();
        }

        synchronized (test) {
            test.notify();
        }
        Thread.sleep(3000);
        System.out.println("-----------分割线-------------");
        
        synchronized (test) {
            test.notifyAll();
        }
    }
}

输出结果如下：

Thread-0 Start-----
Thread-1 Start-----
Thread-2 Start-----
Thread-3 Start-----
Thread-4 Start-----
Thread-0 End-------
-----------分割线-------------
Thread-4 End-------
Thread-3 End-------
Thread-2 End-------
Thread-1 End-------

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

最后，有两点需要注意：

调用wait方法后，线程是会释放对monitor对象的所有权的。
一个通过wait方法阻塞的线程，必须同时满足以下两个条件才能被真正执行：

线程需要被唤醒（超时唤醒或调用notify/notifyll）。
线程唤醒后需要竞争到锁（monitor）。

三、sleep、yield、join 方法

上面我们已经清楚了wait和notify方法的使用和原理，现在我们再来看另外一组线程间协作的方法。这组方法跟上面方法的最明显区别是：这几个方法都位于Thread类中，而上面三个方法都位于Object类中。至于为什么，大家可以先思考一下。现在我们逐个分析sleep/yield/join方法。

3.1、sleep

　　sleep方法的作用是让当前线程暂停指定的时间（毫秒），sleep方法是最简单的方法，在上述的例子中也用到过，比较容易理解。唯一需要注意的是其与wait方法的区别。最简单的区别是，wait方法依赖于同步，而sleep方法可以直接调用。而更深层次的区别在于sleep方法只是暂时让出CPU的执行权，并不释放锁。而wait方法则需要释放锁。

public class SleepTest {
    public synchronized void sleepMethod(){
        System.out.println("Sleep start-----");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Sleep end-----");
    }

    public synchronized void waitMethod(){
        System.out.println("Wait start-----");
        synchronized (this){
            try {
                wait(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Wait end-----");
    }

    public static void main(String[] args) {
        final SleepTest test1 = new SleepTest();

        for(int i = 0;i<3;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    test1.sleepMethod();
                }
            }).start();
        }

        try {
            Thread.sleep(10000);//暂停十秒，等上面程序执行完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----分割线-----");

        final SleepTest test2 = new SleepTest();

        for(int i = 0;i<3;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    test2.waitMethod();
                }
            }).start();
        }
    }
}

执行结果：

Sleep start-----
Sleep end-----
Sleep start-----
Sleep end-----
Sleep start-----
Sleep end-----
-----分割线-----
Wait start-----
Wait start-----
Wait start-----
Wait end-----
Wait end-----
Wait end-----

这个结果的区别很明显，通过sleep方法实现的暂停，程序是顺序进入同步块的，只有当上一个线程执行完成的时候，下一个线程才能进入同步方法，sleep暂停期间一直持有monitor对象锁，其他线程是不能进入的。而wait方法则不同，当调用wait方法后，当前线程会释放持有的monitor对象锁，因此，其他线程还可以进入到同步方法，线程被唤醒后，需要竞争锁，获取到锁之后再继续执行。

3.2、yield

我们知道 start() 方法是启动线程，让线程变成就绪状态等待 CPU 调度后执行。yield 即 "谦让"，也是 Thread 类的方法。它让掉当前线程 CPU 的时间片，使正在运行中的线程重新变成就绪状态，并重新竞争 CPU 的调度权。它可能会获取到，也有可能被其他线程获取到。

下面看看 yield 和 sleep 的异同：

yield, sleep 都能暂停当前线程，sleep 可以指定具体休眠的时间，而 yield 则依赖 CPU 的时间片划分。
yield, sleep 两个在暂停过程中，如已经持有锁，则都不会释放锁资源。
yield 不能被中断，而 sleep 则可以接受中断。

yield 一般很少用到，如果一定要用它的话，一句话解释就是：yield 方法可以很好的控制多线程，如执行某项复杂的任务时，如果担心占用资源过多，可以在完成某个重要的工作后使用 yield 方法让掉当前 CPU 的调度权，等下次获取到再继续执行，这样不但能完成自己的重要工作，也能给其他线程一些运行的机会，避免一个线程长时间占有 CPU 资源。

3.3、join

t.join() 方法只会使主线程（调用t.join的线程）进入等待池并等待 t 线程执行完毕后才会被唤醒，并不影响同一时刻处在运行状态的其他线程。先来看个示例

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        ThreadTest t1=new ThreadTest("A");
        ThreadTest t2=new ThreadTest("B");
        t1.start();
        t2.start();
    }
}

class ThreadTest extends Thread {
    private String name;
    public ThreadTest(String name){
        this.name=name;
    }
    public void run(){
        for(int i=1;i<=5;i++){
            System.out.println(name+"-"+i);
        }		
    }
}

运行结果：

A-1
B-1
B-2
B-3
A-2
B-4
A-3
B-5
A-4
A-5

可以看出 A 线程和 B 线程是并行执行的。而在其中加入 join() 方法后：

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        ThreadTest t1=new ThreadTest("A");
        ThreadTest t2=new ThreadTest("B");
        t1.start();
		t1.join();
        t2.start();
    }
}

class ThreadTest extends Thread {
    private String name;
    public ThreadTest(String name){
        this.name=name;
    }
    public void run(){
        for(int i=1;i<=5;i++){
            System.out.println(name+"-"+i);
        }		
    }
}

运行结果：

A-1
A-2
A-3
A-4
A-5
B-1
B-2
B-3
B-4
B-5

显然，使用 t1.join() 之后，B 线程需要等 A 线程执行完毕之后才能执行。需要注意的是，t1.join() 需要等 t1.start() 执行之后执行才有效果，此外，如果 t1.join() 放在 t2.start() 之后的话，仍然会是交替执行。为了深入理解，我们先看一下join()的源码。

    public final void join() throws InterruptedException {
        join(0);            //join()等同于join(0)
    }

    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);           //join(0)等同于wait(0)，即wait无限时间直到被notify
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

可以看出，join() 方法的底层是利用 wait() 方法实现的。join 方法是一个同步方法，当主线程调用 t1.join() 方法时，主线程先获得了 t1 对象的锁，随后进入方法，调用了 t1 对象的 wait() 方法，使主线程进入了 t1 对象的等待池。此时，A 线程则还在执行，并且随后的 t2.start() 还没被执行，因此，B 线程也还没开始。等到 A 线程执行完毕之后，主线程继续执行，走到了 t2.start()，B 线程才会开始执行。

t.join() 方法只会使主线程进入等待池并等待 t 线程执行完毕后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。join源码中，只会调用 wait 方法，并没有在结束时调用 notify，这是因为线程在 die 的时候会自动调用自身的 notifyAll 方法，来释放所有的资源和锁。

四、总结

本文主要详细讲解了 wait/notify/notifyAll 和 sleep/yield/join 方法。最后回答一下上面提出的问题：wait/notify/notifyAll 方法的作用是实现线程间的协作，那为什么这三个方法不是位于 Thread 类中，而是位于Object类中？位于 Object 中，也就相当于所有类都包含这三个方法（因为Java中所有的类都继承自Object类）。

要回答这个问题，还是得回过来看 wait 方法的实现原理，大家需要明白的是，wait等待其实是对象monitor，由于 Java 中的每一个对象都有一个内置的 monitor 对象，自然所有的类都理应有 wait/notify 方法。

Lerendan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
暴力突破 Java 并发 - 线程间的协作（wait、notify、notifyAll、yield、join）

一、线程的状态Java 中线程中状态可分为五种：New：新建状态，当线程创建完成时为新建状态，即new Thread(...)，还没有调用start方法时，线程处于新建状态。 Runnable：就绪状态，当调用线程的的start方法后，线程进入就绪状态，等待CPU资源。处于就绪状态的线程由Java运行时系统的线程调度程序(thread scheduler)来调度。 Running：运行...
复制链接

扫一扫