NIO总结（四）

CountDownLatch：闭锁，线程闭检锁。        
是一个并发构造，它允许一个或多个线程等待一系列制定操作的完成。        
CountDownLatch 以一个给定的数量初始化。countDown()每被调用一次，这一数量就减一。
通过调用await()方法之一，线程可以阻塞等待这一数量到达零。                                
CountDownLatchDemo1                                
public class CountDownLatchDemo1{                                
public static void main(String[] args){                                
CountDownLatch cdl = new CountDownLatch(3);                                
new Thread(new T3(cdl)).Start();                                
new Thread(new T4(cdl)).Start();                                
new Thread(new T5(cdl)).Start();    
cdl.await();//await方法将会产生阻塞，直到cdl中数字被递减为0才会释放阻塞
//以前没有CountDownLatch时候用线程通信操作先买后做饭，现在用CountDownLatch之后简单很多
System.out.println("开始做饭~~~");                                
}                               
/*买菜*/                                
class T3 implements Runnable{                                
private CountDownLatch cdl=null;                                
public T3(CountDownLatch cdl) {                                
this.cdl = cdl;                                
}                                
@Override                                
public void run(){                                
try{                                
Thread.sleep(3000);                                
cdl.countDown();//每被调用一次，数量减一                                
Sysout.out.println("T3买菜回来");                                
} catch(InterruptedException e) {                                
e.printStackTrace();                                
}                                
}}                                  
/*买米*/                                
class T4 implements Runnable{                                
private CountDownLatch cdl=null;                                
public T4(CountDownLatch cdl) {                                
this.cdl = cdl;                                
}                                
@Override                                
public void run(){                                
try{                                
Thread.sleep(4000);                                
cdl.countDown();                                
Sysout.out.println("T4买米回来");                                
} catch(InterruptedException e) {                                
e.printStackTrace();                                
}                                
}}                               
/*买米*/                                
class T5 implements Runnable{                                
private CountDownLatch cdl=null;                                
public T5(CountDownLatch cdl) {                                
this.cdl = cdl;                                
}                                
@Override                                
public void run(){                                
try{                                
Thread.sleep(5000);                                
cdl.countDown();                                
Sysout.out.println("T5买锅回来");                                
} catch(InterruptedException e) {                                
e.printStackTrace();                                
}                                
}}                                
}                                
*CountDownLatch重要                                
CyclicBarrier：栅栏    
java.util.concurrent.CyclicBarrier类是一种机制，它能够对处理一些算法的线程实现
同步。换句话讲，它就是一个所有线程必须等待的一个栅栏，直到所有线程都到达这里，然后    所有线程才可以继续做其它事情。    
CyclicBarrier barry = new CyclicBarrier(3);可以直接new一个对象，指定一个数字代表3个线程
barry.await();线程开始等待
Exchanger：交换机
java.util.concurrent.Exchanger类表示一种两个线程可以进行互相交换对象的会和点。
两个线程要接头，可以两个线程***交换***数据。。作用就是两个线程交换数据
Exchanger exchanger = new Exchanger();可以直接new
exchanger.exchange(data);进行交换    
Semaphore：信号量    
java.util.concurrent.Semaphore类是一个计数信号量，它有两个主要方法：        
acquire(),acquire:获取    
release(),release:释放        
计数信号量是一个指定数量的“许可”初始化，每调用一次acquire(),一个许可会被调用线程取走，没调用一次release()，一个许可会被返还给信号量，因此，在没有任何release()调用时，最多有N个线程能够通过acquire()方法，N是该信号量初始化时的许可的指定数量，这些许可是一个见到那的计数器。
主要有两种功能：
1.保护一个重要（代码）部分防止一次超过N个线程进入。    
2.在两个线程之间发送信号。
可以直接new：Semaphore semaphore = new Semaphore(3);//给三个许可，信号量无法保证公平性。
semaphore.acquire();//拿到许可
semaphore.release();//还回许可
线程之间发送信号：（此处功能与BlockingQueue：阻塞队列类似）    
如果将一个信号量用于在两个线程之间传送信号，通常你应该用一个线程调用acquire()
方法，另一个线程调用release()方法。如果没有可用的许可，acquire()调用将会阻塞，直到一个许可被另一个线程释放出来，同理，如果无法往信号量释放更多许可时，一个release()调用也好阻塞
当Semaphore semaphore = new Semaphore(3,true);传进去一个true信号量回归公平不按照规定拿票