五、 新类库中的构件

Java SE5的java.util.concurrent引入了大量设计用来解决并发问题的新类。学习使用它们将有助于编写出更加简单而强壮的并发程序。

1. CountDownLatch

他被用来同步一个或多个任务,强制他们等待由其他任务执行的一组操作完成。

你可以向CountDownLatch对象设置一个初始计数值,任何在这个对象上调用wait()方法都将阻塞,直至这个计数值到达0。其他任务在结束其工作时,可以在该对象上盗用countDown()来减小这个计数值。CountDownLatch被设计为只触发一次,计数值不能被重置。如果你需要能够重置计数值的版本,则可以使用CyclicBarrier。

调用countDown()的任务在产生这个调用时并没有被阻塞,只有对await()的调用会被阻塞,直至计数值到达0。

CountDownLatch的典型用法是将一个程序氛围n个相互独立的可解决任务,并创建值为0的CountDownLatch。当每个任务完成时,都会在这个锁存器上调用countDown()。等待问题呗解决的任务在这个锁存器上调用await(),将他们自己拦住,直至锁存器计数结束。下面是演示这种技术的一个框架示例:

public class CountDownLatchDemo {
static final int SIZE = 100; public static void main(String[] args) throws Exception {
ExecutorService exec = Executors.newCachedThreadPool();
CountDownLatch latch = new CountDownLatch(SIZE);
for (int i = 0; i < 10; i++) {
exec.execute(new WaitingTask(latch));
} for (int i = 0; i < SIZE; i++) {
exec.execute(new TaskPortion(latch));
} System.out.println("Launched all tasks");
exec.shutdown();
}
} class TaskPortion implements Runnable {
private static int counter = 0;
private final int id = counter++;
private static Random rand = new Random(47);
private final CountDownLatch latch; TaskPortion(CountDownLatch latch) {
this.latch = latch;
} public void run() {
try {
doWork();
latch.countDown();
} catch (InterruptedException e) {
//Acceptable way to exit
}
} public void doWork() throws InterruptedException {
TimeUnit.MILLISECONDS.sleep(rand.nextInt(2000));
System.out.println(this + "completed");
} public String toString() {
return String.format("%1$-3d", id);
}
} class WaitingTask implements Runnable {
private static int counter = 0;
private final int id = counter++;
private final CountDownLatch latch; WaitingTask(CountDownLatch latch) {
this.latch = latch;
} public void run() {
try {
latch.await();
System.out.println("Latch barrier passed for " + this);
} catch (InterruptedException e) {
System.out.println(this + " interrupted");
}
} public String toString() {
return String.format("WaitingTask %1$-3d", id);
}
}

TaskPortion将随机的休眠一段时间,以模拟这部分工作的完成,而WaitingTask表示系统中必须等待的部分,它要等待到问题的初始部分完成为止。所有任务都使用了在main()中定义的同一个单一的CountDownLatch。

2. CyclicBarrier

CyclicBarrier适用于这样的情况,你希望创建一组任务,他们并行的执行任务,然后在进行下一个步骤前等待,直至所有任务都完成(看起来有些像join())。它使得所有的并行任务都在栅栏处列队,因此可以一致的向前移动。这非常像CountDownLatch,只是CountDownLatch是只触发一次的事件,而CyclicBarrier可以多次重用。

