一个demo理解Thread之join()方法

    最近在看以前写的笔记的时候，发现有很多知识上的细节还可以细细揣摩。比如本文标题所说的join()方法的使用。笔记上写的是:

join合并线程，待此线程执行完成后，再执行其它线程，其它线程阻塞。

以前不假思索的也就过去了，现在再回头看，我觉得这句话就有待商榷。

看了一下api，上面说：

等待这个线程死亡。

单从api上看，既没有说明会合并线程，也没有说明会阻塞其它线程。

几行简单的代码测试一下就知道了。

1. 从一个线程开始测试，代码如下：

   public class TestJoin {
   	public static void main(String[] args) {
   		Join join = new Join();
   		Thread t1 = new Thread(join,"join01");
   		t1.start();
   		for (int i = 1; i <= 10; i++) {
   			System.out.println("main执行到第"+i+"次");
   			if(i ==5){
   				try {
   					t1.join();
   				} catch (InterruptedException e) {
   					e.printStackTrace();
   				}
   			}
   		}
   	}
   }
   
   class Join implements Runnable{
   
   	public void run() {
   		for (int i = 1; i <= 10; i++) {
   			System.out.println(Thread.currentThread().getName()+"----执行到第"+i+"次");
   		}
   	}
   	
   }

   运行结果大致如下：

         

也就是说，当在main函数中执行t1.join()方法，每次都会等到join01执行完毕后，main方法才会执行第6次及其后面的代码逻辑。

那么，api中的 "等待这个线程死亡。" 这个，应该指的就是调用该方法的对象。即指上例中的join01线程。就是说直到调用join()方法的join01线程执行结束，才会执行mian后面的代码逻辑。此时main是被阻塞的。

既然这句话到这里已经说完了，其实到这里本该已经结束了。但是，本着对笔记上记的那句话的探究，我们下面再测试了一下：

2.增加为两个线程。

public class TestJoin {
	public static void main(String[] args) {
		Join join = new Join();
		Thread t1 = new Thread(join,"join01");
		Thread t2 = new Thread(join,"join02");
		t1.start();
		t2.start();
		for (int i = 1; i <= 10; i++) {
			System.out.println("main执行到第"+i+"次");
			if(i ==5){
				try {
					t1.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

class Join implements Runnable{

	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println(Thread.currentThread().getName()+"----执行到第"+i+"次");
		}
	}
	
}

运行结果取以下3中情况：

 

根据这三个结果可以推断出：

在t1调用join()方法时，除了执行该方法的main线程被阻塞外，其余的线程不受影响。这就跟开头说的那句话相悖了！

既然结论不一样，那就看一下源码：

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

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) {//millis传入为0，走这里
            while (isAlive()) {//判断线程是否存活，存活则继续
                wait(0);//实际是main线程等待，阻塞。
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

从源码上可以看出，join方法是同步的。t1.join方法，其实执行的是t1.wait方法。

那么由于是在main方法中执行的。需要弄清楚的一点是：调用t1.join()的是main线程，join()方法属于join01这个线程。

所以是main线程指示join01线程调用了join方法，而不是join01线程调用自己的join方法。因此wait()方法是在main方法的调用栈中。这样，在main方法中执行t1.join()方法，main方法就会被wait方法加入到join01的阻塞队列中。

最后总结就是：

在当前线程中，另一个线程调用join()方法会使当前线程被阻塞，直到这个调用join方法的线程执行结束。
同理，在当前线程中，多个线程调用join()方法会使当前线程被阻塞，直到所有调用join方法的线程执行结束。

再加一句：其余未调用join方法的线程不受影响，正常执行。

所以文章开头说的那句话是不对的。