java线程join方法实例剖析

待我称王封你为后i 2022-09-23 08:22 151阅读 0赞

http://www.journaldev.com/1024/java-thread-join-example

Java Thread join():本函数用来使线程暂停，转让控制权，这里的暂停指的是暂停当前，转让给x.join(),x

方便的理解记忆：join();----老衲加入了！！！！老衲现在最大，或者老衲在规定的时间最大！！我有控制权。

[![java thread join, thread join example, java thread join example, thread join][java thread join_ thread join example_ java thread join example_ thread join]][java thread join_ thread join example_ java thread join example_ thread join]

**public final void join():** 这个java线程连接方法使得当前线程处于等待过程，知道线程死亡。如果线程被中断,它抛出Interrupted Exception。

**public final synchronized void join(long millis): **这个java线程连接方法用于使得线程等待指定的时间，单位毫秒。由于线程执行取决于操作系统实现,它并不能保证当前线程将执行等待的时间。

public final synchronized void join(long millis, int nanos):这个java线程连接方法用于使得线程等待更加准确地时间：给定毫秒+纳秒。

下面一个简单的例子来说明线程连接方法。项目的目标是确保主是最后一个线程，第三个线程只有线程1死亡才执行。

package com.journaldev.threads;
    
    public class ThreadJoinExample {
    
        public static void main(String[] args) {
            Thread t1 = new Thread(new MyRunnable(), "t1");
            Thread t2 = new Thread(new MyRunnable(), "t2");
            Thread t3 = new Thread(new MyRunnable(), "t3");
            
            t1.start();
            
            //start second thread after waiting for 2 seconds or if it's dead
            try {
                t1.join(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            t2.start();
            
            //start third thread only when first thread is dead
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            t3.start();
            
            //let all threads finish execution before finishing main thread
            try {
                t1.join();
                t2.join();
                t3.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            System.out.println("All threads are dead, exiting main thread");
        }
    
    }
    
    class MyRunnable implements Runnable{
    
        @Override
        public void run() {
            System.out.println("Thread started:::"+Thread.currentThread().getName());
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread ended:::"+Thread.currentThread().getName());
        }
        
    }

**结果：**

Thread started:::t1//t1.join(2000);t1线程获得控制权力，时间2S;----所以t1start----- Thread.sleep(4000);----超过时间交出控制权

Thread started:::t2//------回到主线程----t2 start ----------执行t1.join()-----t1加入，重获新生！！！！-----回到run()继续执行-----输出t1 end----死亡----返回主线程  
Thread ended:::t1  
Thread started:::t3//此刻 t3.start();  
Thread ended:::t2// \-----t1,t2，t3---依次join()------t1已经亡，轮到t2-----t2继续上次执行，run()---t2 end-----  
Thread ended:::t3// \-同理t3------交给main----main end  
All threads are dead, exiting main thread

*（断点运行，有助于理解）*

2.延伸：

即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

bt.join();//意思：bt加入了，此刻转让控制权，必须等待bt对象线程执行完毕才能继续向下！！！！

class BThread extends Thread {
        public BThread() {
            super("[BThread] Thread");
        };
        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " start.");
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println(threadName + " loop at " + i);
                    Thread.sleep(1000);
                }
                System.out.println(threadName + " end.");
            } catch (Exception e) {
                System.out.println("Exception from " + threadName + ".run");
            }
        }
    }
    class AThread extends Thread {
        BThread bt;
        public AThread(BThread bt) {
            super("[AThread] Thread");
            this.bt = bt;
        }
        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " start.");
            try {
                bt.join();
                System.out.println(threadName + " end.");
            } catch (Exception e) {
                System.out.println("Exception from " + threadName + ".run");
            }
        }
    }
    public class TestDemo {
        public static void main(String[] args) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " start.");
            BThread bt = new BThread();
            AThread at = new AThread(bt);
            try {
                bt.start();
                Thread.sleep(2000);
                at.start();
                at.join();
            } catch (Exception e) {
                System.out.println("Exception from main");
            }
            System.out.println(threadName + " end!");
        }
    }

可能的结果：

main start.    //主线程起动，因为调用了at.join()，要等到at结束了，此线程才能向下执行。 
    [BThread] Thread start. 
    [BThread] Thread loop at 0 
    [BThread] Thread loop at 1 
    [AThread] Thread start.    //线程at启动，因为调用bt.join()，等到bt结束了才向下执行。 
    [BThread] Thread loop at 2 
    [BThread] Thread loop at 3 
    [BThread] Thread loop at 4 
    [BThread] Thread end. 
    [AThread] Thread end.    // 线程AThread在bt.join();阻塞处起动，向下继续执行的结果 
    main end!      //线程AThread结束，此线程在at.join();阻塞处起动，向下继续执行的结果。

或者：（系统决定时间片分配）

main start.  
\[BThread\] Thread start.  
\[BThread\] Thread loop at 0  
\[BThread\] Thread loop at 1  
\[BThread\] Thread loop at 2  
\[AThread\] Thread start.  
\[BThread\] Thread loop at 3  
\[BThread\] Thread loop at 4  
\[BThread\] Thread end.  
\[AThread\] Thread end.  
main end!

更改代码：

public class TestDemo {
        public static void main(String[] args) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " start.");
            BThread bt = new BThread();
            AThread at = new AThread(bt);
            try {
                bt.start();
                Thread.sleep(2000);//此处thread是main线程
                at.start();
                //at.join(); //在此处注释掉对join()的调用
            } catch (Exception e) {
                System.out.println("Exception from main");
            }
            System.out.println(threadName + " end!");
        }
    }

结果：

main start.    // 主线程起动，因为Thread.sleep(2000)，主线程没有马上结束;
    
    [BThread] Thread start.    //线程BThread起动
    [BThread] Thread loop at 0
    [BThread] Thread loop at 1
    main end!   // 在sleep两秒后主线程结束，AThread执行的bt.join();并不会影响到主线程。
    [AThread] Thread start.    //线程at起动，因为调用了bt.join()，等到bt结束了，此线程才向下执行。
    [BThread] Thread loop at 2
    [BThread] Thread loop at 3
    [BThread] Thread loop at 4
    [BThread] Thread end.    //线程BThread结束了
    [AThread] Thread end.    // 线程AThread在bt.join();阻塞处起动，向下继续执行的结果

[java thread join_ thread join example_ java thread join example_ thread join]: /images/20220721/3e684ded52874430b5e3d5a472dbd90c.png