public class HorseRace {
static final int FINISH_LINE = 75;
private List<Horse> horses = new ArrayList<Horse>();
private ExecutorService exec = Executors.newCachedThreadPool();
private CyclicBarrier barrier; public HorseRace(int nHorses, final int pause) {
barrier = new CyclicBarrier(nHorses, () -> {
StringBuilder s = new StringBuilder();
for (int i = 0; i < FINISH_LINE; i++) {
s.append("=");
}
System.out.println(s);
for (Horse horse : horses) {
System.out.println(horse.tracks());
}
for (Horse horse : horses) {
if (horse.getStrides() >= FINISH_LINE) {
System.out.println(horse + " won!");
exec.shutdownNow();
return;
}
}
try {
TimeUnit.MILLISECONDS.sleep(pause);
} catch (InterruptedException e) {
System.out.println("barrier-action sleep interrupted");
}
});
for (int i = 0; i < nHorses; i++) {
Horse horse = new Horse(barrier);
horses.add(horse);
exec.execute(horse);
}
} public static void main(String[] args) {
int nHorses = 7;
int pause = 200;
if (args.length > 0) {
int n = new Integer(args[0]);
nHorses = n > 0 ? n : nHorses;
}
if (args.length > 1) {
int p = new Integer(args[1]);
pause = p > -1 ? p : pause;
}
new HorseRace(nHorses, pause);
}
} class Horse implements Runnable {
private static int counter = 0;
private final int id = counter++;
private int strides = 0;
private static Random rand = new Random(47);
private static CyclicBarrier barrier; public Horse(CyclicBarrier barrier) {
this.barrier = barrier;
} public synchronized int getStrides() {
return strides;
} public void run() {
try {
while (!Thread.interrupted()) {
synchronized (this) {
strides += rand.nextInt(3);
}
barrier.await();
}
} catch (InterruptedException e) {
//a legitimate way to exit
} catch (BrokenBarrierException e) {
//This one we want to know about
throw new RuntimeException(e);
}
} public String toString() {
return "Horse " + id + " ";
} public String tracks() {
StringBuilder s = new StringBuilder();
for (int i = 0; i < getStrides(); i++) {
s.append("*");
}
s.append(id);
return s.toString();
}
}

可以向CyclicBarrier提供一个“栅栏动作”,他是一个Runnable,当计数值到达0时自动执行--这是CyclicBarrier和CountDownLatch之间的另一个区别。这里,栅栏动作是作为匿名内部类创建的,他被提交给了CyclicBarrier的构造器。

3. DelayQueue

这是一个无界的BlockingQueue,用于放置实现了Delayed接口的对象,其中的对象只能在其到期时才能从队列中取走。这种队列是有序的,即队头对象的延迟到期的时间最长。如果没有任何延迟到期,那么就不会y任何头元素,并且poll()将返回null(正因为这样,你不能将null放置到这种队列中)。

4. Semaphore

正常的锁在任何时刻都只允许yi'ge'ren'wu一个任务访问一项资源,而计数信号量允许n个任务同时访问这个资源。你还可以将信号量看作是在向外分发使用资源的“许可证”,尽管实际上没有使用任何许可证对象。

作为一个示例,请考虑对象池的概念,他管理着数量有限的对象,当要使用对象时可以签出他们,而在用户使用完毕时,可以将他们签回。这种功能可以被封装到一个泛型类中:

