[b]同步器[/b]
在集合类中阻塞队列是对一无二的:不仅仅因为他是对象的容器,而且还因为他能协调生产者和消费者线程的控制流程,这得归功于take和put方法的阻塞。
同步器可以是任何能基于状态协调线程控制流程的对象。阻塞线程可以当作同步器;其他类型的同步器包括semaphores,barriers,latches.这些同步器类在jdk中就有提供。
所有的同步器都具有某些基础的属性:他们封装了一些状态,用来决定已经到达了同步器的线程是允许通过还是强迫他等待,而且还提供了一些方法来操作这些状态,另外还提供了方法来等待同步器进入想要的状态。
[b]Latches(门闩)[/b]
该同步器可以延迟线程的执行,直到同步器进入终结状态。Latch扮演了门的角色:在门闩进入终结状态之前,门是关闭的,没有任何线程可以通过。而当进入终结状态,即门开的时候,则允许任何线程通过。一旦门闩成为终结状态,那么他将不能在修改他的状态了,所以他将永远打开。Latches还可以被用来保证某些活动在其他活动结束之前不被执行,比如:
1.保证在资源初始化完毕之前,任何计算线程不能执行。一个简单的二进制latch就可以用来标记资源已经初始化完毕,在这之前,任何活动都将等待这个latch
2.保证一个服务在依赖的服务启动之后再启动.每个服务都和二进制的latch有关联;启动服务S,那么依赖于S的服务都将会等待,直到S启动,然后S的latch将被释放,这样,任何依赖于S的服务都可以继续执行。
3.在一个活动的各个部分都准备好之前,一直等待,比如多人游戏,在这种情况,latch在所有的player都准备好之后,将释放,进入最终状态。
[b]CountDownLatch[/b]
这个比较有意思,当计数倒数到0的时候,所有线程执行
[code]
package com.company.jncz;
import java.util.concurrent.CountDownLatch;
public class LatchTest {
class Worker implements Runnable{
private CountDownLatch start;
private CountDownLatch end;
private int i;
Worker(CountDownLatch start,CountDownLatch end, int i){
this.start = start;
this.end = end;
this.i = i;
}
public void run() {
try {
start.await();//如果注释这句,则任务被创建出来之后即执行,不会等待startSignal.countDown()这个启动信号
dowork();
System.out.println("第"+i+"个任务执行");
} catch (Exception e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
end.countDown();
}
private void dowork() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();//TODO
}
}
}
public static void main(String args[]) throws InterruptedException{
int num = 50;
LatchTest lt = new LatchTest();
CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch endSignal = new CountDownLatch(num);
for(int i=0;i<num;i++){
new Thread(lt.new Worker(startSignal,endSignal, i)).start();
}
System.out.println("任务开始执行");
startSignal.countDown();//开始执行任务
try {
endSignal.await();//等待所有线程结束执行
} catch (InterruptedException e) {
e.printStackTrace();//TODO
}
System.out.println("执行完毕");
}
}
[/code]
在这段代码中startSignal表示了一个信号量,如同跑步的时候,发令员的枪声,由于startSignal初始值是1,所以一旦执行了startSignal.countDown(),那么立即就成了0,那么所有任务立即开始执行,而在Worker内部,endSignal不断的在countDown,所以随着任务的执行endSignal也慢慢接近于0,一旦所有任务执行完毕,则endSignal为0,则endSignal.await()方法通过,那么后续的工作可以继续进行。
[b]FutureTask[/b]
FutureTask也可以当作一个latch。(FutureTask实现了Future接口,他描述了一种抽象的因果关系)。FutureTask代表的运算,最终是由一个实现Callable接口的类实现的,他可以处于以下三种状态:waiting to run,running,completed。所谓完成状态代表了正常完成,取消和异常。一旦一个FutureTask进入完成状态,那么他将永远处于完成状态。
Future.get的行为取决于任务的状态。如果是完成状态,则get立即返回结果,否则将阻塞,直到任务状态为完成才返回结果,或者抛出异常。FutureTask将结果从计算线程转移到接收线程;FutureTask的规范保证了这种转移始终安全的结果发布。
FutureTask被Executor框架用来表示异步任务,或者用来表示任意的耗时的计算(而该计算又不是很迫切需要返回结果).
[b]Semaphore[/b]
计数信号量通常用来控制活动的数目,比如对资源的访问或者在某个时刻运行某个动作。计数信号量可以被用来实现资源池或者给集合加上边界限制。
Semaphore管理了一些虚拟的许可,任何活动可以获取许可,当他们做完之后,可以释放许可,如果没有许可了,则acquire会阻塞,直到有可用的许可(或被中断或者超时)。而release方法则将许可返回给Semaphore。如果许可数目初始化成1,则相当于一个非可重入的互斥锁。谁获取了许可谁就获得了这个互斥锁。
这里所说的许可,并不跟任何线程挂钩,所以许可可以在A线程被获得,而在B线程被返回给Semaphore。可以认为acquire是消费许可,而release是创建许可。
[code]
public class BoundedHashSet<T> {
private final Set<T> set;
private final Semaphore sem;
public BoundedHashSet(int bound) {
this.set = Collections.synchronizedSet(new HashSet<T>());
sem = new Semaphore(bound);
}
public boolean add(T o) throws InterruptedException {
sem.acquire();
boolean wasAdded = false;
try {
wasAdded = set.add(o);
return wasAdded;
}
finally {
if (!wasAdded)
sem.release();
}
}
public boolean remove(Object o) {
boolean wasRemoved = set.remove(o);
if (wasRemoved)
sem.release();
return wasRemoved;
}
}
[/code]
代码中的bound就是这个集合的边界,只能有这么长。否则获取许可的时候,已经没有许可可以给了,只能阻塞,只有在有一个元素被remove之后,许可才会有。
[b]Barriers[/b]
[code]
package com.company.jncz.concurrent;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class BarrierTest {
class Soldier implements Runnable{
private CyclicBarrier cb;
private int i;
Soldier(CyclicBarrier cb,int i){
this.i = i;
this.cb = cb;
}
public void run() {
try {
System.out.println("士兵"+i+"号到达目的地,并等待其他士兵");
cb.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class AfterWork implements Runnable{
public void run() {
System.out.println("士兵到齐,出发");
}
}
public static void main(String args[]){
BarrierTest bt = new BarrierTest();
int num = 50;
CyclicBarrier cb = new CyclicBarrier(num,bt.new AfterWork());
for (int i = 0; i < num; i++) {
new Thread(bt.new Soldier(cb,i)).start();
}
}
}
[/code]
这个类模拟了Barrier的作用,他会等待所有线程都完毕之后,才会执行其指定的Runnable接口。
如上代码,当每个线程运行完毕之后,会打印出“士兵到位”的信息,并会await,直到其他士兵全部到齐,然后会运行AfterWork这个类。
另外一种Barrier是Exchanger,他由两个barrier组成,每个部分在边界点交换数据。当在运行不对成的活动时很有用,比如当一个线程填充了buffer,另一个线程从buffer中消费数据;这些线程可以用Exchanger来交换数据。当两个线程通过Exchanger交互了对象,这个交换对于两个线程来说都是安全的。
[code]
package com.company.jncz.concurrent;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Exchanger;
public class ExchangerTest {
private static final Exchanger ex = new Exchanger();
class DataProducer implements Runnable{
private List list = new ArrayList();
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("生产了一个数据,耗时1秒");
list.add(new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
ex.exchange(list);//将数据准备用于交换
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class DataConsumer implements Runnable{
private List list = new ArrayList();
public void run() {
try {
list = (List) ex.exchange(list);//进行交换数据
} catch (InterruptedException e) {
e.printStackTrace();
}
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Date d = (Date) iterator.next();
System.out.println(d);
}
}
}
public static void main(String args[]){
ExchangerTest et = new ExchangerTest();
new Thread(et.new DataProducer()).start();
new Thread(et.new DataConsumer()).start();
}
}
[/code]
在集合类中阻塞队列是对一无二的:不仅仅因为他是对象的容器,而且还因为他能协调生产者和消费者线程的控制流程,这得归功于take和put方法的阻塞。
同步器可以是任何能基于状态协调线程控制流程的对象。阻塞线程可以当作同步器;其他类型的同步器包括semaphores,barriers,latches.这些同步器类在jdk中就有提供。
所有的同步器都具有某些基础的属性:他们封装了一些状态,用来决定已经到达了同步器的线程是允许通过还是强迫他等待,而且还提供了一些方法来操作这些状态,另外还提供了方法来等待同步器进入想要的状态。
[b]Latches(门闩)[/b]
该同步器可以延迟线程的执行,直到同步器进入终结状态。Latch扮演了门的角色:在门闩进入终结状态之前,门是关闭的,没有任何线程可以通过。而当进入终结状态,即门开的时候,则允许任何线程通过。一旦门闩成为终结状态,那么他将不能在修改他的状态了,所以他将永远打开。Latches还可以被用来保证某些活动在其他活动结束之前不被执行,比如:
1.保证在资源初始化完毕之前,任何计算线程不能执行。一个简单的二进制latch就可以用来标记资源已经初始化完毕,在这之前,任何活动都将等待这个latch
2.保证一个服务在依赖的服务启动之后再启动.每个服务都和二进制的latch有关联;启动服务S,那么依赖于S的服务都将会等待,直到S启动,然后S的latch将被释放,这样,任何依赖于S的服务都可以继续执行。
3.在一个活动的各个部分都准备好之前,一直等待,比如多人游戏,在这种情况,latch在所有的player都准备好之后,将释放,进入最终状态。
[b]CountDownLatch[/b]
这个比较有意思,当计数倒数到0的时候,所有线程执行
[code]
package com.company.jncz;
import java.util.concurrent.CountDownLatch;
public class LatchTest {
class Worker implements Runnable{
private CountDownLatch start;
private CountDownLatch end;
private int i;
Worker(CountDownLatch start,CountDownLatch end, int i){
this.start = start;
this.end = end;
this.i = i;
}
public void run() {
try {
start.await();//如果注释这句,则任务被创建出来之后即执行,不会等待startSignal.countDown()这个启动信号
dowork();
System.out.println("第"+i+"个任务执行");
} catch (Exception e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
end.countDown();
}
private void dowork() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();//TODO
}
}
}
public static void main(String args[]) throws InterruptedException{
int num = 50;
LatchTest lt = new LatchTest();
CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch endSignal = new CountDownLatch(num);
for(int i=0;i<num;i++){
new Thread(lt.new Worker(startSignal,endSignal, i)).start();
}
System.out.println("任务开始执行");
startSignal.countDown();//开始执行任务
try {
endSignal.await();//等待所有线程结束执行
} catch (InterruptedException e) {
e.printStackTrace();//TODO
}
System.out.println("执行完毕");
}
}
[/code]
在这段代码中startSignal表示了一个信号量,如同跑步的时候,发令员的枪声,由于startSignal初始值是1,所以一旦执行了startSignal.countDown(),那么立即就成了0,那么所有任务立即开始执行,而在Worker内部,endSignal不断的在countDown,所以随着任务的执行endSignal也慢慢接近于0,一旦所有任务执行完毕,则endSignal为0,则endSignal.await()方法通过,那么后续的工作可以继续进行。
[b]FutureTask[/b]
FutureTask也可以当作一个latch。(FutureTask实现了Future接口,他描述了一种抽象的因果关系)。FutureTask代表的运算,最终是由一个实现Callable接口的类实现的,他可以处于以下三种状态:waiting to run,running,completed。所谓完成状态代表了正常完成,取消和异常。一旦一个FutureTask进入完成状态,那么他将永远处于完成状态。
Future.get的行为取决于任务的状态。如果是完成状态,则get立即返回结果,否则将阻塞,直到任务状态为完成才返回结果,或者抛出异常。FutureTask将结果从计算线程转移到接收线程;FutureTask的规范保证了这种转移始终安全的结果发布。
FutureTask被Executor框架用来表示异步任务,或者用来表示任意的耗时的计算(而该计算又不是很迫切需要返回结果).
[b]Semaphore[/b]
计数信号量通常用来控制活动的数目,比如对资源的访问或者在某个时刻运行某个动作。计数信号量可以被用来实现资源池或者给集合加上边界限制。
Semaphore管理了一些虚拟的许可,任何活动可以获取许可,当他们做完之后,可以释放许可,如果没有许可了,则acquire会阻塞,直到有可用的许可(或被中断或者超时)。而release方法则将许可返回给Semaphore。如果许可数目初始化成1,则相当于一个非可重入的互斥锁。谁获取了许可谁就获得了这个互斥锁。
这里所说的许可,并不跟任何线程挂钩,所以许可可以在A线程被获得,而在B线程被返回给Semaphore。可以认为acquire是消费许可,而release是创建许可。
[code]
public class BoundedHashSet<T> {
private final Set<T> set;
private final Semaphore sem;
public BoundedHashSet(int bound) {
this.set = Collections.synchronizedSet(new HashSet<T>());
sem = new Semaphore(bound);
}
public boolean add(T o) throws InterruptedException {
sem.acquire();
boolean wasAdded = false;
try {
wasAdded = set.add(o);
return wasAdded;
}
finally {
if (!wasAdded)
sem.release();
}
}
public boolean remove(Object o) {
boolean wasRemoved = set.remove(o);
if (wasRemoved)
sem.release();
return wasRemoved;
}
}
[/code]
代码中的bound就是这个集合的边界,只能有这么长。否则获取许可的时候,已经没有许可可以给了,只能阻塞,只有在有一个元素被remove之后,许可才会有。
[b]Barriers[/b]
[code]
package com.company.jncz.concurrent;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class BarrierTest {
class Soldier implements Runnable{
private CyclicBarrier cb;
private int i;
Soldier(CyclicBarrier cb,int i){
this.i = i;
this.cb = cb;
}
public void run() {
try {
System.out.println("士兵"+i+"号到达目的地,并等待其他士兵");
cb.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class AfterWork implements Runnable{
public void run() {
System.out.println("士兵到齐,出发");
}
}
public static void main(String args[]){
BarrierTest bt = new BarrierTest();
int num = 50;
CyclicBarrier cb = new CyclicBarrier(num,bt.new AfterWork());
for (int i = 0; i < num; i++) {
new Thread(bt.new Soldier(cb,i)).start();
}
}
}
[/code]
这个类模拟了Barrier的作用,他会等待所有线程都完毕之后,才会执行其指定的Runnable接口。
如上代码,当每个线程运行完毕之后,会打印出“士兵到位”的信息,并会await,直到其他士兵全部到齐,然后会运行AfterWork这个类。
另外一种Barrier是Exchanger,他由两个barrier组成,每个部分在边界点交换数据。当在运行不对成的活动时很有用,比如当一个线程填充了buffer,另一个线程从buffer中消费数据;这些线程可以用Exchanger来交换数据。当两个线程通过Exchanger交互了对象,这个交换对于两个线程来说都是安全的。
[code]
package com.company.jncz.concurrent;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Exchanger;
public class ExchangerTest {
private static final Exchanger ex = new Exchanger();
class DataProducer implements Runnable{
private List list = new ArrayList();
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("生产了一个数据,耗时1秒");
list.add(new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
ex.exchange(list);//将数据准备用于交换
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class DataConsumer implements Runnable{
private List list = new ArrayList();
public void run() {
try {
list = (List) ex.exchange(list);//进行交换数据
} catch (InterruptedException e) {
e.printStackTrace();
}
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Date d = (Date) iterator.next();
System.out.println(d);
}
}
}
public static void main(String args[]){
ExchangerTest et = new ExchangerTest();
new Thread(et.new DataProducer()).start();
new Thread(et.new DataConsumer()).start();
}
}
[/code]