Java学习者须知的Java中join方法介绍与用法

　　方法Join 是干啥用的? 简单回答，同步，如何同步? 怎么实现的? 下面将逐个回答。

　　自从接触java 多线程，一直对Join 理解不了。JDk 是这样说的：join public final void join (long millis )throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever. 大家能理解吗? 字面意思是等待一段时间直到这个线程死亡，我的疑问是那个线程，是它本身的线程还是调用它的线程的，上代码：

　　package concurrentstudy;

　　/**

　　*

　　* @author vma

　　*/

　　public class JoinTest {

　　public static void main(String[] args) {

　　Thread t = new Thread( new RunnableImpl());

　　t.start();

　　try {

　　t.join(1000) ; // 主线程只等1 秒，不管子线程什么时候结束

　　System.out.println("joinFinish");

　　} catch (InterruptedException e) {

　　// TODO Auto-generated catch block

　　e.printStackTrace();

　　}

　　}

　　}

　　class RunnableImpl implements Runnable {

　　@Override

　　public void run() {

　　try {

　　System.out.println("Begin sleep");

　　Thread.sleep(1000);

　　System.out.println("End sleep");

　　} catch (InterruptedException e) {

　　e.printStackTrace();

　　}

　　}

　　}

　　结果是：

　　Begin sleep

　　End sleep

　　joinFinish

　　明白了吧， 当main 线程调用t.join 时，main 线程等待t 线程 ，等待时间是1000 ，如果t 线程Sleep 2000 呢

　　public void run() {

　　try {

　　System.out.println("Begin sleep");

　　// Thread.sleep(1000);

　　Thread.sleep(2000) ;

　　System.out.println("End sleep");

　　} catch (InterruptedException e) {

　　e.printStackTrace();

　　}

　　}

　　结果是：

　　Begin sleep

　　joinFinish

　　End sleep

　　也就是说 main 线程只等1000 毫秒，不管T 什么时候结束 ，如果是t.join() 呢， 看代码：

　　public final void join() throws InterruptedException {

　　join(0);

　　}

　　就是说如果是t.join() = t.join(0) 　JDK 这样说的 A timeout of 0 means to wait forever 字面意思是永远等待，是这样吗?

　　其实是等到t 结束后。

　　这个是怎么实现的吗? 看JDK 代码：

　　/**

　　* Waits at most millis milliseconds for this thread to

　　* die. A timeout of 0 means to wait forever.

　　*

　　* @param millis the time to wait in milliseconds.

　　* @exception InterruptedException if any thread has interrupted

　　* the current thread. The interrupted status of the

　　* current thread is cleared when this exception is thrown.

　　*/

　　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 对象的锁 ，如果拿不到它是无法wait 的，刚开的例子t.join(1000) 不是说明了main 线程等待1 秒，如果在它等待之前，其他线程获取了t 对象的锁，它等待时间可不就是1 毫秒了。上代码介绍：

　　/*

　　* To change this template, choose Tools | Templates

　　* and open the template in the editor.

　　*/

　　package concurrentstudy;

　　/**

　　*

　　* @author vma

　　*/

　　public class JoinTest {

　　public static void main(String[] args) {

　　Thread t = new Thread( new RunnableImpl());

　　new ThreadTest(t).start();// 这个线程会持有锁

　　t.start();

　　try {

　　t.join();

　　System.out.println("joinFinish");

　　} catch (InterruptedException e) {

　　// TODO Auto-generated catch block

　　e.printStackTrace();

　　}

　　}

　　}

　　class ThreadTest extends Thread {

　　Thread thread;

　　public ThreadTest(Thread thread) {

　　this .thread = thread;

　　}

　　@Override

　　public void run() {

　　holdThreadLock();

　　}

　　public void holdThreadLock() {

　　synchronized (thread) {

　　System.out.println("getObjectLock");

　　try {

　　Thread.sleep(9000);

　　} catch (InterruptedException ex) {

　　ex.printStackTrace();

　　}

　　System.out.println("ReleaseObjectLock");

　　}

　　}

　　}

　　class RunnableImpl implements Runnable {

　　@Override

　　public void run() {

　　try {

　　System.out.println("Begin sleep");

　　Thread.sleep(2000);

　　System.out.println("End sleep");

　　} catch (InterruptedException e) {

　　e.printStackTrace();

　　}

　　}

　　}

　　在main 方法中 通过new ThreadTest(t).start(); 实例化ThreadTest 线程对象， 它在 holdThreadLock() 方法中，通过 synchronized (thread) ，获取线程对象t 的锁，并Sleep (9000 )后释放，这就意味着，即使

　　main 方法t.join(1000), 等待一秒钟，它必须等待 ThreadTest 线程释放t 锁后才能进入wait 方法中，它实际等待时间是9000+1000 MS

　　运行结果是：

　　getObjectLock

　　Begin sleep

　　End sleep

　　ReleaseObjectLock

　　joinFinish