countdownlatch的用法
countdownlatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能，比如有一个任务A，它要等待其他4个任务都执行完成之后，才能执行，此时就可以利用countdownlatch来实现这种功能；
countdownlatch只提供了一种构造器；
public CountDonwnLatch（int count）{}；//参数count为计数器
然后下面这3个方法时countdownlatch类中最重要的3个方法；
public void await（）throws interruptedException{}；//调用await（）的线程会被挂起，它会等待知道count值为0才继续执行；
public boolean await（long timeout，TimeUnit unit） throws interruptedException{}；//和await（）方法类似，只不过等待一定时间后count值还没有变为0的话，也会继续执行；
public void countDown（）{}；//将count值减1；
示例：
public class Test {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2);
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
try {
System.out.println("等待2个子线程执行完毕...");
latch.await();
System.out.println("2个子线程已经执行完毕");
System.out.println("继续执行主线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果：
线程Thread-0正在执行
线程Thread-1正在执行
等待2个子线程执行完毕...
线程Thread-0执行完毕
线程Thread-1执行完毕
2个子线程已经执行完毕
继续执行主线程
cyclicBarrier的用法
字面意思是回环栅栏，通过它可以实现让一组线程等待至某个状态后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，cyclicbarrier是可以被重用的。我们暂且把这个状态叫做barrier，当调用await（）方法后，线程就处于barrier；
CyclicBarrier类位于java.util.concurrent包下，CyclicBarrier提供了2个构造器：
public CyclicBarrier（int parties，Runable barrierAction）{}；
public CyclicBarrier（int parties）{}；
参数parties是指让多少个线程或者任务等待至barrier状态，参数barrierAction为这些线程都达到barrier状态时会执行的内容；
CyclicBarrier中最重要的方法就是await（）方法，它有两个重载的方法；
版本1：public void await（）throws interruptedException，BrokenBarrierException{}；
版本2：public void await（long timeout，TimeUnit unit）throws interruptedExcpetion，BrokenBarrierException，TimeOutException{}；
第一个版本比较常用，用来挂起当前线程，知道所有线程都达到barrier状态之后再同时执行后续任务；
第二个版本是让这些线程等待一定时间，如果还有线程没有达到barrier状态，也会执行后续的任务；
示例：
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;i<N;i++)
new Writer(barrier).start();
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
try {
Thread.sleep(5000); //以睡眠来模拟写入数据操作
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有线程写入完毕，继续处理其他任务...");
}
}
}
执行结果：
线程Thread-0正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
从上面输出结果可以看出，每个线程都是执行完数据写入操作之后达到barrier状态，等待其他线程全部都达到barrier状态后同时执行下面的操作；
如果想在所有线程都执行完写入操作之后，进行额外的其他操作可以为CyclicBarrier提供Runable参数；
示例：
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N,new Runnable() {
@Override
public void run() {
System.out.println("当前线程"+Thread.currentThread().getName());
}
});
for(int i=0;i<N;i++)
new Writer(barrier).start();
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
try {
Thread.sleep(5000); //以睡眠来模拟写入数据操作
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有线程写入完毕，继续处理其他任务...");
}
}
}
执行结果：
线程Thread-0正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2正在写入数据...
线程Thread-3正在写入数据...
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
当前线程Thread-3
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
从上面执行结果可以看出，当所有线程都执行完数据写入操作达到barrier状态后，会从现有的4个线程中随用选一个去执行runable操作；
下面看下await（）方法执行timeout时间的效果：
实例：
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;i<N;i++) {
if(i<N-1)
new Writer(barrier).start();
else {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Writer(barrier).start();
}
}
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
try {
Thread.sleep(5000); //以睡眠来模拟写入数据操作
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
try {
cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
}
}
}
执行结果：
线程Thread-0正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-3正在写入数据...
java.util.concurrent.TimeoutException
Thread-1所有线程写入完毕，继续处理其他任务...
Thread-0所有线程写入完毕，继续处理其他任务...
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
java.util.concurrent.BrokenBarrierException
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
java.util.concurrent.BrokenBarrierException
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
Thread-2所有线程写入完毕，继续处理其他任务...
java.util.concurrent.BrokenBarrierException
线程Thread-3写入数据完毕，等待其他线程写入完毕
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
Thread-3所有线程写入完毕，继续处理其他任务...
上面的代码是在for循环中做了判断，然最后一个线程延迟5000ms执行；因为前面3个线程都已经到达了barrier状态，等待指定时间2000ms之后，发现第4个线程还没有到达barrier状态，就会抛出异常，并继续执行后面的操作；
另外CyclicBarrier是可以重用的；
示例：
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;i<N;i++) {
new Writer(barrier).start();
}
try {
Thread.sleep(25000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("CyclicBarrier重用");
for(int i=0;i<N;i++) {
new Writer(barrier).start();
}
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
try {
Thread.sleep(5000); //以睡眠来模拟写入数据操作
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
}
}
}
执行结果：
线程Thread-0正在写入数据...
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
Thread-0所有线程写入完毕，继续处理其他任务...
Thread-3所有线程写入完毕，继续处理其他任务...
Thread-1所有线程写入完毕，继续处理其他任务...
Thread-2所有线程写入完毕，继续处理其他任务...
CyclicBarrier重用
线程Thread-4正在写入数据...
线程Thread-5正在写入数据...
线程Thread-6正在写入数据...
线程Thread-7正在写入数据...
线程Thread-7写入数据完毕，等待其他线程写入完毕
线程Thread-5写入数据完毕，等待其他线程写入完毕
线程Thread-6写入数据完毕，等待其他线程写入完毕
线程Thread-4写入数据完毕，等待其他线程写入完毕
Thread-4所有线程写入完毕，继续处理其他任务...
Thread-5所有线程写入完毕，继续处理其他任务...
Thread-6所有线程写入完毕，继续处理其他任务...
Thread-7所有线程写入完毕，继续处理其他任务...
从执行结果可以看出，在初次的4个线程越过barrier状态之后，又可以用来新一轮的使用。而countdownlatch无法进行重复使用；
semaphore的用法；
semaphore翻译成字面意思是信号量，semaphore可以控制同时访问的线程个数，通过acquire（）获取一个许可，如果没有就等待，而release（）释放一份许可；
semaphore位于java.util.concrrent包下，它提供了2个构造器；
public Semaphore（int permits）{ //参数permits表示许可数目，即同时可以允许多少线程进行访问；
sync = new NonfairSync(permits);
}
public Semaphore（int permits，boolean fair）{//这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可；
sync = （fair）？new FairSync(permits): new NonfairSync(permits);
}
下面说一下Semaphore类中比较重要的几个方法，首先是acquire（）、release（）方法：
public void acquire（）throws interruptedException{}; //获取一个许可；
public void acquire（int permits） throws interruptedException{} //获取permits个许可；
public void release（）{}；//释放一个许可；
public void release（int permits）{} //释放permits个许可；
acquire()用来获取一个许可，若无许可能够获取，则会一直等待，知道获得许可；
release() 用来释放许可。注意，在释放许可之前，必须先获得许可。
这4个方法都会被阻塞，如果想立即得到执行结果，可使用下面几个方法；
public boolean tryAcquire(){}; //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false；
public boolean tryAcquire(long timeout,TimeUnit unit) throws interruptedException{};//尝试获取一个许可，若在指定时间内获取成功，则立即返回true，否则立即返回false；
public boolean tryAcquire(int permits){}；//尝试获取permits个许可，若成功返回true，若获取失败，则立刻返回false；
public boolean tryAcquire(int permits,long timeout, TimeUnit unit){};//尝试获取permits个许可，若在指定时间内获取成功，则立即返回true，否则立即返回false；
另外还可以通过availablePermits（）方法得到可用的许可数目；
示例：
假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，知识使用完了，其他工人才能继续使用。那么我们就可以通过semaphore来实现：
public class Test {
public static void main(String[] args) {
int N = 8; //工人数
Semaphore semaphore = new Semaphore(5); //机器数目
for(int i=0;i<N;i++)
new Worker(i,semaphore).start();
}
static class Worker extends Thread{
private int num;
private Semaphore semaphore;
public Worker(int num,Semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("工人"+this.num+"占用一个机器在生产...");
Thread.sleep(2000);
System.out.println("工人"+this.num+"释放出机器");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果：
工人0占用一个机器在生产...
工人1占用一个机器在生产...
工人2占用一个机器在生产...
工人4占用一个机器在生产...
工人5占用一个机器在生产...
工人0释放出机器
工人2释放出机器
工人3占用一个机器在生产...
工人7占用一个机器在生产...
工人4释放出机器
工人5释放出机器
工人1释放出机器
工人6占用一个机器在生产...
工人3释放出机器
工人7释放出机器
工人6释放出机器
总结 ：
1.countdownlatch和cyclicbarrier都能实现线程之间的等待，只不过他们侧重点不同；
coutdownlatch一般用于某个线程A等待若干个线程执行完任务后，它才执行；
cyclicbarrier一般用于一组线程都达到某个状态，然后这一组线程再同时执行；
另外，countdownlatch是不能够重用的，而cyclicbarrier是可以重用的；
2.semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限；
