java并发编程学习:如何等待多个线程执行完成后再继续后续处理(synchronized、join、FutureTask、CyclicBarrier)

多线程应用中,经常会遇到这种场景:后面的处理,依赖前面的N个线程的处理结果,必须等前面的线程执行完毕后,后面的代码才允许执行。

在我不知道CyclicBarrier之前,最容易想到的就是放置一个公用的static变量,假如有10个线程,每个线程处理完上去累加下结果,然后后面用一个死循环(或类似线程阻塞的方法),去数这个结果,达到10个,说明大家都爽完了,可以进行后续的事情了,这个想法虽然土鳖,但是基本上跟语言无关,几乎所有主流编程语言都支持。

package yjmyzz.test;


public class ThreadLockTest {

    public static int flag = 0;//公用变量

    public static void main(String[] args) throws Exception {
        ThreadLockTest testObj = new ThreadLockTest();
        final int threadNum = 10;

        for (int i = 0; i < threadNum; i++) {
            new Thread(new MyRunable(i, testObj)).start();
        }

        while (true) {
            if (testObj.flag >= threadNum) {
                System.out.println("-----------\n所有thread执行完成!");
                break;
            }
            Thread.sleep(10);
        }
    }

    static class MyRunable implements Runnable {
        int _i = 0;
        ThreadLockTest _test;

        public MyRunable(int i, ThreadLockTest test) {
            this._i = i;
            this._test = test;
        }

        @Override
        public void run() {
            try {
                Thread.sleep((long) (Math.random() * 10));
                System.out.println("thread " + _i + " done");
                //利用synchronized获得同步锁
                synchronized (_test) {
                    _test.flag += 1;
                }
                System.out.println("thread " + _i + " => " + _test.flag);//测试用
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

输出结果:

thread 0 done
thread 0 => 1
thread 9 done
thread 9 => 2
thread 1 done
thread 1 => 3
thread 3 done
thread 3 => 4
thread 7 done
thread 7 => 5
thread 6 done
thread 6 => 6
thread 2 done
thread 2 => 7
thread 4 done
thread 4 => 8
thread 8 done
thread 8 => 9
thread 5 done
thread 5 => 10
-----------
所有thread执行完成!

除了这个方法,还可以借助FutureTask,达到类似的效果,其get方法会阻塞线程,等到该异步处理完成。缺点就是,FutureTask调用的是Callable,必须要有返回值,所以就算你不想要返回值,也得返回点啥

package yjmyzz.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask<String>[] tasks = new FutureTask[10];

        for (int i = 0; i < tasks.length; i++) {
            final int j = i;
            tasks[i] = new FutureTask<String>(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    Thread.sleep((long) (Math.random() * 100));
                    return "task" + j + " done";
                }
            });
            new Thread(tasks[i]).start();
        }

        for (int i = 0; i < tasks.length; i++) {
            System.out.println(tasks[i].get());//依次等待所有task执行完毕
        }

        System.out.println("-----------\n所有task执行完成!");

    }
}

执行结果:

task0 done
task1 done
task2 done
task3 done
task4 done
task5 done
task6 done
task7 done
task8 done
task9 done
-----------
所有task执行完成!

此外,Thread的Join方法也可以实现类似的效果,主要代码如下:

    public static void main(String[] args) throws Exception {

        final int threadNum = 10;
        Thread[] threads = new Thread[threadNum];

        for (int i = 0; i < threadNum; i++) {
            threads[i] = new Thread(new MyRunable(i));
            threads[i].start();
        }

        for (int i = 0; i < threadNum; i++) {
            threads[i].join();
        }

        System.out.println("-----------\n所有thread执行完成!");

    }

当然,这个需求最“正统”的解法应该是使用CyclicBarrier,它可以设置一个所谓的“屏障点”(或称集合点),好比在一项团队活动中,每个人都是一个线程,但是规定某一项任务开始前,所有人必须先到达集合点,集合完成后,才能继续后面的任务。  

package yjmyzz.test;

import java.util.concurrent.CyclicBarrier;

public class ThreadTest {

