简谈Java的join()方法

　　join()是Thread类的一个方法。根据jdk文档的定义：

public final void join()throws InterruptedException: Waits for this thread to die.
join()方法的作用，是等待这个线程结束

　　但显然，这样的定义并不清晰。个人认为"Java 7 Concurrency Cookbook"的定义较为清晰：

join() method suspends the execution of the calling thread until the object called finishes its execution.

　　也就是说，t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；通常用于在main()主线程内，等待其它线程完成再结束main()主线程。例如：

package com.bijian.test;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class JoinTester01 implements Runnable {

	private String name;

	public JoinTester01(String name) {
		this.name = name;
	}

	public void run() {
		System.out.printf("%s begins: %s\n", name, new Date());
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.printf("%s has finished: %s\n", name, new Date());
	}

	public static void main(String[] args) {
		
		Thread thread1 = new Thread(new JoinTester01("One"));
		Thread thread2 = new Thread(new JoinTester01("Two"));
		thread1.start();
		thread2.start();

		try {
			thread1.join();
			thread2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("Main thread is finished");
	}
}

　　上述代码如果没有join()方法，输出如下：

Main thread is finished
One begins: Wed Aug 28 10:21:36 CST 2013
Two begins: Wed Aug 28 10:21:36 CST 2013
Two has finished: Wed Aug 28 10:21:40 CST 2013
One has finished: Wed Aug 28 10:21:40 CST 2013

　　但有了join()方法，输出如下：

One begins: Sun Jan 20 17:53:38 CST 2019
Two begins: Sun Jan 20 17:53:38 CST 2019
Two has finished: Sun Jan 20 17:53:42 CST 2019
One has finished: Sun Jan 20 17:53:42 CST 2019
Main thread is finished

　　可以看出主线程main比其它两个线程先结束。

　　最后来深入了解一下join()，请看其源码：

/**
 * Waits at most {@code millis} milliseconds for this thread to
 * die. A timeout of {@code 0} means to wait forever.
 *
 * <p> This implementation uses a loop of {@code this.wait} calls
 * conditioned on {@code this.isAlive}. As a thread terminates the
 * {@code this.notifyAll} method is invoked. It is recommended that
 * applications not use {@code wait}, {@code notify}, or
 * {@code notifyAll} on {@code Thread} instances.
 *
 * @param  millis
 *         the time to wait in milliseconds
 *
 * @throws  IllegalArgumentException
 *          if the value of {@code millis} is negative
 *
 * @throws  InterruptedException
 *          if any thread has interrupted the current thread. The
 *          <i>interrupted status</i> of the current thread is
 *          cleared when this exception is thrown.
 * 此处A timeout of 0 means to wait forever 字面意思是永远等待，其实是等到t结束后
 */
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（小提示：Object 提供的方法）。 当main线程调用t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程 ，比如退出后。这就意味着main 线程调用t.join时，必须能够拿到线程t对象的锁。

package com.bijian.test;

public class JoinTester02 implements Runnable {

	Thread thread;

	public JoinTester02(Thread thread) {
		this.thread = thread;
	}

	public void run() {
		synchronized (thread) {
			System.out.println("getObjectLock");
			try {
				Thread.sleep(9000);
			} catch (InterruptedException ex) {
				ex.printStackTrace();
			}
			System.out.println("ReleaseObjectLock");
		}
	}

	public static void main(String[] args) {
		Thread thread = new Thread(new JoinTester01("Three"));
		Thread getLockThread = new Thread(new JoinTester02(thread));

		getLockThread.start();
		thread.start();

		try {
			thread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("Main finished!");
	}
}

 　　输出如下：

getObjectLock
Three begins: Sun Jan 20 18:05:31 CST 2019
Three has finished: Sun Jan 20 18:05:35 CST 2019
ReleaseObjectLock
Main finished!

　　getLockThread通过 synchronized(thread)，获取线程对象t的锁，并Sleep（9000）后释放，这就意味着，即使main方法t.join(1000)等待一秒钟，它必须等待ThreadTest 线程释放t锁后才能进入wait方法中。

 

文章来源：https://www.cnblogs.com/techyc/p/3286678.html