CyclicBarrier的使用之王者荣耀打大龙

最近一直整并发这块东西，顺便写点Java并发的例子，给大家做个分享，也强化下自己记忆，如果有什么错误或者不当的地方，欢迎大家斧正。

LOL和王者荣耀的玩家很多，许多人应该都有打大龙的经历，话说前期大家打算一起去偷大龙，由于前期大家都比较弱，需要五个人都齐了才能打大龙，这样程序该如何实现呢？本人很菜，开始我的代码是这么写的（哈哈大家不要纠结我的时间）：

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
打大龙...

　　这完了，大家在路上的时间就花了40s了，显然是错误的。要是都这么干，对方把你塔都要偷光了。不行得改进下，怎么改呢，多线程并发执行，如是我改成了下面这样的，用volatile关键字。

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();
    }

　　结果如下：

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

　　结果似乎还不错，但是处理起来实在是有点麻烦，需要 while (i!=0)一直在那循环着。这时候学到了用 CyclicBarrier来处理，代码如下:

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();
    }

　　大家都没到达之前都等待，结果如下：

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

　　CyclicBarrier相当于线程的计数器：

CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。
CyclicBarrier就象它名字的意思一样，可看成是个障碍，所有的线程必须到齐后才能一起通过这个障碍。
CyclicBarrier初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

巴特西

CyclicBarrier的使用之王者荣耀打大龙

最新文章

热门文章