join(),CountDownLatch,CyclicBarrier和线程池的整理

最新推荐文章于 2023-03-03 14:24:21 发布

yk_record

最新推荐文章于 2023-03-03 14:24:21 发布

阅读量355

点赞数

分类专栏： java相关文章标签： java多线程

本文链接：https://blog.csdn.net/m0_37536626/article/details/80924500

版权

java相关专栏收录该内容

6 篇文章 0 订阅

订阅专栏

此次主要整理线程执行顺序的相关实现方法，包括join(),CountDownLatch,CyclicBarrier和线程池。

一. join（）

join() 是 Thread 类的一个方法，join() 方法的作用是等待当前线程结束，也即让“主线程”等待“子线程”结束之后才能继续运行。t.join() 方法阻塞调用此方法的线程 (calling thread)，直到线程 t完成，此线程再继续（看起来和同步调用类似）；通常用于在 main 主线程内，等待其它线程完成后再继续执行 main 主线程。

join 实现

Join 方法实现是通过 wait（Object 提供的方法）。看源代码知会进入 (isAlive()) 循环；即只要子线程是活的，主线程就不停的等待。

示例及代码

用 join 方式实现问题如下，在代码中 main 线程被阻塞直到 thread1，thread2，thread3 执行完，主线程才会顺序的执行thread4，即boss先要等3个worker工作结束才check工作

public class JoinPractice {

   static class Worker implements Runnable {

        private String name;

        public Worker(String name){
            this.name = name;
        }

        @Override
        public void run(){
            System.out.println(name + " is working");

        }
    }

    static class Boss implements Runnable{

        private String name;

        public Boss(String name){
            this.name = name;
        }

        @Override
        public void run(){
            System.out.println("boss checks work");
        }
    }

    public static void main(String[] args){

        Worker worker1 = new Worker("worker1");
        Worker worker2 = new Worker("worker2");
        Worker worker3 = new Worker("worker3");
        Boss boss = new Boss("boss");

        Thread thread1 = new Thread(worker1);
        Thread thread2 = new Thread(worker2);
        Thread thread3 = new Thread(worker3);
        Thread thread4 = new Thread(boss);

        thread1.start();
        thread2.start();
        thread3.start();

        try {
            thread1.join();
            thread2.join();
            thread3.join();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        thread4.start();
    }

}

运行结果

worker2 is working
worker1 is working
worker3 is working
boss checks work

二. CountDownLatch

Java 的 util.concurrent 包里面的 CountDownLatch 其实可以把它看作一个计数器（倒计时锁），只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。你可以向 CountDownLatch 对象设置一个初始的数字作为计数值，任何调用这个对象上的 await() 方法都会阻塞，直到这个计数器的计数值被其他的线程减为 0 为止。

使用场景

CountDownLatch 的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个 CountDownLatch 对象的 await() 方法，其他的任务执行完自己的任务后调用同一个CountDownLatch 对象上的 countDown() 方法，这个调用 await() 方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到 0 为止。

示例及代码

举个例子，有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。所以在这里用 Java 代码设计两个类，Worker 代表工人，Boss 代表老板，代码使用了内部类实现。

public class OrderThreadExecute {

    class Worker implements Runnable {
        private CountDownLatch downLatch;
        private String name;

        public Worker(CountDownLatch downLatch, String name) {
            this.downLatch = downLatch;
            this.name = name;
        }

        @Override
        public void run() {
            this.doWork();
            try {
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));
            } catch (InterruptedException ie) {
            }
            System.out.println(this.name + "活干完了！");
            this.downLatch.countDown();
        }

        private void doWork() {
            System.out.println(this.name + "正在干活...");
        }

    }

    class Boss implements Runnable {
        private CountDownLatch downLatch;

        public Boss(CountDownLatch downLatch) {
            this.downLatch = downLatch;
        }

        @Override
        public void run() {
            System.out.println("老板正在等所有的工人干完活......");
            try {
                this.downLatch.await();
            } catch (InterruptedException e) {
            }
            System.out.println("工人活都干完了，老板开始检查了！");
        }

    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        CountDownLatch latch = new CountDownLatch(3);

        OrderThreadExecute orderThread = new OrderThreadExecute();

        Worker w1 = orderThread.new Worker(latch, "张三");
        Worker w2 = orderThread.new Worker(latch, "李四");
        Worker w3 = orderThread.new Worker(latch, "王二");

        Boss boss = orderThread.new Boss(latch);

        executor.execute(boss);
        executor.execute(w3);
        executor.execute(w2);
        executor.execute(w1);

        executor.shutdown();

    }

}

