浅析 Java Thread.join()

一、在研究join的用法之前,先明确两件事情。
1.join方法定义在Thread类中,则调用者必须是一个线程,
例如:
Thread t = new CustomThread();//这里一般是自定义的线程类
t.start();//线程起动
t.join();//此处会抛出InterruptedException异常

2.上面的两行代码也是在一个线程里面执行的。
以上出现了两个线程,一个是我们自定义的线程类,我们实现了run方法,做一些我们需要的工作;另外一个线程,生成我们自定义线程类的对象,然后执行
customThread.start();
customThread.join();
在这种情况下,两个线程的关系是一个线程由另外一个线程生成并起动,所以我们暂且认为第一个线程叫做“子线程”,另外一个线程叫做“主线程”。

二、为什么要用join()方法
主线程生成并起动了子线程,而子线程里要进行大量的耗时的运算(这里可以借鉴下线程的作用),当主线程处理完其他的事务后,需要用到子线程的处理结果,这个时候就要用到join();方法了。

三、join方法的作用
在网上看到有人说“将两个线程合并”。这样解释我觉得理解起来还更麻烦。不如就借鉴下API里的说法:
“等待该线程终止。”
解释一下,是主线程(我在“一”里已经命名过了)等待子线程的终止。也就是在子线程调用了join()方法后面的代码,只有等到子线程结束了才能执行。(Waits for this thread to die.)

四、用实例来理解
写一个简单的例子来看一下join()的用法,一共三个类:
1.CustomThread 类
2. CustomThread1类
3. JoinTestDemo 类,main方法所在的类。

代码1:

  1. package wxhx.csdn2;      
  2. /**  
  3.  *     
  4.  * @author bzwm    
  5.  *    
  6.  */     
  7. class CustomThread1 extends Thread {      
  8.     public CustomThread1() {      
  9.         super(“[CustomThread1] Thread”);      
  10.     };      
  11.     public void run() {      
  12.         String threadName = Thread.currentThread().getName();      
  13.         System.out.println(threadName + “ start.”);      
  14.         try {      
  15.             for (int i = 0; i < 5; i++) {      
  16.                 System.out.println(threadName + “ loop at ” + i);      
  17.                 Thread.sleep(1000);      
  18.             }      
  19.             System.out.println(threadName + “ end.”);      
  20.         } catch (Exception e) {      
  21.             System.out.println(“Exception from ” + threadName + “.run”);      
  22.         }      
  23.     }      
  24. }      
  25. class CustomThread extends Thread {      
  26.     CustomThread1 t1;      
  27.     public CustomThread(CustomThread1 t1) {      
  28.         super(“[CustomThread] Thread”);      
  29.         this.t1 = t1;      
  30.     }      
  31.     public void run() {      
  32.         String threadName = Thread.currentThread().getName();      
  33.         System.out.println(threadName + “ start.”);      
  34.         try {      
  35.             t1.join();      
  36.             System.out.println(threadName + “ end.”);      
  37.         } catch (Exception e) {      
  38.             System.out.println(“Exception from ” + threadName + “.run”);      
  39.         }      
  40.     }      
  41. }      
  42. public class JoinTestDemo {      
  43.     public static void main(String[] args) {      
  44.         String threadName = Thread.currentThread().getName();      
  45.         System.out.println(threadName + “ start.”);      
  46.         CustomThread1 t1 = new CustomThread1();      
  47.         CustomThread t = new CustomThread(t1);      
  48.         try {      
  49.             t1.start();      
  50.             Thread.sleep(2000);      
  51.             t.start();      
  52.             t.join();//在代碼2里,將此處注釋掉      
  53.         } catch (Exception e) {      
  54.             System.out.println(“Exception from main”);      
  55.         }      
  56.         System.out.println(threadName + “ end!”);      
  57.     }      
  58. }  

打印结果:
main start.//main方法所在的线程起动,但没有马上结束,因为调用t.join();,所以要等到t结束了,此线程才能向下执行。
[CustomThread1] Thread start.//线程CustomThread1起动
[CustomThread1] Thread loop at 0//线程CustomThread1执行
[CustomThread1] Thread loop at 1//线程CustomThread1执行
[CustomThread] Thread start.//线程CustomThread起动,但没有马上结束,因为调用t1.join();,所以要等到t1结束了,此线程才能向下执行。
[CustomThread1] Thread loop at 2//线程CustomThread1继续执行
[CustomThread1] Thread loop at 3//线程CustomThread1继续执行
[CustomThread1] Thread loop at 4//线程CustomThread1继续执行
[CustomThread1] Thread end. //线程CustomThread1结束了
[CustomThread] Thread end.// 线程CustomThread在t1.join();阻塞处起动,向下继续执行的结果
main end!//线程CustomThread结束,此线程在t.join();阻塞处起动,向下继续执行的结果。

修改一下代码,得到代码2:(这里只写出修改的部分)

  1. public class JoinTestDemo {      
  2.     public static void main(String[] args) {      
  3.         String threadName = Thread.currentThread().getName();      
  4.         System.out.println(threadName + “ start.”);      
  5.         CustomThread1 t1 = new CustomThread1();      
  6.         CustomThread t = new CustomThread(t1);      
  7.         try {      
  8.             t1.start();      
  9.             Thread.sleep(2000);      
  10.             t.start();      
  11. //          t.join();//在代碼2里,將此處注釋掉      
  12.         } catch (Exception e) {      
  13.             System.out.println(“Exception from main”);      
  14.         }      
  15.         System.out.println(threadName + “ end!”);      
  16.     }      
  17. }  

