CyclicBarrier实例一

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest2 {
    static CyclicBarrier c = new CyclicBarrier(2, new A());

    public static void main(String[] args) {
        //另外的子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + ",19");
                    System.out.println(1);
                    c.await();
                } catch (Exception e) {
                }

            }
        }).start();

        //main线程
        try {
            System.out.println(Thread.currentThread().getName() + ",28");
            System.out.println(2);
            c.await();
        } catch (Exception e) {
        }

    }

    //所有线程都到达时，最后一个到达的线程触发Runnable运行
    static class A implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + ",run");
            System.out.println(3);
        }
    }
}

输出：

main,28
2
Thread-0,19
1
Thread-0,run
3

实例二：

CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。例如，用一个Excel保
存了用户所有银行流水，每个Sheet保存一个账户近一年的每笔银行流水，现在需要统计用户
的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日
均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流
水。

import java.util.Map.Entry;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
 * 银行流水处理服务类
 *
 * @authorftf
 */
public class BankWaterService implements Runnable {
    /**
     * 创建4个屏障，处理完之后执行当前类的run方法
     */
    private CyclicBarrier c = new CyclicBarrier(4, this);
    /**
     * 假设只有4个sheet，所以只启动4个线程
     */
    private Executor executor = Executors.newFixedThreadPool(4);
    /**
     * 保存每个sheet计算出的银流结果
     */
    private ConcurrentHashMap<String, Integer> sheetBankWaterCount = new
            ConcurrentHashMap<String, Integer>();

    private void count() {
        for (int i = 0; i < 4; i++) {

/*            executor.execute(new Runnable() {
                @Override
                public void run() {
                    //计算当前sheet的银流数据，计算代码省略
                    sheetBankWaterCount
                            .put(Thread.currentThread().getName(), 1);
                    System.out.println(Thread.currentThread().getName() + ",count");
                    //银流计算完成，插入一个屏障
                    try {
                        c.await();
                    } catch (InterruptedException |
                            BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });*/

            //与上面的run同义，使用了lambda
            executor.execute(() -> {
                //计算当前sheet的银流数据，计算代码省略
                sheetBankWaterCount
                        .put(Thread.currentThread().getName(), 1);
                System.out.println(Thread.currentThread().getName() + ",count");
                //银流计算完成，插入一个屏障
                try {
                    c.await();
                } catch (InterruptedException |
                        BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    //所有线程都到达时，最后一个到达的线程触发Runnable运行
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ",run");
        int result = 0;
        //汇总每个sheet计算出的结果
        for (Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()) {
            result += sheet.getValue();
        }
        //将结果输出
        sheetBankWaterCount.put("result", result);
        System.out.println(result);
    }

    public static void main(String[] args) {
        BankWaterService bankWaterCount = new BankWaterService();
        bankWaterCount.count();
    }
}

输出：

pool-1-thread-2,count
pool-1-thread-4,count
pool-1-thread-3,count
pool-1-thread-1,count
pool-1-thread-1,run
4

扫描二维码关注公众号，回复： 3808524 查看本文章

CyclicBarrier和CountDownLatch区别

猜你喜欢