并发编程系列之线程join方法使用方法简介

Love The Way You Lie 2021-08-13 15:10 301阅读 0赞

本博客简介介绍一下java线程的join方法，join方法是实现线程同步，可以将原本并行执行的多线程方法变成串行执行的

如图所示代码，是并行执行的

public class ThreadTest {
        //private static final Long count = 10000L;
        public static void main(String[] args){
            long base = System.currentTimeMillis();
            try {
                ThreadJoin t1 = new ThreadJoin("线程1");
                ThreadJoin t2 = new ThreadJoin("线程2");
                t1.start();
                t2.start();
    
            } catch (Exception e) {
                e.printStackTrace();
            }
            long time = System.currentTimeMillis() - base;
            System.out.println("执行时间："+time);
        }
        
    }
    class ThreadJoin extends Thread{
        private static final Long count = 10L;
    
        public ThreadJoin(String name){
            super(name);
        }
    
        @Override
        public void run() {
            //super.run();
            for(int i = 1; i <= count; i ++){
                System.out.println(this.getName()+":"+i);
            }
        }
    }

打印出来的信息，都是这样的

执行时间：0
    线程1:1
    线程2:1
    线程2:2
    线程2:3
    线程2:4
    线程2:5
    线程2:6
    线程2:7
    线程2:8
    线程2:9
    线程2:10
    线程1:2
    线程1:3
    线程1:4
    线程1:5
    线程1:6
    线程1:7
    线程1:8
    线程1:9
    线程1:10

要实现串行执行，可以加上join方法，实现线程1执行完成后才开始执行线程2，也就是串行执行

public class ThreadTest {
        //private static final Long count = 10000L;
        public static void main(String[] args){
            long base = System.currentTimeMillis();
            try {
                ThreadJoin t1 = new ThreadJoin("线程1");
                ThreadJoin t2 = new ThreadJoin("线程2");
                t1.start();
                t1.join();
                t2.start();
    
            } catch (Exception e) {
                e.printStackTrace();
            }
            long time = System.currentTimeMillis() - base;
            System.out.println("执行时间："+time);
        }
        
    }
    class ThreadJoin extends Thread{
        private static final Long count = 10L;
    
        public ThreadJoin(String name){
            super(name);
        }
    
        @Override
        public void run() {
            //super.run();
            for(int i = 1; i <= count; i ++){
                System.out.println(this.getName()+":"+i);
            }
        }
    }

线程1:1
    线程1:2
    线程1:3
    线程1:4
    线程1:5
    线程1:6
    线程1:7
    线程1:8
    线程1:9
    线程1:10
    执行时间：0
    线程2:1
    线程2:2
    线程2:3
    线程2:4
    线程2:5
    线程2:6
    线程2:7
    线程2:8
    线程2:9
    线程2:10

从执行结果看，已经是串行执行线程

所以上面的例子是调了现场1的join方法，也就是说要先执行完成线程1，然后才执行main主线程

join方法的作用是，举个例子，在A线程里调B线程的join方法时，要先B线程执行完成，然后才会继续执行A线程

ok，上面调join方法是不加参数的，也可以加上参数，比如线程`A.join(10)；`，就是说线程A执行10s后，继续执行B线程

注意：join时间参数缺省的情况，默认是0，也就是说join()等同于join(0);

/**
         * Waits for this thread to die.
         *
         * <p> An invocation of this method behaves in exactly the same
         * way as the invocation
         *
         * <blockquote>
         * {@linkplain #join(long) join}{@code (0)}
         * </blockquote>
         *
         * @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.
         */
        public final void join() throws InterruptedException {
            join(0);
        }

Thread类里的源码，可以看出默认赋值为0，然后这个0是什么意思？0不是表示执行0s，而是表示要A线程执行完成才继续执行B线程的意思

ok，然后为什么调用了join方法就可以实现线程同步？我们简单看一下代码：

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");
            }
    		//执行时间为0或者缺省情况
            if (millis == 0) {
                while (isAlive()) {//表示线程还没执行好
                    wait(0);//调用线程的wait方法
                }
            } else {//执行时间大于0的情况
                while (isAlive()) {
                    long delay = millis - now;//循环计算延期时间
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);//同样调用线程的wait方法
                    now = System.currentTimeMillis() - base;
                }
            }
        }

ok，看了一下源码，还是比较容易理解的，其实就是调用了现场wait方法实现线程同步的