Java线程:新特征-障碍器

障碍器是多线程并发控制的一种手段,用法很简单。下面给个例子:

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* Java线程:新特征-障碍器
*
* @author leizhimin 
*/
public class Test {
         public static void main(String[] args) {
                 //创建障碍器,并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable)
                 CyclicBarrier cb = new CyclicBarrier(7, new MainTask());
                 new SubTask("A", cb).start();
                 new SubTask("B", cb).start();
                 new SubTask("C", cb).start();
                 new SubTask("D", cb).start();
                 new SubTask("E", cb).start();
                 new SubTask("F", cb).start();
                 new SubTask("G", cb).start();
         }
}
/**
* 主任务
*/
class MainTask implements Runnable {
         public void run() {
                 System.out.println(">>>>主任务执行了!<<<<");
         }
}
/**
* 子任务
*/
class SubTask extends Thread {
         private String name;
         private CyclicBarrier cb;
         SubTask(String name, CyclicBarrier cb) {
                 this.name = name;
                 this.cb = cb;
         }
         public void run() {
                 System.out.println("[子任务" + name + "]开始执行了!");
                 for (int i = 0; i < 999999; i++) ;    //模拟耗时的任务
                 System.out.println("[子任务" + name + "]开始执行完成了,并通知障碍器已经完成!");
                 try {
                         //通知障碍器已经完成
                         cb.await();
                 } catch (InterruptedException e) {
                         e.printStackTrace();
                 } catch (BrokenBarrierException e) {
                         e.printStackTrace();
                 }
         }
}

运行结果:

[子任务E]开始执行了!
[子任务E]开始执行完成了,并通知障碍器已经完成!
[子任务F]开始执行了!
[子任务G]开始执行了!
[子任务F]开始执行完成了,并通知障碍器已经完成!
[子任务G]开始执行完成了,并通知障碍器已经完成!
[子任务C]开始执行了!
[子任务B]开始执行了!
[子任务C]开始执行完成了,并通知障碍器已经完成!
[子任务D]开始执行了!
[子任务A]开始执行了!
[子任务D]开始执行完成了,并通知障碍器已经完成!
[子任务B]开始执行完成了,并通知障碍器已经完成!
[子任务A]开始执行完成了,并通知障碍器已经完成!
>>>>主任务执行了!<<<<
Process finished with exit code 0

从执行结果可以看出,所有子任务完成的时候,主任务执行了,达到了控制的目标。

出处:http://lavasoft.blog.51cto.com/62575/222738

时间: 2024-10-03 17:57:52

Java线程:新特征-障碍器的相关文章

Java线程系列

Java线程:线程私有变量 Java线程:深入ThreadLocal Java线程:线程的调度-休眠 Java线程:线程的调度-优先级 Java线程:线程的调度-让步 Java线程:线程的调度-合并 Java线程:线程的调度-守护线程 Java线程:线程的同步-同步方法 Java线程:线程的同步-同步块 Java线程:并发协作-生产者消费者模型 Java线程:并发协作-死锁 Java线程:volatile关键字 Java线程:新特征-线程池 Java线程:新特征-有返回值的线程 Java线程:新

Java线程:新特征-线程池

有关Java5线程新特征的内容全部在java.util.concurrent下面,里面包含数目众多的接口和类,熟悉这部分API特征是一项艰难的学习过程.目前有关这方面的资料和书籍都少之又少,大所属介绍线程方面书籍还停留在java5之前的知识层面上. 当然新特征对做多线程程序没有必须的关系,在java5之前通用可以写出很优秀的多线程程序.只是代价不一样而已. 线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理.当有线程任务时,从

Java线程:新特征-阻塞队列

阻塞队列是Java5线程新特征中的内容,Java定义了阻塞队列的接口 java.util.concurrent.BlockingQueue,阻塞队列的概念是,一个指定长度的队列,如果队列满了,添加新元素的操作会被阻塞等待,直到有空位为止.同样,当队列为空时候,请求队列元素的操作同样会阻塞等待,直到有可用元素为止. 有了这样的功能,就为多线程的排队等候的模型实现开辟了便捷通道,非常有用. java.util.concurrent.BlockingQueue继承了java.util.Queue接口,

Java线程池

Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利.为了编写高效稳定可靠的多线程程序,线程部分的新增内容显得尤为重要. 有关Java5线程新特征的内容全部在java.util.concurrent下面,里面包含数目众多的接口和类,熟悉这部分API特征是一项艰难的学习过程.目前有关这方面的资料和书籍都少之又少,大所属介绍线程方面书籍还停留在java5之前的知识层面上. 当然新特征对做

Java 8 新特性

这篇文章是一篇介绍Java8新特性英文博客的中文翻译,Java8发布有些时日,但是大家对它的了解和认识还不够,大部分企业和用户还停留在之前的版本中,本次翻译主要针对对Java8感兴趣和致力于从事Java开发的人员提供有价值的中文资料,希望能够对大家的工作和学习有所帮助.Java8的中文资料相对匮乏,这是我看过介绍Java8新特性最好的一篇文章,作者通过实例和理论相结合的方式,通俗易懂的阐述了Java8的一些新特性,今天让小村长为你揭开Java8的神秘面纱,一同走进码农的精神世界.注释 : 由于本

Java线程:新特征-信号量

因此,本人认为,这个信号量类如果能返回数目,还能知道哪些对象在等待,哪些资源可使用,就非常完美了,仅仅拿到这些概括性的数字,对精确控制意义不是很大.目前还没想到更好的用法. 下面是一个简单例子: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; /** * Java线程:新特征-信号量 * * @aut

Java线程:新特征-阻塞栈

对于阻塞栈,与阻塞队列相似.不同点在于栈是"后入先出"的结构,每次操作的是栈顶,而队列是"先进先出"的结构,每次操作的是队列头. 这里要特别说明一点的是,阻塞栈是Java6的新特征.. Java为阻塞栈定义了接口:java.util.concurrent.BlockingDeque,其实现类也比较多,具体可以查看JavaAPI文档. 下面看一个简单例子: import java.util.concurrent.BlockingDeque; import java.u

Java线程:新特征-原子量

所谓的原子量即操作变量的操作是"原子的",该操作不可再分,因此是线程安全的. 为何要使用原子变量呢,原因是多个线程对单个变量操作也会引起一些问题.在Java5之前,可以通过volatile.synchronized关键字来解决并发访问的安全问题,但这样太麻烦. Java5之后,专门提供了用来进行单变量多线程并发安全访问的工具包java.util.concurrent.atomic,其中的类也很简单. 下面给出一个反面例子(切勿模仿): import java.util.concurre

Java线程:新特征-有返回值的线程

在Java5之前,线程是没有返回值的,常常为了"有"返回值,破费周折,而且代码很不好写.或者干脆绕过这道坎,走别的路了. 现在Java终于有可返回值的任务(也可以叫做线程)了. 可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口. 执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了. 下面是个很简单的例子: import java.util.concurrent.*