    public static void main(String[] args) throws Exception {

        final int threadNum = 10;
        CyclicBarrier cb = new CyclicBarrier(threadNum + 1);//注意:10个子线程 + 1个主线程

        for (int i = 0; i < threadNum; i++) {
            new Thread(new MyRunable(cb, i)).start();
        }

        cb.await();
        System.out.println("-----------\n所有thread执行完成!");
    }

    static class MyRunable implements Runnable {
        CyclicBarrier _cb;
        int _i = 0;

        public MyRunable(CyclicBarrier cb, int i) {
            this._cb = cb;
            this._i = i;
        }

        @Override
        public void run() {
            try {
                Thread.sleep((long) (Math.random() * 100));
                System.out.println("thread " + _i + " done,正在等候其它线程完成...");
                _cb.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

thread 9 done,正在等候其它线程完成... thread 5 done,正在等候其它线程完成... thread 0 done,正在等候其它线程完成... thread 6 done,正在等候其它线程完成... thread 4 done,正在等候其它线程完成... thread 2 done,正在等候其它线程完成... thread 3 done,正在等候其它线程完成... thread 8 done,正在等候其它线程完成... thread 7 done,正在等候其它线程完成... thread 1 done,正在等候其它线程完成... ----------- 所有thread执行完成!

参考文章:

http://ifeve.com/concurrency-cyclicbarrier/

http://ifeve.com/thread-synchronization-utilities-5/

http://ifeve.com/semaphore-countdownlatch-cyclicbarrier-phaser-exchanger-in-java/ 

http://ifeve.com/thread-management-7/

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏屈定‘s Blog

设计模式--组合模式的思考

组合模式是一种抽象树形结构的模式,其在业务开发中也是一种很有用的设计模式,下面开始分析.

43930
来自专栏MasiMaro 的技术博文

COM学习(一)——COM基础思想

学习微软技术COM是绕不开的一道坎,最近做项目的时候发现有许多功能需要用到COM中的内容,虽然只是简单的使用COM中封装好的内容,但是许多代码仍然只知其然,不知...

18330
来自专栏IT派

程序员们,再不升级 Java 10 就晚了!

正如我们大家都知道的,Java 的最新版本已经来到了10。本文将重点介绍当前正在开发的一些有趣的 Java 新功能。

12620
来自专栏Crossin的编程教室

【Python 第23课】 if, elif, else

今天补充之前讲过的一个语句:if。为什么我跳要着讲,因为我的想法是先讲下最最基本的概念,让你能用起来,之后你熟悉了,再说些细节。 关于if,可以发送数字『7』回...

29360
来自专栏java学习

java每日一练(2017/8/20)

最新通知 ●回复"每日一练"获取以前的题目! ●【新】Android视频更新了!(回复【安卓视频】获取下载链接) ●【新】Ajax知识点视频更新了!(回复【学习...

32560
来自专栏程序员互动联盟

【编程入门】C语言堆栈入门——堆和栈的区别

在计算机领域,堆栈是一个不容忽视的概念,我们编写的C语言程序基本上都要用到。但对于很多的初学着来说,堆栈是一个很模糊的概念。堆栈:一种数据结构、一个在程序运行时...

53260
来自专栏木可大大

编写优雅代码的最佳实践

Robert Martin曾说过"在代码阅读中说脏话的频率是衡量代码质量额唯一标准"。同时,代码的写法应当使别人理解它所需的时间最小化,也就是说我们写的代码是给...

464200
来自专栏为数不多的Android技巧

一种绕过Android P对非SDK接口限制的简单方法

众所周知,Android P 引入了针对非 SDK 接口(俗称为隐藏API)的使用限制。这是继 Android N上针对 NDK 中私有库的链接限制之后的又一次...

72230
来自专栏C/C++基础

Effective C++ 条款08:别让异常逃离析构函数

《Effective C++》第三版中条款08建议不要在析构函数中抛出异常,原因是C++异常机制不能同时处理两个或两个以上的异常。多个异常同时存在的情况下,程序...

11540
来自专栏锦小年的博客

python学习笔记1-理解Python语言

本章主要介绍一下python语言的相关知识,包括其语言类型、作为面向对象的3大特性以及5大原则,在末尾介绍了其优缺点。 python是解释型的脚本语言 解...

22090

扫码关注云+社区

领取腾讯云代金券