欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java并发实例之CyclicBarrier的使用

程序员文章站 2023-12-19 08:27:34
最近一直整并发这块东西,顺便写点java并发的例子,给大家做个分享,也强化下自己记忆,如果有什么错误或者不当的地方,欢迎大家斧正。 cyclicbarrier是一种多线程...

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

cyclicbarrier是一种多线程并发控制实用工具,和countdownlatch非常类似,它也可以实现线程间的计数等待,但是它的功能比countdownlatch更加复杂且强大。

cyclicbarrier的介绍

cyclicbarrier 的字面意思是可循环(cyclic)使用的屏障(barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活。线程进入屏障通过cyclicbarrier的await()方法。

cyclicbarrier默认的构造方法是cyclicbarrier(int parties),其参数表示屏障拦截的线程数量,每个线程调用await方法告诉cyclicbarrier我已经到达了屏障,然后当前线程被阻塞。

cyclicbarrier还提供一个更高级的构造函数cyclicbarrier(int parties, runnable barrieraction),用于在线程到达屏障时,优先执行barrieraction这个runnable对象,方便处理更复杂的业务场景。

public cyclicbarrier(int parties) {
  this(parties, null);
}
public int getparties() {
  return parties;
}

实现原理:在cyclicbarrier的内部定义了一个lock对象,每当一个线程调用cyclicbarrier的await方法时,将剩余拦截的线程数减1,然后判断剩余拦截数是否为0,如果不是,进入lock对象的条件队列等待。如果是,执行barrieraction对象的runnable方法,然后将锁的条件队列中的所有线程放入锁等待队列中,这些线程会依次的获取锁、释放锁,接着先从await方法返回,再从cyclicbarrier的await方法中返回。

cyclicbarrier主要用于一组线程之间的相互等待,而countdownlatch一般用于一组线程等待另一组些线程。实际上可以通过countdownlatch的countdown()和await()来实现cyclicbarrier的功能。即 countdownlatch中的countdown()+await() = cyclicbarrier中的await()。注意:在一个线程中先调用countdown(),然后调用await()。

构造函数cyclicbarrier可以理解为循环栅栏,这个计数器可以反复使用。比如,假设我们将计数器设置为10,那么凑齐第一批10个线程后,计数器就会归零,然后接着凑齐下一批10个线程,这就是它的内在含义。

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和使用countdownlatch是没什么区别的,正如前文所说的cyclicbarrier的功能更加的复杂且强大。给大家看一个《实战java高并发程序设计》一书上的一个例子。

比如:司令下达命令,要求10个士兵去一起完成一项任务。这时,就会要求10个士兵先集合报道,接着,一起雄赳赳气昂昂地去执行任务。当10个士兵都执行完了任务,那么司机就可以对外宣称,任务完成。相比countdownlatch,cyclicbarrier可以接受一个参数作为barrieraction。所谓的barrieraction就是当计数器一次计数完成后,系统会执行的动作。如下构造函数,其中,parties表示技术总数,也就是参与的线程总数。

public cyclicbarrier(int parties, runnable barrieraction)

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

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

执行结果如下:

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

总结

以上就是本文关于java并发实例之cyclicbarrier的使用的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站:

javaweb应用使用限流处理大量的并发请求详解

java并发学习之blockingqueue实现生产者消费者详解

java系统的高并发解决方法详解

如有不足之处,欢迎留言指出。期待您的宝贵意见!

上一篇:

下一篇: