cyclicbarrier java_Java并发编程之CyclicBarrier和线程池的使用

原标题：Java并发编程之CyclicBarrier和线程池的使用

下面我们来讲述一下线程池和CyclicBarrier的使用和对比。

一、场景描述

有四个游戏玩爱好者玩游戏，游戏中有三个关卡，每一个关卡必须让所有玩家到达后才能允许通过。其实这个场景里的玩家中如果有玩家B先到了第一个关卡，他必须要等到其他剩余玩家都到达第一个关卡时才能通过，这也说明了线程之间需要相互等待。这和CountDownLatch的应用场景有区别，CountDownLatch里的线程是到了运行的目标后继续干自己的事情，而不需要管其他玩家，而这里的线程就不同了，必须等待其他玩家。

二、CyclicBarrier介绍

CyclicBarrier 的字面意思是可循环使用(Cyclic)的屏障(Barrier)。它要做的事情是，让一组线程到达一个屏障(也可以叫同步点)时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier类有两个常用的构造方法：

1. CyclicBarrier(int parties)

这里的parties也是一个计数器，例如，初始化时parties里的计数是3，于是拥有该CyclicBarrier对象的线程当parties的计数为3时就唤醒，注：这里parties里的计数在运行时当调用CyclicBarrier:await()时,计数就加1，一直加到初始的值

2. CyclicBarrier(int parties, Runnable barrierAction)

这里的parties与上一个构造方法的解释是一样的，这里需要解释的是第二个入参(Runnable barrierAction),这个参数是一个实现Runnable接口的类的对象，也就是说当parties加到初始值时就出发barrierAction的内容。

代码示例 package com.itmyhome;import java.util.concurrent.BrokenBarrierException;import java.util.concurrent.CyclicBarrier;/**

输出结果: 玩家0正在玩第一关...玩家3正在玩第一关...玩家2正在玩第一关...玩家1正在玩第一关...所有玩家进入第二关！

CyclicBarrier和CountDownLatch的区别

CountDownLatch: 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。

CyclicBarrier: N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。

CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。

CountDownLatch：减计数方式，CyclicBarrier：加计数方式

三、线程池使用

在上例中，用到了线程池，采用了Executors提供的静态方法初始化线程池。

ExecutorService executorService = Executors.newCachedThreadPool();

newCachedThreadPool()方法实现如下，即初始线程池没有创建线程，只有在有新任务时才会创建线程去执行任务，空闲线程等待时间60秒。

public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue());

}

ExecutorService与ThreadPoolExecutor是什么关系，有什么差异，因为通过ThreadPoolExecutor也能够实现线程池。

public class Test { public static void main(String[] args) {

ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(5)); for(int i=0;i<15;i++){

MyTask myTask = new MyTask(i);

executor.execute(myTask);

}

executor.shutdown();

}

}

首先来看看ThreadPoolExecutor的execute函数，这个函数返回void：

void execute(Runnable command)//Executes the given task sometime in the future.

然后再来看看ExecutorService的submit函数，这个函数返回Future，即有返回值，这是两者的一个差异之处。

Future> submit(Runnable task)//Submits a Runnable task for execution and returns a Future representing that task.

接下来，通过树状图来看看线程池相关类间的关系，可以查阅源码看之间的关系：

Executor是顶层接口，仅提供execute方法。

ExecutorService接口继承了Executor接口，丰富了接口函数。

AbstractExecutorService抽象类实现了ExecutorService接口。

ThreadPoolExecutor类继承了AbstractExecutorService类。

部分源码

Executor接口

public interface Executor { void execute(Runnable command);

}

ExecutorService接口

public interface ExecutorService extends Executor { void shutdown(); boolean isShutdown(); boolean isTerminated(); boolean awaitTermination(long timeout, TimeUnit unit)

throws InterruptedException;

Future submit(Callable task);

Future submit(Runnable task, T result);

Future> submit(Runnable task);

List> invokeAll(Collection extends Callable> tasks) throws InterruptedException;

List> invokeAll(Collection extends Callable> tasks, long timeout, TimeUnit unit) throws InterruptedException;

T invokeAny(Collection extends Callable> tasks)

throws InterruptedException, ExecutionException;

T invokeAny(Collection extends Callable> tasks, long timeout, TimeUnit unit)

throws InterruptedException, ExecutionException, TimeoutException;

}

AbstractExecutorService抽象类

public abstract class AbstractExecutorService implements ExecutorService { protected RunnableFuture newTaskFor(Runnable runnable, T value) { }; protected RunnableFuture newTaskFor(Callable callable) { }; public Future> submit(Runnable task) {}; public Future submit(Runnable task, T result) { }; public Future submit(Callable task) { }; private T doInvokeAny(Collection extends Callable> tasks, boolean timed, long nanos)

throws InterruptedException, ExecutionException, TimeoutException {

}; public T invokeAny(Collection extends Callable> tasks)

throws InterruptedException, ExecutionException {

}; public T invokeAny(Collection extends Callable> tasks, long timeout, TimeUnit unit)

throws InterruptedException, ExecutionException, TimeoutException {

}; public List> invokeAll(Collection extends Callable> tasks) throws InterruptedException {

}; public List> invokeAll(Collection extends Callable> tasks, long timeout, TimeUnit unit) throws InterruptedException {

};

}

ThreadPoolExecutor类

public class ThreadPoolExecutor extends AbstractExecutorService {

..... public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,

BlockingQueue workQueue); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,

BlockingQueue workQueue,ThreadFactory threadFactory); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,

BlockingQueue workQueue,RejectedExecutionHandler handler); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,

BlockingQueue workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

...public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return;

c = ctl.get();

} if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command))

reject(command); else if (workerCountOf(recheck) == 0)

addWorker(null, false);

} else if (!addWorker(command, false)) reject(command);

}

}

欢迎关注小编，每日更新最新资讯带给大家。返回搜狐，查看更多

责任编辑：