java多线程工具类_Java多线程并发工具类

Semaphore-信号灯机制

当我们创建一个可扩展大小的线程池，并且需要在线程池内同时让有限数目的线程并发运行时，就需要用到Semaphore(信号灯机制)，Semaphore 通常用于限制可以访问某些资源(物理或逻辑的)的线程数目，它是一个计数信号量，从概念上讲，信号量维护了一个许可集合，如有必要，在许可可用前会阻塞每一个acquire()，然后再获取该许可，每个release() 添加一个许可，从而可能释放一个正在阻塞的获取者。

在线程池内创建线程并运行时，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，线程返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。注意，调用acquire() 时无法保持同步锁定，因为这会阻止线程返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。下面通过一个例子加以说明：

public class SemaphoreTest {

public static void main(String[] args) {

ExecutorService service = Executors.newCachedThreadPool();

final Semaphore sp = new Semaphore(3);

for(int i=0;i<5;i++){

Runnable runnable = new Runnable(){

public void run(){

try {

sp.acquire();

} catch (InterruptedException e1) {

e1.printStackTrace();

}

System.out.println("线程" + Thread.currentThread().getName() +

"进入，当前已有" + (3-sp.availablePermits()) + "个并发");

try {

Thread.sleep((long)(Math.random()*10000));

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("线程" + Thread.currentThread().getName() +

"即将离开");

sp.release();

//下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元

System.out.println("线程" + Thread.currentThread().getName() +

"已离开，当前已有" + (3-sp.availablePermits()) + "个并发");

}

};

service.execute(runnable);

}

}

}

该例子定义了一个newCachedThreadPool，在该Pool中利用for循环同时创建5个线程，现在通过Semaphore，创建一个只允许在线程池中有3个线程并发运行，sp.acquire()表示某个线程获得了一个信号灯，开始运行，在运行结束时，通过sp.release()还回这个信号灯，以便剩下的线程获得信号灯运行，sp.availablePermits()指的是当前信号灯库中有多少个可以被使用，由于例子中定义有3个信号灯，所以3-sp.availablePermits()就代表了当前有多少个线程在并发运行，上例运行结果如下：

线程pool-1-thread-1进入，当前已有2个并发

线程pool-1-thread-2进入，当前已有2个并发

线程pool-1-thread-3进入，当前已有3个并发

线程pool-1-thread-1即将离开

线程pool-1-thread-1已离开，当前已有2个并发

线程pool-1-thread-4进入，当前已有3个并发

线程pool-1-thread-3即将离开

线程pool-1-thread-3已离开，当前已有2个并发

线程pool-1-thread-5进入，当前已有3个并发

线程pool-1-thread-2即将离开

线程pool-1-thread-2已离开，当前已有2个并发

线程pool-1-thread-4即将离开

线程pool-1-thread-4已离开，当前已有1个并发

线程pool-1-thread-5即将离开

线程pool-1-thread-5已离开，当前已有0个并发

Semaphore作为互斥锁使用：

当信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，与传统互斥锁最大不同就是在释放的时候并不是必须要拥有锁的对象释放，也可以由其他的对象释放，因为信号量没有所有权的概念。在某些专门的上下文(如死锁恢复)中这会很有用。

Semaphore的构造方法有两种：

第一种：

Semaphore(int permits) //用给定的许可数和非公平的公平设置创建一个 Semaphore。

第一种构造方法创建的信号灯，现在在获取的时候是随机的，没有一定的顺序，例如上例中，在前三个线程中的一个运行完毕以后，释放一个信号灯，剩下的两个线程就会随机的一个线程得到这个信号灯而运行。

第二种：

Semaphore(int permits, boolean fair) //用给定的许可数和给定的公平设置创建一个 Semaphore

第二种构造方法可选地接受一个公平 参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入 是允许的，也就是说可以在已经等待的线程前为调用acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用acquire() 方法的线程而言，都按照处理它们调用这些方法的顺序(即先进先出；FIFO)来选择线程、获得许可。注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了acquire()，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的tryAcquire() 方法不使用公平设置，而是使用任意可用的许可。

通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。

CyclicBarrier-用路障实现分阶段线程并发

生活中我们常常会遇到这样的情景：10个朋友邀约去公园玩，彼此约好上午十点在小区门口集合然后一块租车过去，可能上午九点就会有人开始到了门口，但是因为人没有来全，必须等剩下的人，最后等到人全后大家一块到公园，到达公园后又约定分头开始玩，下午6点的时候公园门口集合，然后一块回去。在我们java编程过程中也会遇到类似的情况，要求必须几个线程都运行完后才可以进行下一步的操作，这就用到了循环路障类--CyclicBarrier。

CyclicBarrier一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。它 还支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后(但在释放所有线程之前)，该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作很有用。

CyclicBarrier有两种构造方法：

第一种：

CyclicBarrier(int parties) //创建一个新的 CyclicBarrier，它将在给定数量的参与者(线程)处于等待状态时启动，但它不会在每个 barrier 上执行预定义的操作

第二种：

CyclicBarrier(int parties, Runnable barrierAction) // 创建一个新的 CyclicBarrier，它将在给定数量的参与者(线程)处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。

下面通过一个实例进行说明：

public class CyclicBarrierTest {

public static void main(String[] args) {

ExecutorService service = Executors.newCachedThreadPool();

final CyclicBarrier cb = new CyclicBarrier(3);

for(int i=0;i<3;i++){

Runnable runnable = new Runnable(){

public void run(){

try {

Thread.sleep((long)(Math.random()*10000));

System.out.println("线程" + Thread.currentThread().getName() +

"即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));

cb.await();

Thread.sleep((long)(Math.random()*10000));

System.out.println("线程" + Thread.currentThread().getName() +

"即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));

cb.await();

Thread.sleep((long)(Math.random()*10000));

System.out.println("线程" + Thread.currentThread().getName() +

"即将到达集合地点3，当前已有" + (cb.getNumberWaiting() + 1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));

cb.await();

} catch (Exception e) {

e.printStackTrace();

}

}

};

service.execute(runnable);

}

service.shutdown();

}

}

该例中定义了一个循环路障类：CyclicBarrier cb = new CyclicBarrier(3);在路障中设定必须要三个线程等待( cb.await())的时候才可以往下运行，从而达到下一个集合点。该例利用Thread.sleep((long)(Math.random()*10000)); 产生一个随机的休眠时间，用它来实现不同线程到达路障时的时间不同，到的早的线程需要等待到的晚的线程，当3个线程都cb,.await()；时。路障打开，3个线程再往下运行。程序运行的结果如下：

线程pool-1-thread-2即将到达集合地点1，当前已有1个已经到达，正在等候

线程pool-1-thread-1即将到达集合地点1，当前已有2个已经到达，正在等候

线程pool-1-thread-3即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊

线程pool-1-thread-1即将到达集合地点2，当前已有1个已经到达，正在等候

线程pool-1-thread-2即将到达集合地点2，当前已有2个已经到达，正在等候

线程pool-1-thread-3即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊

线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候

线程pool-1-thread-1即将到达集合地点3，当前已有2个已经到达，正在等候

线程pool-1-thread-2即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊

上例中是通过for循环产生了刚好3个线程，如果把产生的线程数改成4个的话，在这4个线程当中，只要有3个到达路障的时候，路障就会打开，其运行结果如下：

线程pool-1-thread-3即将到达集合地点1，当前已有1个已经到达，正在等候

线程pool-1-thread-1即将到达集合地点1，当前已有2个已经到达，正在等候

线程pool-1-thread-4即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊

线程pool-1-thread-2即将到达集合地点1，当前已有1个已经到达，正在等候

线程pool-1-thread-1即将到达集合地点2，当前已有2个已经到达，正在等候

线程pool-1-thread-4即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊

线程pool-1-thread-2即将到达集合地点2，当前已有1个已经到达，正在等候

线程pool-1-thread-3即将到达集合地点2，当前已有2个已经到达，正在等候

线程pool-1-thread-4即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊

线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候

线程pool-1-thread-2即将到达集合地点3，当前已有2个已经到达，正在等候

线程pool-1-thread-1即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊

CountDownLatch-线程并发的发令枪

田径赛百米短跑时，运动员会在起跑线做准备动作，等到发令枪一声响，运动员就会奋力奔跑。在多线程运行时，也有这么一个发令枪--CountDownLatch，它通过控制事先定义的计数来控制线程的运行。

CountDownLatch的构造方法如下：

CountDownLatch(int count); //构造一个用给定计数初始化的 CountDownLatch。

主要用到的方法有：

void await(); //使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。

boolean await(long timeout, TimeUnit unit); //使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。

void countDown(); //递减锁存器的计数，如果计数到达零，则释放所有等待的线程。

long getCount(); // 返回当前计数。

String toString(); //返回标识此锁存器及其状态的字符串。

CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。对于给定的计数 初始化 CountDownLatch，可以调用了 countDown() 方法，在当前计数到达零之前，await() 方法会一直受阻塞，当计数到达零时，会释放所有等待的线程，await() 的所有后续调用都将立即返回。但这种现象只出现一次——计数无法被重置，如果需要重置计数，请考虑使用 CyclicBarrier。

CountDownLatch 是一个通用同步工具，它有很多用途，将计数  初始化为1的 CountDownLatch可 用作一个简单的开/关锁存器或入口，在通过调用 countDown() 的线程打开入口前，所有调用 await() 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。

CountDownLatch 的一个有用特性是，它不要求调用 countDown() 方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过await(),它比CyclicBarrier有更大的灵活性，它可以控制不确定数目的线程，而不是像CyclicBarrier在确定数目的线程wait()时就会通过，只有当countDown()的值为0时才允许所有的线程通过。

下面通过一个例子加以说明：

public class CountdownLatchTest {

public static void main(String[] args) {

ExecutorService service = Executors.newCachedThreadPool();

final CountDownLatch cdOrder = new CountDownLatch(1);

final CountDownLatch cdAnswer = new CountDownLatch(3);

for(int i=0;i<3;i++){

Runnable runnable = new Runnable(){

public void run(){

try {

System.out.println("线程" + Thread.currentThread().getName() +

"正准备接受命令");

cdOrder.await();

System.out.println("线程" + Thread.currentThread().getName() +

"已接受命令");

Thread.sleep((long)(Math.random()*10000));

System.out.println("线程" + Thread.currentThread().getName() +

"回应命令处理结果");

cdAnswer.countDown();

} catch (Exception e) {

e.printStackTrace();

}

}

};

service.execute(runnable);

}

try {

Thread.sleep((long)(Math.random()*10000));

System.out.println("线程" + Thread.currentThread().getName() +

"即将发布命令");

cdOrder.countDown();

System.out.println("线程" + Thread.currentThread().getName() +

"已发送命令，正在等待结果");

cdAnswer.await();

System.out.println("线程" + Thread.currentThread().getName() +

"已收到所有响应结果");

} catch (Exception e) {

e.printStackTrace();

}

service.shutdown();

}

}

上例中main方法表示主线程，并且通过for循环创建3个子线程，定义了两个CountDownLatch对象：cdOrder和cdAnswer，cdOrder计数为1，用来控制3个子线程，cdAnswer计数为3，用来控制主线程。当程序开始运行时，主线程和子线程同时开始运行，由于主线程需要sleep一段时间，所以3个子线程运行，但是碰到cdOrder.await();必须等到主线程cdOrder.countDown();将计数变成0时才可以继续往下运行，主线程运行到cdAnswer.await();时等待，只有当三个子线程都cdAnswer.countDown();将计数变为0时主线程才可以往下运行。改程序运行结果如下：

线程pool-1-thread-2正准备接受命令

线程pool-1-thread-3正准备接受命令

线程pool-1-thread-1正准备接受命令

线程main即将发布命令

线程main已发送命令，正在等待结果

线程pool-1-thread-3已接受命令

线程pool-1-thread-2已接受命令

线程pool-1-thread-1已接受命令

线程pool-1-thread-1回应命令处理结果

线程pool-1-thread-3回应命令处理结果

线程pool-1-thread-2回应命令处理结果

线程main已收到所有响应结果

Exchanger-兄弟线程的信息交换

如果两个线程在运行过程中需要交换彼此的信息，比如一个数据或者使用的空间，就需要用到Exchanger这个类，Exchanger为线程交换信息提供了非常方便的途径，它可以作为两个线程交换对象的同步点，只有当每个线程都在进入 exchange ()方法并给出对象时，才能接受其他线程返回时给出的对象。

Exchanger的构造方法如下：

Exchanger(); //创建一个新的 Exchanger。

Exchanger用到的主要方法有：

exchange(V x); //等待另一个线程到达此交换点(除非它被中断)，然后将给定的对象传送给该线程，并接收该线程的对象。

exchange(V x, long timeout, TimeUnit unit)； // 等待另一个线程到达此交换点(除非它被中断，或者超出了指定的等待时间)，然后将给定的对象传送给该线程，同时接收该线程的对象。

下面通过例子来加以说明：

public class ExchangerTest {

public static void main(String[] args) {

ExecutorService service = Executors.newCachedThreadPool();

final Exchanger exchanger = new Exchanger();

service.execute(new Runnable(){

public void run() {

try {

String data1 = "zxx";

System.out.println("线程" + Thread.currentThread().getName() +

"正在把数据" + data1 +"换出去");

Thread.sleep((long)(Math.random()*10000));

String data2 = (String)exchanger.exchange(data1);

System.out.println("线程" + Thread.currentThread().getName() +

"换回的数据为" + data2);

}catch(Exception e){

}

}

});

service.execute(new Runnable(){

public void run() {

try {

String data1 = "lhm";

System.out.println("线程" + Thread.currentThread().getName() +

"正在把数据" + data1 +"换出去");

Thread.sleep((long)(Math.random()*10000));

String data2 = (String)exchanger.exchange(data1);

System.out.println("线程" + Thread.currentThread().getName() +

"换回的数据为" + data2);

}catch(Exception e){

}

}

});

}

}

上例main()方法中创建了2个线程，两个线程都有各自String类型的data，并且各自的sleep时间都不一样。类中定义了一个Exchanger对象，作为两个线程交换数据的通道，当其中一个线程运行exchanger.exchange()；方法时，由于没有另外一个线程还没有开始执行这个交换方法，所以就需要等到另外一个线程也提出交换时，两个线程才可以完成信息的交换。其运行结果如下：

线程pool-1-thread-1正在把数据zxx换出去

线程pool-1-thread-2正在把数据lhm换出去

线程pool-1-thread-2换回的数据为zxx

线程pool-1-thread-1换回的数据为lhm