CyclicBarrier的运用

CyclicBarrier相当于线程的计数器:

集合队伍!
士兵0报道!
士兵1报道!
士兵2报道!
士兵3报道!
士兵4报道!
士兵5报道!
士兵6报道!
士兵7报道!
士兵8报道!
士兵9报道!
司令:[士兵10个,集合完毕!
士兵0:任务完成
士兵2:任务完成
士兵9:任务完成
士兵3:任务完成
士兵7:任务完成
士兵8:任务完成
士兵1:任务完成
士兵4:任务完成
士兵5:任务完成
士兵6:任务完成
司令:[士兵10个,任务完成!

结果如尚对,但是处理起来其实是起硌麻烦,需要 while
(i!=0)一直当那么循环着。这时候学到了所以 CyclicBarrier来处理,代码如下:

结果如下:

public class KillDragon {
    /**
     * 模拟打野去打大龙
     */
   public static void dayePlayDragon(){
       System.out.println("打野在去打大龙的路上,需要10s");
   }

    /**
     * 模拟上单去打大龙
     */
    public static void shangdanPlayDragon(){
        System.out.println("上单在去打大龙的路上,需要10s");
    }

    /**
     * 模拟中单去打大龙
     */
    public static void zhongdanPlayDragon(){
        System.out.println("中单在去打大龙的路上,需要10s");
    }

    /**
     * 模拟ADC和辅助去打大龙
     */
    public static void adcAndFuzhuPlayDragon(){
        System.out.println("ADC和辅助在去打大龙的路上,需要10s");
    }

    /**
     * 模拟大家一起去打大龙
     */
    public static void killDragon()
    {
        System.out.println("打大龙...");
    }

    public static void main(String[] args)
    {
        dayePlayDragon();
        shangdanPlayDragon();
        zhongdanPlayDragon();
        adcAndFuzhuPlayDragon();
        killDragon();
    }
打野在去打大龙的路上,需要10s
上单在去打大龙的路上,需要10s
中单在去打大龙的路上,需要10s
ADC和辅助在去打大龙的路上,需要10s
打大龙...
总共耗时:10002毫秒

 这收了,大家在中途的岁月尽管花了40s了,显然是错的。要是都这样干,对方将你塔还如盗取光了。不行得更上一层楼下,怎么改呢,多线程并发执行,如是自己改变化了脚这样的,用volatile关键字。

打野在去打大龙的路上,需要10s
上单在去打大龙的路上,需要10s
中单在去打大龙的路上,需要10s
ADC和辅助在去打大龙的路上,需要10s
打大龙...
总共耗时:10005毫秒

LOL和天皇荣耀的玩家多,许多人数应该还来自大龙的阅历,话说前期大家打算一起去偷大龙,由于早期大家都于弱,需要五个人口还共同了才能够起大龙,这样程序该如何兑现呢?本人挺菜,开始我之代码是这般形容的(哈哈大家不用纠结自己的时空):

近期直整并作这块东西,顺便写点Java并发的事例,给大家做个享受,也深化下自己记,如果生什么错或不当之地方,欢迎大家斧正。

集合队伍!
士兵0报道!
士兵1报道!
士兵2报道!
士兵3报道!
士兵4报道!
士兵5报道!
士兵6报道!
士兵7报道!
士兵8报道!
士兵9报道!
司令:[士兵10个,集合完毕!
士兵0:任务完成
士兵2:任务完成
士兵9:任务完成
士兵3:任务完成
士兵7:任务完成
士兵8:任务完成
士兵1:任务完成
士兵4:任务完成
士兵5:任务完成
士兵6:任务完成
司令:[士兵10个,任务完成!

结果如尚不易,但是处理起来其实是来硌麻烦,需要 while
(i!=0)一直在那么循环着。这时候学到了用 CyclicBarrier来处理,代码如下:

public CyclicBarrier(int parties, Runnable barrierAction)

CyclicBarrier相当于线程的计数器:

打野在去打大龙的路上,需要10s
上单在去打大龙的路上,需要10s
中单在去打大龙的路上,需要10s
ADC和辅助在去打大龙的路上,需要10s
打大龙...
总共耗时:10002毫秒

 这收了,大家以途中的工夫虽花费了40s了,显然是错的。要是都如此干,对方把你塔都使盗取光了。不行得更上一层楼下,怎么改呢,多线程并发执行,如是本身改变成为了底这样的,用volatile关键字。

打野在去打大龙的路上,需要10s
上单在去打大龙的路上,需要10s
中单在去打大龙的路上,需要10s
ADC和辅助在去打大龙的路上,需要10s
打大龙...
总共耗时:10005毫秒
public class CyclicBarrierDemo {
    public static class Soldier implements Runnable {
        private String soldier;
        private final CyclicBarrier cyclicBarrier;

        public Soldier(CyclicBarrier cyclicBarrier, String soldier) {
            this.soldier = soldier;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                cyclicBarrier.await();
                doWork();
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }

        }

        void doWork() {
            try {
                Thread.sleep(Math.abs(new Random().nextInt() % 10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(soldier + ":任务完成");
        }
    }

    public static class BarrierRun implements Runnable {

        boolean flag;
        int N;

        public BarrierRun(boolean flag, int N) {
            this.flag = flag;
            this.N = N;
        }

        @Override
        public void run() {
            if (flag) {
                System.out.println("司令:[士兵" + N + "个,任务完成!");
            } else {
                System.out.println("司令:[士兵" + N + "个,集合完毕!");
                flag = true;
            }
        }
    }

    public static void main(String args[]) {
        final int N = 10;
        Thread[] allSoldier = new Thread[N];
        boolean flag = false;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(N, new BarrierRun(flag, N));
        System.out.println("集合队伍!");
        for (int i = 0; i < N; i++) {
            System.out.println("士兵" + i + "报道!");
            allSoldier[i] = new Thread(new Soldier(cyclicBarrier, "士兵" + i));
            allSoldier[i].start();
        }
    }
}

CyclicBarrier初始化时规定一个数码,然后计算调用了CyclicBarrier.await()进入等的线程数。当线程数达到了此数目时,所有上等状态的线程被提拔并连续。
CyclicBarrier就象它名字的意同样,可看成是只障碍,
所有的线程必须到一道后才同经过者阻力。
CyclicBarrier初始时还而带来一个Runnable的参数,
此Runnable任务在CyclicBarrier的数据及后,所有其他线程被提拔前被实施。
理所当然如此以CyclicBarrier和应用CountDownLatch是没什么区别的,正使前方和所说的CyclicBarrier的机能进一步的扑朔迷离且强大。给大家看一个《实战Java高并发程序设计》一题及之一个例。
依:司令下达命令,要求10个战士去同形成同样码职责。这时,就会要求10只兵士先汇报道,接着,一起雄赳赳气昂昂地失去实施任务。当10个兵卒都推行了了任务,那么司机不怕好对外声称,任务成功。相比CountDownLatch,CyclicBarrier可以承受一个参数作为BarrierAction。所谓的BarrierAction就是当计数器一不行计数完成后,系统会履的动作。如下构造函数,其中,parties表示技术总数,也就是是插足的线程总数。

打野在去打大龙的路上,需要10s
上单在去打大龙的路上,需要10s
中单在去打大龙的路上,需要10s
ADC和辅助在去打大龙的路上,需要10s
打大龙...

下面示例演示了上述任务场景

脚示例演示了上述任务场景

结果如下:

大家都并未到之前还等候,结果如下:

打野在去打大龙的路上,需要10s
上单在去打大龙的路上,需要10s
中单在去打大龙的路上,需要10s
ADC和辅助在去打大龙的路上,需要10s
打大龙...
public CyclicBarrier(int parties, Runnable barrierAction)
public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(5);
        new Thread(new Runnable() {
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                killDragon();
                long t = System.currentTimeMillis() - start;
                System.out.println("总共耗时:"+t+"毫秒");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                dayePlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                shangdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                zhongdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                adcAndFuzhuPlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

LOL和国王荣耀的玩家多,许多总人口相应都有从大龙的经验,话说前期大家打算一起错过偷大龙,由于前期大家还比弱,需要五单人都同了才会起大龙,这样程序该怎么实现为?本人好菜,开始自之代码是这样写的(哈哈大家不要纠结我之辰):

public class CyclicBarrierDemo {
    public static class Soldier implements Runnable {
        private String soldier;
        private final CyclicBarrier cyclicBarrier;

        public Soldier(CyclicBarrier cyclicBarrier, String soldier) {
            this.soldier = soldier;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                cyclicBarrier.await();
                doWork();
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }

        }

        void doWork() {
            try {
                Thread.sleep(Math.abs(new Random().nextInt() % 10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(soldier + ":任务完成");
        }
    }

    public static class BarrierRun implements Runnable {

        boolean flag;
        int N;

        public BarrierRun(boolean flag, int N) {
            this.flag = flag;
            this.N = N;
        }

        @Override
        public void run() {
            if (flag) {
                System.out.println("司令:[士兵" + N + "个,任务完成!");
            } else {
                System.out.println("司令:[士兵" + N + "个,集合完毕!");
                flag = true;
            }
        }
    }

    public static void main(String args[]) {
        final int N = 10;
        Thread[] allSoldier = new Thread[N];
        boolean flag = false;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(N, new BarrierRun(flag, N));
        System.out.println("集合队伍!");
        for (int i = 0; i < N; i++) {
            System.out.println("士兵" + i + "报道!");
            allSoldier[i] = new Thread(new Soldier(cyclicBarrier, "士兵" + i));
            allSoldier[i].start();
        }
    }
}
private static volatile int i = 4;
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                while (i!=0){

                }
                while (i==0) {
                    killDragon();
                    i--;
                    long t = System.currentTimeMillis() - start;
                    System.out.println("总共耗时:"+t+"毫秒");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                dayePlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                shangdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                zhongdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                adcAndFuzhuPlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

CyclicBarrier是一样种植多线程并发控制实用工具,和CountDownLatch非常接近,它吗足以实现线程间的计数等待,但是她的效应比CountDownLatch更加错综复杂且强大。CyclicBarrier可以掌握为循环栅栏,这个计数器可以数使用。比如,假要我们以计数器设置也10,那么聚集一起第一批判10独线程后,计数器就会由零,然后就汇一起下一样批判10单线程,这便是她的内在含义。

CyclicBarrier是一致种多线程并发控制实用工具,和CountDownLatch非常类似,它吗可兑现线程间的计数等待,但是它的成效比CountDownLatch更加错综复杂且强大。CyclicBarrier可以掌握为循环栅栏,这个计数器可以屡屡用。比如,假而我们以计数器设置为10,那么聚集一起第一批10只线程后,计数器就见面由零,然后就汇一起下一样批10单线程,这即是它的内在含义。

近期直整并作这块东西,顺便写点Java并发的例子,给大家做个享受,也加剧下自己记,如果起啊错或不当的地方,欢迎大家斧正。

public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(5);
        new Thread(new Runnable() {
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                killDragon();
                long t = System.currentTimeMillis() - start;
                System.out.println("总共耗时:"+t+"毫秒");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                dayePlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                shangdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                zhongdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                adcAndFuzhuPlayDragon();
                try {
                    Thread.sleep(10000);
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
private static volatile int i = 4;
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                while (i!=0){

                }
                while (i==0) {
                    killDragon();
                    i--;
                    long t = System.currentTimeMillis() - start;
                    System.out.println("总共耗时:"+t+"毫秒");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                dayePlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                shangdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                zhongdanPlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                adcAndFuzhuPlayDragon();
                try {
                    Thread.sleep(10000);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

CyclicBarrier初始化时规定一个数据,然后计算调用了CyclicBarrier.await()进入等的线程数。当线程数达了此数额时,所有进入等状态的线程被提示并持续。
CyclicBarrier就象它名字的意同样,可用作是独障碍,
所有的线程必须顶一起后才能一起通过之阻力。
CyclicBarrier初始时还只是带动一个Runnable的参数,
此Runnable任务在CyclicBarrier的数额达到后,所有其他线程被提示前于执行。
当如此用CyclicBarrier和下CountDownLatch是没什么区别之,正而前文所说的CyclicBarrier的法力更是的错综复杂且强大。给大家看一个《实战Java高并发程序设计》一书写上的一个例证。
依:司令下达命令,要求10只战士去一起就同样起职责。这时,就见面要求10个兵士先汇报道,接着,一起雄赳赳气昂昂地失去履行任务。当10只兵卒还尽完毕了职责,那么司机便足以对外声明,任务到位。相比CountDownLatch,CyclicBarrier可以领一个参数作为BarrierAction。所谓的BarrierAction就是当计数器一坏计数完成后,系统会尽之动作。如下构造函数,其中,parties表示技术总数,也便是参与的线程总数。

结果如下:

结果如下:

行结果如下:

实行结果如下:

世家还不曾到达之前还待,结果如下:

public class KillDragon {
    /**
     * 模拟打野去打大龙
     */
   public static void dayePlayDragon(){
       System.out.println("打野在去打大龙的路上,需要10s");
   }

    /**
     * 模拟上单去打大龙
     */
    public static void shangdanPlayDragon(){
        System.out.println("上单在去打大龙的路上,需要10s");
    }

    /**
     * 模拟中单去打大龙
     */
    public static void zhongdanPlayDragon(){
        System.out.println("中单在去打大龙的路上,需要10s");
    }

    /**
     * 模拟ADC和辅助去打大龙
     */
    public static void adcAndFuzhuPlayDragon(){
        System.out.println("ADC和辅助在去打大龙的路上,需要10s");
    }

    /**
     * 模拟大家一起去打大龙
     */
    public static void killDragon()
    {
        System.out.println("打大龙...");
    }

    public static void main(String[] args)
    {
        dayePlayDragon();
        shangdanPlayDragon();
        zhongdanPlayDragon();
        adcAndFuzhuPlayDragon();
        killDragon();
    }

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website