Java中线程的join()方法的使用

join()方法和join(long)方法

子线程调用join()方法之后，主线程会在子线程调用join()方法处阻塞，直到子线程执行完毕销毁，然后继续执行join()方法后主线程的代码。
join()方法示例代码如下：

public class MyThread extends Thread{

    @Override
    public void run() {
        try {
            System.out.println("我是子线程");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

class test{
    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        MyThread myThread = new MyThread();
        myThread.start();
        myThread.join();
        long end = System.currentTimeMillis();
        System.out.println("前面代码执行用了"+(end-start)+"毫秒，子线程执行完了，主线程接着执行！");
    }
}

执行结果：
	我是子线程
	前面代码执行用了2008毫秒，子线程执行完了，主线程接着执行！

join(long)方法中的参数是等待时间，当时间到了并重新获得了锁，则当前线程会继续向后运行，如果没有重新获得锁，则一直尝试，直到获得锁为止。
join(long)方法示例代码如下：

public class MyThread extends Thread{

    @Override
    public void run() {
        try {
            System.out.println("我是子线程1");
            Thread.sleep(2000);
            System.out.println("我是子线程2");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

class test{
    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        MyThread myThread = new MyThread();
        myThread.start();
        myThread.join(1000);
        long end = System.currentTimeMillis();
        System.out.println("前面代码执行用了"+(end-start)+"毫秒，主线程接着执行！");
    }
}
执行结果：
	我是子线程1
	前面代码执行用了1016毫秒，主线程接着执行！
	我是子线程2

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()方法是通过wait(long)方法实现线程暂停的，由于调用wait()方法后锁会被释放所以join()方法被调用后会释放当前持有的锁。

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

方法	描述
join方法	会立即释放所持有的锁，意味着其他线程就可以调用当前线程中的同步方法了
Thread.sleep(long)	不释放锁，意味着线程只能阻塞在当前调用位置等待睡眠时间结束，其他线程不能调用当前线程中的同步方法

join方法立即释放锁代码示例

public class MyThread extends Thread{
    private MyThread1 myThread1;
    public MyThread(MyThread1 myThread1){
        this.myThread1 = myThread1;
    }
    @Override
    public void run() {
        synchronized (myThread1){
            try {
                long start = System.currentTimeMillis();
                myThread1.start();
                myThread1.join();
                long end = System.currentTimeMillis();
                System.out.println("用时"+(end-start)+"---结束---MyThread");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class MyThread1 extends Thread{
    @Override
    public void run() {
        try {
            System.out.println("MyThread1");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    public synchronized void myThread1Test(){
        System.out.println("myThread1Test()方法执行了！");
    }
}
class MyThread2 extends Thread{
    private MyThread1 myThread1;
    public MyThread2(MyThread1 myThread1){
        this.myThread1 = myThread1;
    }
    @Override
    public void run() {
        myThread1.myThread1Test();
    }
}

class test{
    public static void main(String[] args) throws InterruptedException {
        MyThread1 myThread1 = new MyThread1();
        MyThread myThread = new MyThread(myThread1);
        MyThread2 myThread2 = new MyThread2(myThread1);
        myThread.start();
        //保证myThread的run方法先执行
        Thread.sleep(500);
        myThread2.start();
    }
}

执行结果：
	MyThread1
	myThread1Test()方法执行了！
	用时2009---结束---MyThread

Thread.sleep(long)不释放锁代码示例

public class MyThread extends Thread{

    private MyThread1 myThread1;
    public MyThread(MyThread1 myThread1){
        this.myThread1 = myThread1;
    }

    @Override
    public void run() {
        synchronized (myThread1){
            try {
                long start = System.currentTimeMillis();
                myThread1.start();
                Thread.sleep(2000);
                long end = System.currentTimeMillis();
                System.out.println("用时"+(end-start)+"---结束---MyThread");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class MyThread1 extends Thread{

    @Override
    public void run() {
        System.out.println("MyThread1");
    }

    public synchronized void myThread1Test(){
        System.out.println("myThread1Test()方法执行了！");
    }
}
class MyThread2 extends Thread{

    private MyThread1 myThread1;
    public MyThread2(MyThread1 myThread1){
        this.myThread1 = myThread1;
    }

    @Override
    public void run() {
        myThread1.myThread1Test();
    }
}

class test{
    public static void main(String[] args) throws InterruptedException {
        MyThread1 myThread1 = new MyThread1();
        MyThread myThread = new MyThread(myThread1);
        MyThread2 myThread2 = new MyThread2(myThread1);
        myThread.start();
        //保证myThread的run方法先执行
        Thread.sleep(500);
        myThread2.start();
    }
}
执行结果：
	MyThread1
	用时2012---结束---MyThread
	myThread1Test()方法执行了！