java中常用的并发工具

java中常用的并发工具

1）闭锁CountDownLatch 
	
	功能：让一个主线程等待一组工作线程执行完毕之后，才继续执行主线程，与join()方法的功能类似。
	
	原理：
		1)CountDownLatch是通过一个计数器来实现的，计数器的初始值为需要等待线程的数量。eg：CountDownLatch c = new CountDownLatch(2); // 等待线程的数量为2
		2)主线程调用CountDownLatch的await()方法会阻塞当前线程(即:主线程在闭锁上等待)，直到计数器的值为0。
		3)当一个工作线程完成了自己的任务后，调用CountDownLatch的countDown()方法，计数器的值就会减1。
		4)当计数器值为0时，说明所有的工作线程都执行完了，此时，在闭锁上等待的主线程就可以恢复执行任务。

	注意：
		1)countDown()可以在每个线程中调用一次，也可以在一个线程中调用多次。
		2)一个线程调用countDown()方法happen-before另外一个线程调用await()方法，即countDown()方法执行的结果对await()方法可见。
	

2）屏障(栅栏)CyclicBarrier

	功能：让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门(trip)，所有被屏障拦截的线程才会继续运行。

	原理：
		1)CyclicBarrier是通过一个计数器来实现的，计数器的初始值为需要等待线程的数量。eg：CyclicBarrier c = new CyclicBarrier(2); // 等待线程的数量为2
		2)每个线程调用CyclicBarrier的await()方法，使自己进入等待状态。
		3)当所有的线程都调用了CyclicBarrier的await()方法后，所有的线程停止等待，继续运行。
	
	CyclicBarrier和CountDownLatch的区别：
	
		1)CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。
		2)到达某个点后，使用CountDownLatch的线程继续运行，使用CyclicBarrier的线程停止运行：
			使用CountDownLatch的线程运行到某个点之后，调用 countDown() 方法将计数器的值减1，之后线程继续执行。
			使用CyclicBarrier 的线程运行到某个点之后，调用 await()	   方法使该线程停止运行，直到所有的线程都到达了这个点(调用await方法)，(所有的)线程才可以继续运行。


3）信号量Semaphore

	功能：控制并发的线程数。

	原理：
		1)Semaphore是通过一个计数器(记录许可证的数量)来实现的，计数器的初始值为需要等待线程的数量。eg：Semaphore s = new Semaphore(10); // 线程最大的并发数为10
		2)线程通过acquire()方法获取许可证(计数器的值减1)，只有获取到许可证才可以继续执行下去，否则阻塞当前线程。
		3)线程通过release()方法归还许可证(计数器的值加1)。

	说明：使用tryAcquire()方法可以立即得到执行的结果：尝试获取一个许可证，若获取成功，则立即返回true，若获取失败，则立即返回false。
		
	应用：流量控制，例如数据库连接数的控制等。
	

4）交换者Exchanger

	功能：两个线程间数据的交换。
	
	原理：
		1)线程A调用public V exchange(V dataA)方法，线程A到达同步点，并且在线程B到达同步点前一直等待。
		2)线程B调用public V exchange(V dataB)方法，线程B到达同步点。
		3)线程A与线程B都达到同步点时，线程将自己的数据传递给对方，两个线程完成了数据的交换了。
		
	 举例：
		public class ExchangerTest {
			public static void main(String[] args) {
				
				final Exchanger<String> exchanger = new Exchanger<String>();
				
				ExecutorService service = Executors.newFixedThreadPool(2);

				service.execute(new Runnable() {
					public void run() {
						try {
							String originalData = "dataA";
							Thread.sleep(2000);
							System.out.println("线程" + Thread.currentThread().getName() + "正在把数据[" + originalData + "]传递出去..." + "	time:" + System.currentTimeMillis());
							String exchangedData = exchanger.exchange(originalData);
							System.out.println("线程" + Thread.currentThread().getName() + "获取到另一线程的数据[" + exchangedData + "]" + "	time:" + System.currentTimeMillis());
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				});

				service.execute(new Runnable() {
					public void run() {
						try {
							String originalData = "dataB";
							Thread.sleep(6000);
							System.out.println("线程" + Thread.currentThread().getName() + "正在把数据[" + originalData + "]传递出去..." + "	time:" + System.currentTimeMillis());
							String exchangedData = exchanger.exchange(originalData);
							System.out.println("线程" + Thread.currentThread().getName() + "获取到另一线程的数据[" + exchangedData + "]" + "	time:" + System.currentTimeMillis());
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				});
			}
		}
		
		结果：
			线程pool-1-thread-1正在把数据[dataA]传递出去...	time:1506414528645
			线程pool-1-thread-2正在把数据[dataB]传递出去...	time:1506414532645
			线程pool-1-thread-2获取到另一线程的数据[dataA]	time:1506414532645
			线程pool-1-thread-1获取到另一线程的数据[dataB]	time:1506414532645