public class Pool<T> {
private int size;
private List<T> items = new ArrayList<T>();
private volatile boolean[] checkedOut;
private Semaphore available; public Pool(Class<T> classObject, int size) {
this.size = size;
checkedOut = new boolean[size];
available = new Semaphore(size, true);
for (int i = 0; i < size; i++) {
try {
items.add(classObject.newInstance());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
} public T checkOut() throws InterruptedException {
available.acquire();
return getItem();
} public void checkIn(T x) {
if (releaseItem(x)) {
available.release();
}
} private synchronized T getItem() {
for (int i = 0; i < size; i++) {
if (!checkedOut[i]) {
checkedOut[i] = true;
return items.get(i);
}
}
return null;
} private synchronized boolean releaseItem(T item) {
int index = items.indexOf(item);
if (index == -1) {
return false;
}
if (checkedOut[index]) {
checkedOut[index] = false;
return true;
}
return false;
}
}

在这个简化的形式中,构造器使用newInstance()来把对象加载到池中。如果你需要一个新对象,那么可以调用checkOut(),并且在使用完之后,将其递交给checkIn()。

为了创建一个示例,我们可以使用Fat,这是一种创建代价高昂的对象类型,因为他的构造器运行起来很耗时:

public class Fat {
private volatile double d;
private static int counter = 0; public Fat() {
for (int i = 1; i < 10000; i++) {
d += (Math.PI + Math.E) / (double) i;
}
} public void operation() {
System.out.println(this);
} public String toString() {
return "Fat id: " + d;
}
}

我们在池中管理这些对象,以限制这个构造器所造成的影响。我们可以创建一个任务,它将签出Fat对象,持有一段时间后再将他们签入,以此来测试Pool这个类:

public class SemaphoreDemo {
final static int SIZE = 25; public static void main(String[] args) throws Exception {
final Pool<Fat> pool = new Pool<>(Fat.class, SIZE);
ExecutorService exec = Executors.newCachedThreadPool();
for (int i = 0; i < SIZE; i++) {
exec.execute(new CheckoutTask<Fat>(pool));
}
System.out.println("All CheckoutTasks created");
List<Fat> list = new ArrayList<>();
for (int i = 0; i < SIZE; i++) {
Fat f = pool.checkOut();
System.out.println(i + ": main() thread checked out");
f.operation();
list.add(f);
} Future<?> blocked = exec.submit(new Runnable() {
public void run() {
try {
pool.checkOut();
} catch (InterruptedException e) {
System.out.println("checkout() interrupted");
}
}
});
TimeUnit.SECONDS.sleep(2);
blocked.cancel(true);
System.out.println("Checking in objects in " + list);
for (Fat f : list) {
pool.checkIn(f);
}
for (Fat f : list) {
pool.checkIn(f);
}
exec.shutdown();
}
} class CheckoutTask<T> implements Runnable {
private static int counter = 0;
private final int id = counter++;
private Pool<T> pool; public CheckoutTask(Pool<T> pool) {
this.pool = pool;
} public void run() {
try {
T item = pool.checkOut();
System.out.println(this + " checked out " + item);
TimeUnit.SECONDS.sleep(1);
System.out.println(this + " checked in " + item);
pool.checkIn(item);
} catch (InterruptedException e) {
//Acceptable way to terminate
}
} public String toString() {
return "CheckoutTask " + id + " ";
}
}

在main()中,创建了一个持有Fat对象的Pool,而一组CheckoutTask则开始操练这个Pool。然后,main()线程签出池中的Fat对象,但是并不签入他们。一旦池中所有的对象都被签出,Semaphore将不再允许执行任何签出操作。blocked的run()方法因此会被阻塞,2秒之后,cancel()方法被调用,以此来挣脱Future的束缚。注意,冗余的qian'ru签入将被Pool忽略。

java编程思想-java中的并发(四)的更多相关文章

  1. Java编程思想 第21章 并发

    这是在2013年的笔记整理.现在重新拿出来,放在网上,重新总结下. 两种基本的线程实现方式 以及中断 package thread; /** * * @author zjf * @create_tim ...

  2. 33.JAVA编程思想——JAVA IO File类

    33.JAVA编程思想--JAVA IO File类 RandomAccessFile用于包括了已知长度记录的文件.以便我们能用 seek()从一条记录移至还有一条:然后读取或改动那些记录. 各记录的 ...

  3. 《Java编程思想》读书笔记(四)

    前言:三年之前就买了<Java编程思想>这本书,但是到现在为止都还没有好好看过这本书,这次希望能够坚持通读完整本书并整理好自己的读书笔记,上一篇文章是记录的第十七章到第十八章的内容,这一次 ...

  4. java编程思想-java中的并发(二)

    二.共享受限资源 有了并发就可以同时做多件事情了.但是,两个或多个线程彼此互相干涉的问题也就出现了.如果不防范这种冲突,就可能发生两个线程同时试图访问同一个银行账户,或向同一个打印机打印,改变同一个值 ...

  5. java编程思想-java中的并发(一)

    一.基本的线程机制 并发编程使我们可以将程序划分为多个分离的.独立运行的任务.通过使用多线程机制,这些独立任务中的每一个都将由执行线程来驱动. 线程模型为编程带来了便利,它简化了在单一程序中同时jia ...

  6. Java编程思想学习(十六) 并发编程

    线程是进程中一个任务控制流序列,由于进程的创建和销毁需要销毁大量的资源,而多个线程之间可以共享进程数据,因此多线程是并发编程的基础. 多核心CPU可以真正实现多个任务并行执行,单核心CPU程序其实不是 ...

  7. java编程思想-java中的并发(三)

    三.终结任务 1. 在阻塞时终结 线程状态 一个线程可以处于以下四种状态之一: 1)新建(new):当线程被创建时,他只会短暂的处于这种状态.此时,他已经分配了必须的系统资源,并执行了初始化.此刻线程 ...

  8. Java编程思想——第21章 并发

    前言 对于某些问题,如果能够并行的执行程序中的多个部分,则回变得非常方便甚至必要,这些部分要么看起来是并发执行,要么是在多处理环境下同时执行.并行编辑可以使程序执行速度得到极大提高,或者为设计某些类型 ...

  9. Java编程思想学习笔记_6(并发)

    一.从任务中产生返回值,Callable接口的使用 Callable是一种具有泛型类型参数的泛型,它的类型参数表示的是从方法call返回的值,而且必须使Executor.submit来去调用它.sub ...

随机推荐

  1. 硬件升级win8.1重新安装系统

    上次重装系统一年后升级了硬件配置,双11后,再次折腾系统. 配置硬件的选择 部分配件已经升级过了,之前的一直是AMD平台,发热大功耗高,08年我配的AMD 8450+映泰GX790 128M待机在10 ...

  2. Servicestack IRequestLogger获取 IHttpRequest

    我在 ServiceStack里实现了 Logging 中的请求与返回,同时我想在IRequestLogger.Log() 方法中获取 IHttpRequest . IRequestContext 并 ...

  3. [BZOJ 1260][CQOI2007]染色(DP)

    题目:http://www.lydsy.com:808/JudgeOnline/problem.php?id=1260 分析: f[i][j]表示i~j刷成s[i]~s[j]这个样子需要的最小次数 则 ...

  4. Hibernate Synchronizer3——一个和hibernate Tool类似的小插件之使用方法

    首先,要告诉大家的是,当我们要自动生成Mapping File的时候,我们除了使用hibernae tools之外,还可以通过一个更为简洁的插件,只需通过点击: 1.Hibernate Configu ...

  5. Android 全屏显示的方法(不包含状态栏)

    我们都知道在Android中某些功能的实现往往有两种方法:一种是在xml文件中设置相应属性,另一种是用代码实现.同样Android实现全屏显示也可以通过这两种方法实现: 1.在AndroidManif ...

  6. 使用D3制作图表(1)--画布绘制

    使用D3绘制图表可以使数据更加直观. 使用D3前要先加载D3库,这里有两种方式,一种是在线加载<script type="text/javascript" src=" ...

  7. 给Linux装图形化界面

    在工作中遇到这种情况,安装confluence服务的时候需要调用图形化桌面,但是原来装系统的时候是最小化装的,所以这里就麻烦了 给装图形化吧 在我们安装Linux系统时,刚开始的时候可能没有安装图形界 ...

  8. Notes on 'Selective Search For Object Recognition'

    UijlingsIJCV2013, Selective Search For Object Recognition code 算法思想 利用分割算法将图片细分成很多region, 或超像素. 在这个基 ...

  9. MyEclipse去除网上复制下来的来代码带有的行号

    作为开发人员,我们经常从网上复制一些代码,有些时候复制的代码前面是带有行号,如: MyEclipse本身自带有查找替换功能,并且支持正则表达式替换,使用正则替换就可以很容易去除这些行号 使用快捷键“c ...

  10. windows下为mysql添加日志

    mysql的配置文件 [mysqld] …… log-error="D:/phpStudy/log/mysql/mysql_log_err.txt" log="D:/ph ...