打印结果:
main start. // main方法所在的线程起动,但没有马上结束,这里并不是因为join方法,而是因为Thread.sleep(2000);
[CustomThread1] Thread start. //线程CustomThread1起动
[CustomThread1] Thread loop at 0//线程CustomThread1执行
[CustomThread1] Thread loop at 1//线程CustomThread1执行
main end!// Thread.sleep(2000);结束,虽然在线程CustomThread执行了t1.join();,但这并不会影响到其他线程(这里main方法所在的线程)。
[CustomThread] Thread start. //线程CustomThread起动,但没有马上结束,因为调用t1.join();,所以要等到t1结束了,此线程才能向下执行。
[CustomThread1] Thread loop at 2//线程CustomThread1继续执行
[CustomThread1] Thread loop at 3//线程CustomThread1继续执行
[CustomThread1] Thread loop at 4//线程CustomThread1继续执行
[CustomThread1] Thread end. //线程CustomThread1结束了
[CustomThread] Thread end. // 线程CustomThread在t1.join();阻塞处起动,向下继续执行的结果

五、从源码看join()方法

在CustomThread的run方法里,执行了t1.join();,进入看一下它的JDK源码:

  1. public final void join() throws InterruptedException {      
  2.    join(0);      
  3. }  

然后进入join(0)方法:

  1.    /**    
  2.     * Waits at most <code>millis</code> milliseconds for this thread to     
  3.     * die. A timeout of <code>0</code> means to wait forever. //注意这句    
  4.     *    
  5.     * @param      millis   the time to wait in milliseconds.    
  6.     * @exception  InterruptedException if another thread has interrupted    
  7.     *             the current thread.  The <i>interrupted status</i> of the    
  8.     *             current thread is cleared when this exception is thrown.    
  9.     */     
  10.    public final synchronized void join(long millis) //参数millis为0.      
  11.    throws InterruptedException {      
  12.       long base = System.currentTimeMillis();      
  13.       long now = 0;      
  14.       if (millis < 0) {      
  15.           throw new IllegalArgumentException(“timeout value is negative”);      
  16.       }      
  17.       if (millis == 0) {//进入这个分支      
  18.           while (isAlive()) {//判断本线程是否为活动的。这里的本线程就是t1.      
  19.              wait(0);//阻塞      
  20.           }      
  21.        } else {      
  22.           while (isAlive()) {      
  23.              long delay = millis - now;      
  24.              if (delay <= 0) {      
  25.                 break;      
  26.              }      
  27.           wait(delay);      
  28.           now = System.currentTimeMillis() - base;      
  29.        }   
  30.    }      
  31. }   

单纯从代码上看,如果线程被生成了,但还未被起动,调用它的join()方法是没有作用的。将直接继续向下执行,这里就不写代码验证了。

以上原文摘自:http://www.blogjava.net/jnbzwm/articles/330549.html

下面是我在跑程序时遇到的问题,先通过for循环start()了几个线程,然后又for循环邀请了几个线程join(),那么如果join线程起到阻塞主线程作用的话,它是否阻塞for循环呢?如果也阻塞for循环的话,下面的代码就又成为单线程了。。

  1. package JavaTest;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.List;   
  5.   
  6. public class joinTest {   
  7.     public static void main(String[] args) {   
  8.   
  9.         int threadNumber = 10;   
  10.         List<Thread> threadList = new ArrayList<Thread>();   
  11.   
  12.         for (int i = 0; i < threadNumber; i++) {   
  13.             MyRunner tmpRunner = new MyRunner();   
  14.             Thread tmpThread = new Thread(tmpRunner);   
  15.             tmpThread.setName(String.valueOf(i));   
  16.             threadList.add(tmpThread);   
  17.         }   
  18.   
  19.   
  20.         // Class c = r.getClass();   
  21.         for (int i = 0; i < threadNumber; i++) {   
  22.             threadList.get(i).start();   
  23.         }   
  24.            
  25.         for (int i = 0; i < threadNumber; i++) {   
  26.   
  27.             try {   
  28.                 threadList.get(i).join();    
  29.                    
  30.             } catch (InterruptedException e) {   
  31.                 e.printStackTrace();   
  32.             }   
  33.         }   
  34.            
  35.            
  36.         for (int i = 0; i < 5; i++) {   
  37.             System.out.println(“main thread: ” + i);   
  38.         }   
  39.     }   
  40. }   
  41.   
  42. class MyRunner implements Runnable {   
  43.     public void run() {   
  44.         for (int i = 0; i < 10; i++) {   
  45.                
  46.             Class c = this.getClass();   
  47.                
  48.             System.out.println(i + “ Thread:” + Thread.currentThread().getName());   
  49.             try {   
  50.                 Thread.sleep(10*Integer.parseInt(Thread.currentThread().getName()));   
  51.             } catch (InterruptedException e) {   
  52.                 // TODO Auto-generated catch block   
  53.                 e.printStackTrace();   
  54.             }   
  55.         }   
  56.     }   
  57. }  

测试的结果表明join是会阻塞main函数,但是并不阻塞for循环,因而可以通过两个for循环分别start()和join()。并行运行并阻塞main线程往下运行

发表评论

电子邮件地址不会被公开。 必填项已用 * 标注

*

您可以使用这些 HTML 标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>