运行结果

老板正在等所有的工人干完活......
王二正在干活...
李四正在干活...
张三正在干活...
李四活干完了！
王二活干完了！
张三活干完了！
工人活都干完了，老板开始检查了！

三. CyclicBarrier

CyclicBarrier 的字面意思是CountDownLatch 的作用是允许1或N个线程等待其他线程完成执行；而 CyclicBarrier 则是允许N个线程相互等待。 CountDownLatch 的计数器无法被重置；CyclicBarrier 的计数器可以被重置后使用，因此它被称为是循环的 barrier。循环（Cyclic）使用的屏障（Barrier），又叫同步屏障。它可以让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。线程到达屏障的控制通过CyclicBarrier 的 await() 方法实现。

CyclicBarrier 的构造方法有 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用 await 方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier 还提供一个构造函数 CyclicBarrier(int parties, Runnable barrierAction) ，用于在线程都到达屏障时，优先执行barrierAction 这个 Runnable 对象，然后都到达屏障的线程继续执行。

实现原理

在 CyclicBarrier 的内部定义了一个 ReentrantLock 对象，每当一个线程调用 CyclicBarrier 的 await 方法时，将剩余拦截的线程数减1，然后判断剩余拦截数是否为0，如果不是，进入 Lock 对象的条件队列等待。如果是则执行 barrierAction 对象的 run 方法，然后将锁的条件队列中的所有线程放入锁等待队列中，这些线程会依次的获取锁、释放锁，接着先从 await 方法返回，再从 CyclicBarrier 的 await 方法中返回。

CyclicBarrier 和 CountDownLatch 比较

CountDownLatch 的作用是允许1或N个线程等待其他线程完成执行；而 CyclicBarrier 则是允许N个线程相互等待。
CountDownLatch 的计数器无法被重置；CyclicBarrier 的计数器可以被重置后使用，因此它被称为是循环的 barrier。

示例及代码

public class CyclicBarrierPractice {

    static class Worker implements Runnable{

        private String name;
        private CyclicBarrier cyclicBarrier;

        public Worker(String name, CyclicBarrier cyclicBarrier){
            this.name = name;
            this.cyclicBarrier = cyclicBarrier;
        }

        public void run(){
            System.out.println(name + " is working");
            try {
                Thread.sleep(2000);

                //到达屏障出（同步点）
                cyclicBarrier.await();

                //线程都到了后继续向下执行,也可以不要下面代码,什么都不做了
                System.out.println(name + " do other things");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    static class Boss implements Runnable{

        private String name;

        public Boss(String name){
            this.name = name;
        }

        public void run(){
            System.out.println(name + " checks work");

        }
    }

    public static void main(String[] args){

        //其他线程都达到屏障后,再执行 boss 线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Boss("boss"));

        for(int i=0; i<3; i++){
            new Thread(new Worker("worker"+i, cyclicBarrier)).start();
        }
    }
}

运行结果

worker0 is working
worker1 is working
worker2 is working
boss checks work
worker2 do other things
worker0 do other things
worker1 do other things

四. 线程池

当线程池的线程全部执行完毕后再执行主线程。

示例及代码

public class ExecuteOrderPractice {

    public void orderPractice(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for(int i = 0; i < 5; i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try{
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + " do something");
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
        }

        executorService.shutdown();

        while(true){
            if(executorService.isTerminated()){
                System.out.println("Finally do something ");
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        new ExecuteOrderPractice().orderPractice();

    }
}

运行结果

pool-1-thread-1 do something
pool-1-thread-3 do something
pool-1-thread-2 do something
pool-1-thread-3 do something
pool-1-thread-1 do something
Finally do something

参考博客地址:https://blog.csdn.net/revitalizing/article/details/61008956

yk_record

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
join(),CountDownLatch,CyclicBarrier和线程池的整理

此次主要整理线程执行顺序的相关实现方法，包括join(),CountDownLatch,CyclicBarrier和线程池。一. join（）join() 是 Thread 类的一个方法，join() 方法的作用是等待当前线程结束，也即让“主线程”等待“子线程”结束之后才能继续运行。t.join() 方法阻塞调用此方法的线程 (calling thread)，直到线程 t完成，此线程再继续（看起来...
复制链接

扫一扫