Thread线程类基本使用(下)

package thread;
 
public class Demo6 {
 
 public static void main(String[] args) {
         serial();
        concurrency();
    }
    // 1. 单个线程, 串行的, 完成 20 亿次自增.
    // 2. 两个线程, 并发的, 完成 20 亿次自增.
    private static final long COUNT = 20_0000_0000;
 
    private static void serial() {
        // 需要把方法执行的时间给记录下来.
        // 记录当前的毫秒级时间戳.
        long beg = System.currentTimeMillis();
 
        int a = 0;
        for (long i = 0; i < COUNT; i++) {
            a++;
        }
        a = 0;
        for (long i = 0; i < COUNT; i++) {
            a++;
        }
 
        long end = System.currentTimeMillis();
        System.out.println("单线程消耗的时间: " + (end - beg) + " ms");
    }
 
    private static void concurrency() {
        long beg = System.currentTimeMillis();
 
        Thread t1 = new Thread(() -> {
            int a = 0;
            for (long i = 0; i < COUNT; i++) {
                a++;
            }
        });
 
        Thread t2 = new Thread(() -> {
            int a = 0;
            for (long i = 0; i < COUNT; i++) {
                a++;
            }
        });
 
        t1.start();
        t2.start();
 
        try {
 //通过调用join方法让主线程等待t1和t1线程都结束
//先后调用顺序没事
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        long end = System.currentTimeMillis();
        System.out.println("并发执行的时间: " + (end - beg) + " ms");
    }
 
   
}

 首先，通过上述结果可知对于同一任务，多线程的确有减少时间的作用，观察代码，我们为什么要在多线程处理的方法里加入t1.join()和t2.join呢？原因是因为线程之间是"并发执行的",所以说主线程main在往下执行的过程中，线程t1和t2都在执行，所以为了防止t1和t2还没结束，主线程就已经向下执行到获取当前时间的函数那里从而导致测量时间不准的尴尬场景，我们通过让主线程调用join(),让我们的主线程在t1和t2线程结束之前进入阻塞状态，然后再测量此时的时间就是准确的,拿那这两句代码具体含义是什么呢？首先线程t1，t2哪个先结束我们是不知道的，那第一种情况t1先结束，那执行到t1.join时也就对应t1.join结束，随后执行t2.join对主线程产生阻塞，最后计算的时间就是t2.join完成后的时间，反之则相反。

实例2

通过join方法实现新线程t2等待t1，mian主线程等待新线程t2

package Boke;
 
public class join {
    public static void main(String[] args) {
        System.out.println("主线程main，begin");
        Thread t1=new Thread(()->{
            System.out.println("线程t1,begin");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程t1,end");
        });
        t1.start();
 
 
        Thread t2=new Thread(()->{
            System.out.println("线程t2,begin");
            try {
                //让t2等待t1结束，就在线程t2中调用t1.join
                t1.join();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程t2,end");
        });
        t2.start();
        // //让主线程等待t2结束，就在主线程中调用t2.join
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程main,end");
    }
}