join(long)与sleep(long)的区别

1.join(long)方法的源码

首先看join()源码:

public final void join() throws InterruptedException {
    join(0);
    }

从源码中可以看出,join()直接调用了join(long)方法,join(long)源码如下:

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(0)是不断的询问线程的状态,直到线程销毁join()方法才会结束。

当millis>0时,不在是wait(0),而是wait(delay),delay是还剩余的millis时间。有人会问第一次wait(delay)后不就已经经过这millis的时间,为什么还会有while执行多次wait(delay)呢?因为这里不仅要考虑wait在delay时间后被唤醒,还要考虑到在delay时间内,被notify唤醒,唤醒后还没有执行到millis的时间,因此要多次调用wait(delay)方法。
2.比较join(long) 与 sleep(long),join方法后语句提前执行问题

join方法底层调用的是wait方法,执行到wait方法可以释放锁,而sleep方法不释放锁

具体细节通过案例来讲解:

首先定义两个线程类:MyThreadA,MyThreadB,其中为了保证两个线程可以同步执行,在MyThreadA中添加一个MyThreadB的实例变量,具体代码如下:

package com.feng.example;


public class MyThreadB extends Thread {


    @Override
    synchronized public void run() {

        try {
            System.out.println("begin B thread, ThreadName="+Thread.currentThread().getName()+"==="+System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end B thread, ThreadName="+Thread.currentThread().getName()+"==="+System.currentTimeMillis());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}
package com.feng.example;


public class MyThreadA extends Thread {

    private Thread b;

    public MyThreadA(Thread b)
    {
        this.b = b;
    }

    @Override
    public void run() {
        try {
            synchronized(b)
            {//只是为了能够和线程b同步
                System.out.println("begin A thread, ThreadName="+Thread.currentThread().getName()+"==="+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("end A thread, ThreadName="+Thread.currentThread().getName()+"==="+System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

测试类如下:

package com.feng.example;

public class ThreadTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        try {
            Thread b = new MyThreadB();
            Thread a = new MyThreadA(b);

            a.start();
            b.start();
            b.join(2000);

            System.out.println("main end"+"==="+System.currentTimeMillis());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

这个案例的结果并不是唯一的。首先看第一种输出情况

begin A thread, ThreadName=Thread-1===1450080738885
end A thread, ThreadName=Thread-1===1450080743886
begin B thread, ThreadName=Thread-0===1450080743886
end B thread, ThreadName=Thread-0===1450080748886
main end===1450080748886

分析:线程a,b, b.join(2000),三者所执行的操作都是以线程实例b作为锁对象的,也就是说三者需要同步执行。一般来说main函数中的代码执行要比启动线程的代码执行要快。(这不是重点),运行结果解释如下:

(1)三者中b.join(2000)首先抢到b的锁,然后代码执行到wait(delay)释放锁对象(去看上面的join(long)源码)

(2)线程a,b争抢锁,线程a获得锁对象,执行synchronized(b){}语句块,执行过程中Thread.sleep(5000)不释放锁,直到执行完成

(3)线程b与b.join(2000)方法争抢锁,线程b抢到锁对象,执行run方法,直到执行完

(4)b.join(2000)获得锁,发现线程b已经销毁,join方法执行完毕。

(5)打印main end语句。

上述解释中join争抢锁可以是在a执行完之后,不影响输出结果。

再看第二种运行情况:

begin A thread, ThreadName=Thread-1===1450082014528
end A thread, ThreadName=Thread-1===1450082019529
main end===1450082019529
begin B thread, ThreadName=Thread-0===1450082019529
end B thread, ThreadName=Thread-0===1450082024530

解释如下:

(1)三者中b.join(2000)首先抢到b的锁,然后代码执行到wait(delay)释放锁对象(去看上面的join(long)源码)

(2)线程a,b争抢锁,线程a获得锁对象,执行synchronized(b){}语句块,执行过程中Thread.sleep(5000)不释放锁,直到执行完成

(3)线程b与b.join(2000)方法争抢锁,b.join抢到锁,发现已经超过2s,因此join方法执行完成,输出main end,释放锁

(4)线程b获得锁,执行run方法

还有一只输出可能,这种可能不好演示,直接给出结果:

begin A thread, ThreadName=Thread-1===1450082014528
end A thread, ThreadName=Thread-1===1450082019529
begin B thread, ThreadName=Thread-0===1450082019529
main end===1450082019529
end B thread, ThreadName=Thread-0===1450082024530

解释如下:

(1)三者中b.join(2000)首先抢到b的锁,然后代码执行到wait(delay)释放锁对象(去看上面的join(long)源码)

(2)线程a,b争抢锁,线程a获得锁对象,执行synchronized(b){}语句块,执行过程中Thread.sleep(5000)不释放锁,直到执行完成

(3)线程b与b.join(2000)方法争抢锁,b.join抢到锁,发现已经超过2s,因此join方法执行完成,释放锁

(4)线程b获得锁,在主线程的输出语句运行之前执行了线程b的run方法,这里main线程与b线程属于异步执行。

从上例中可以看出join与sleep的不同,调用sleep时只是单纯的阻塞,并且不会释放锁。上例同时解释了join方法后语句提前执行的情况。

重点理解join方法获取锁,执行到wait方法直接释放锁的问题。

3.存在的困惑
主线程调用b.join方法,在join方法中是是让线程b执行wait方法,明明是线程b等待,又如何达到让主线程等待的功能呢?

b.wait到底wait的是什么,线程b为什么还能执行????

自我解释:

首先b.wait(),b只是代表一个锁,等待的是执行b.wait()的线程。

join和wait一样,哪个线程执行的此操作,等待的就是哪个线程,和调用者没有关系,调用者只是一个锁对象而已。

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页