介绍几种等待多线程任务执行完毕的方法

最新推荐文章于 2024-05-11 01:35:16 发布

原创最新推荐文章于 2024-05-11 01:35:16 发布 · 4k 阅读

7 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

16 篇文章

订阅专栏

本文深入探讨了四种关键的并发控制方法：join(), CountDownLatch, CyclicBarrier及自定义计数器，详细介绍了每种方法的工作原理及其在多线程场景中的应用。

一.引言：

在我们日常的开发过程中，我们经常会开启多个线程或者创建一个线程池去执行多个并发任务，当所有任务执行完毕后，我们一般会做一个统一的处理。那我们如何知道多个线程的任务已经全部执行完毕了呢？
今天由我来为大家介绍几种方法：

二.join()方法

在这里插入图片描述

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (i<10000){
                    i++;
                }
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (k<10000){
                    k++;
                }
            }
        });
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("i的值"+i);
        System.out.println("k的值"+k);

运行程序控制台打印i和k的值都是1万，可以得出结论，线程1，线程2都执行完毕了。

分析总结：执行join方法的线程的所在线程，一直在等待执行join方法的线程完成。如果A在B线程中执行了join()方法，那么B线程就会等待A线程执行结束。（通过while循环判断join的线程是否存活。）

三.CountDownLatch类

代码实现在上述代码的基础上创建一个CountDownLatch对象：
在这里插入图片描述

       Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (i<10000){
                    i++;
                }
                mCountDownLatch.countDown();
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (k<10000){
                    k++;
                }
                mCountDownLatch.countDown();
            }
        });
        thread2.start();

        try {
            mCountDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("i的值"+i);
        System.out.println("k的值"+k);

运行程序，控制台打印结果和上面一样。

分析总结:CountDownLatch内部维持一个计数操作，通过CAS算法,保证操作的原子性。
countDown()会将当前计数-1（通过Unsafe类下compareAndSwapInt方法）；
await()方法表示当前线程挂起，一直等待这个计数到0。

四.CyclicBarrier类

代码如下：
在这里插入图片描述

在这里插入图片描述

   mCyclicBarrier = new CyclicBarrier(2, mRunnable);
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (i<10000){
                    i++;
                }
                try {
                    mCyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (k<10000){
                    k++;
                }
                try {
                    mCyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        thread2.start();

执行我们应用程序，打印结果和上述结果一致。

分析总结：
CyclicBarrier可以理解为一个屏障。
子线程通过调用它的await方法来告诉CyclicBarrier，线程到达屏障。当指定数量的线程
达到屏障后，在执行线程后面的方法。打个比方我们去车站坐车，所有人到达之后，车才会发动。
上诉代码我们通过CyclicBarrier的构造方法，指定等待2个线程到达屏障后(例如我们的车要等待多少人到齐之后才能发动)在执行后续的操作，并且指定之后都到达之后先执行什么操作（一个Runnable对象，例如我们车发动的操作）。

四.自定义个一个计数器

代码如下：
在这里插入图片描述

在这里插入图片描述

  Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (i<10000){
                    i++;
                }
                atomicInteger.incrementAndGet();
                justIsOver();
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (k<10000){
                    k++;
                }
                atomicInteger.incrementAndGet();
                justIsOver();
            }
        });
        thread2.start();

执行我们的应用程序，控制台打印结果如上所示：

分析总结：
通过java提供的原子类AtomicInteger创建一个对象，用来计数。每个线程执行完毕时
调用incrementAndGet把内部的一个计数+1，当它内部的值为2时，就代表我们的两个线程都执行完毕了。

好了,今天我们就介绍这四种方法，还有其他方法，思想大差不差，要么设置一个同步点，要么就设置一个计数器。如果对你提供了帮助，别忘了点个赞再走哦。

转载标明原文地址哦：https://blog.youkuaiyun.com/braintt/article/details/88381193