java多线程join()详解

join()方法的作用：使所属的线程对象A正常执行，而使当前线程B进行无限期的阻塞，执行线程A执行结束销毁以后，线程B才会继续执行。

通过代码理解一下：

package join;

public class MyTest {
	public static void main(String[] args) throws InterruptedException {
		MyThread mt = new MyThread();
		mt.start();
		mt.join();
		System.out.println("main Thread end:" + System.currentTimeMillis());
	}
}

package join;

public class MyThread extends Thread {
	public void run() {
		System.out.println("MyThread begin:" + System.currentTimeMillis());
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

可以看出，main线程并没有立刻执行输出，而是等2秒以后，也就是MyThread线程执行结束以后，才继续执行。

join(long)方法：将上面的mt.join()改成mt.join(1000)，执行结果

可以看出，mian线程只等待了1秒，并没有等待MyThread线程结束。

join(long)带参数的用法：

public class MyTest2 {
	public static void main(String[] args) throws InterruptedException {
		MyThreadA a = new MyThreadA();
		MyThreadB b = new MyThreadB(a);

		b.start();
		b.join(1000);
		System.out.println("打印1:" + System.currentTimeMillis());
		a.start();
		System.out.println("打印2:" + System.currentTimeMillis());
	}
}

public class MyThreadB extends Thread {
	private MyThreadA a;

	public MyThreadB() {
	}
	
	public MyThreadB(MyThreadA a) {
		this.a = a;
	}

	public void run() {
		synchronized (a) {
			try {
				System.out.println("MyThreadB 执行了:" + System.currentTimeMillis());
				Thread.sleep(5000);
				System.out.println("MyThreadB 执行结束了:" + System.currentTimeMillis());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

public class MyThreadA extends Thread {
	public synchronized void run() {
		try {
			System.out.println("MyThreadA 执行了:" + System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("MyThreadA 执行结束:" + System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

分析下执行过程：

1、main线程执行b.start()方法，b线程处于了就绪状态，此时cpu并没有把时间资源给b线程， 所以main线程接着执行了b.join(1000)，main线程阻塞1秒钟。
2、b线程获得了时间资源执行了run()方法，并且获得了线程a的锁。
3、b线程执行sleep(5000)，sleep()方法并不会释放锁，此时main线程等待了1秒以后，main线程处于了就绪状态，由于b线程还处于阻塞，因此main线程获得了时间资源，执行了‘打印1’。
4、main线程继续往下执行，调用a对象start()，由于start方法是同步的，因此main线程需要等b线程释放对象a的锁,所以main线程又进入阻塞状态。
5、5秒以后线程b释放对象a的锁,main线程获得了a的锁，执行了a.start()方法，此时a线程处于就绪状态，与第一条类似，main线程优先执行了‘打印2’。
6、最后线程a执行run()方法,5秒后结束

将MyThreadB类稍作修改。

public class MyThreadB extends Thread {
	private MyThreadA a;

	public MyThreadB() {
	}
	
	public MyThreadB(MyThreadA a) {
		this.a = a;
	}

	public void run() {
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
		synchronized (a) {
			try {
				System.out.println("MyThreadB 执行了:" + System.currentTimeMillis());
				Thread.sleep(5000);
				System.out.println("MyThreadB 执行结束了:" + System.currentTimeMillis());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

读者可以自行分析此执行结果的过程。

join(long)与sleep(long)的区别：两者最大的区别就在于，join(long)方法是使用wait(long)时间的，因此具有释放锁的效果，而sleep并不会释放锁。

最后附上start(),join()源码

public synchronized void start() {
        /**
	 * This method is not invoked for the main method thread or "system"
	 * group threads created/set up by the VM. Any new functionality added 
	 * to this method in the future may have to also be added to the VM.
	 *
	 * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        start0();
        if (stopBeforeStart) {
	    stop0(throwableFromStop);
	}
    }

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;
	    }
	}
    }

可以看出2个方法都是同步的。