Java中提供多种方式协调线程的工作。
CountDownLatch：当多个也就是具体的数量等于CountDownLatch初始化参数的时候。线程达到了预期状态或者完成了预期工作时触发事件，其他线程可以等待这个事件来触发自己的后续工作。等待的线程是多个。达到了预期状态的线程会调用CountDownLatch的countDown方法。等待的线程会调用CountDownLatch的await方法。
import java.util.concurrent.CountDownLatch;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class CountDownLatchDemo {static ThreadPoolExecutor tp = new ThreadPoolExecutor(1, 1, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(5) );public static void main(String[] args) throws InterruptedException {int count = 10;final CountDownLatch latch = new CountDownLatch(count);int[] datas = new int[10240];int step = datas.length / count;for (int i=0; i<count; i++) {int start = i * step;int end = (i+1) * step;if (i == count -1)end = datas.length;tp.execute(new MyRunable(latch, datas, start, end));}latch.await();}}import java.util.concurrent.CountDownLatch;public class MyRunable implements Runnable {CountDownLatch latch;int[] datas; int start; int end;public CountDownLatch getLatch() {return latch;}public void setLatch(CountDownLatch latch) {this.latch = latch;}public int[] getDatas() {return datas;}public void setDatas(int[] datas) {this.datas = datas;}public int getStart() {return start;}public void setStart(int start) {this.start = start;}public int getEnd() {return end;}public void setEnd(int end) {this.end = end;}public MyRunable(CountDownLatch latch, int[] datas, int start, int end) {this.latch = latch;this.datas = datas;this.start = start;this.end = end;}@Overridepublic void run() {latch.countDown();}}
CyclicBarrier是指循环屏障。它可以协同多个线程，让多个线程在这个屏障前等待。直到所有的线程都达到了这个屏障，，再一起继续执行后面的工作。
import java.util.concurrent.BrokenBarrierException;import java.util.concurrent.CyclicBarrier;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class CyclicBarrierDemo {static ThreadPoolExecutor tp = new ThreadPoolExecutor(1, 1, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(5) );public static void main(String[] args) throws InterruptedException {int count = 10;final CyclicBarrier latch = new CyclicBarrier(count);int[] datas = new int[10240];int step = datas.length / count;for (int i=0; i<count; i++) {int start = i * step;int end = (i+1) * step;if (i == count -1)end = datas.length;tp.execute(new MyRunable1(latch, datas, start, end));}try {latch.await();} catch (BrokenBarrierException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
CyclicBarrier与CountDownLatch都用于线程之间的协调。两者之间的差别在于，CountDownLatch是在多个线程都进行了latch.countDown方法后，才会触发事件，唤醒await在latch上的线程。而执行countDown的线程，行完countDown后会继续自己的线程工作。CyclicBarrier用于同步所有调用await方法的线程，并且等待所有线程都到await方法时，这些线程才继续各自的工作。
Exchanger
不同线程之间的数据交换用Exchanger。当一个线程的方法执行调用exchanger.exchange的时候，会等待其他线程也执行到调用这个方法。然后交换彼此之间的数据
import java.util.ArrayList;import java.util.List;import java.util.concurrent.Exchanger;public class ExchangerDemo {public static void main(String[] args) {final Exchanger<List<Integer>> exchanger = new Exchanger<List<Integer>>();new Thread(){public void run(){List<Integer> list = new ArrayList<Integer>(2);list.add(1);list.add(2);try {list = exchanger.exchange(list);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("thread1:" + list);}}.start();new Thread(){public void run(){List<Integer> list = new ArrayList<Integer>(3);list.add(3);list.add(4);list.add(5);try {list = exchanger.exchange(list);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("thread2:" + list);}}.start();}}
一直觉得人应该去旅行，在年轻的时候，趁着有脾气装潇洒，
