(转)Java 5.0多线程编程（4）
CountDownLatch:
CountDownLatch 是个计数器，它有一个初始数，等待这个计数器的线程必须等到计数器倒数到零时才可继续。比如说一个 Server 启动时需要初始化 4 个部件， Server 可以同时启动 4 个线程去初始化这 4 个部件，然后调用 CountDownLatch(4).await() 阻断进入等待，每个线程完成任务后会调用一次 CountDownLatch.countDown() 来倒计数 , 当 4 个线程都结束时 CountDownLatch 的计数就会降低为 0 ，此时 Server 就会被唤醒继续下一步操作。 CountDownLatch 的方法主要有：
- await() ：使调用此方法的线程阻断进入等待
- countDown(): 倒计数，将计数值减 1
- getCount(): 得到当前的计数值
CountDownLatch 的例子：一个 server 调了三个 ComponentThread 分别去启动三个组件，然后 server 等到组件都启动了再继续。
| public class Server { public static void main(String[] args) throws InterruptedException{ System.out.println("Server is starting."); // 初始化一个初始值为 3 的 CountDownLatch CountDownLatch latch = new CountDownLatch(3); // 起 3 个线程分别去启动 3 个组件 ExecutorService service = Executors.newCachedThreadPool(); service.submit(new ComponentThread(latch, 1)); service.submit(new ComponentThread(latch, 2)); service.submit(new ComponentThread(latch, 3)); service.shutdown(); // 进入等待状态 latch.await(); // 当所需的三个组件都完成时， Server 就可继续了 System.out.println("Server is up!"); } }
public class ComponentThread implements Runnable{ CountDownLatch latch; int ID; /** Creates a new instance of ComponentThread */ public ComponentThread(CountDownLatch latch, int ID) { this.latch = latch; this.ID = ID; } public void run() { System.out.println("Component "+ID + " initialized!"); // 将计数减一 latch.countDown(); } } |
运行结果：
| Server is starting. Component 1 initialized! Component 3 initialized! Component 2 initialized! Server is up!
|
CyclicBarrier:
CyclicBarrier 类似于 CountDownLatch 也是个计数器，不同的是 CyclicBarrier 数的是调用了 CyclicBarrier.await() 进入等待的线程数，当线程数达到了 CyclicBarrier 初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。 CyclicBarrier 就象它名字的意思一样，可看成是个障碍，所有的线程必须到齐后才能一起通过这个障碍。 CyclicBarrier 初始时还可带一个 Runnable 的参数，此 Runnable 任务在 CyclicBarrier 的数目达到后，所有其它线程被唤醒前被执行。
CyclicBarrier 提供以下几个方法：
- await() ：进入等待
- getParties() ：返回此 barrier 需要的线程数
- reset() ：将此 barrier 重置
以下是使用 CyclicBarrier 的一个例子：两个线程分别在一个数组里放一个数，当这两个线程都结束后，主线程算出数组里的数的和（这个例子比较无聊，我没有想到更合适的例子）
| public class MainThread { public static void main(String[] args) throws InterruptedException, BrokenBarrierException, TimeoutException{ final int[] array = new int[2]; CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {// 在所有线程都到达 Barrier 时执行 public void run() { System.out.println("Total is:"+(array[0]+array[1])); } }); // 启动线程 new Thread(new ComponentThread(barrier, array, 0)).start(); new Thread(new ComponentThread(barrier, array, 1)).start(); } }
public class ComponentThread implements Runnable{ CyclicBarrier barrier; int ID; int[] array; public ComponentThread(CyclicBarrier barrier, int[] array, int ID) { this.barrier = barrier; this.ID = ID; this.array = array; } public void run() { try { array[ID] = new Random().nextInt(); System.out.println(ID+ " generates:"+array[ID]); // 该线程完成了任务等在 Barrier 处 barrier.await(); } catch (BrokenBarrierException ex) { ex.printStackTrace(); } catch (InterruptedException ex) { ex.printStackTrace(); } } } |
Exchanger:
顾名思义 Exchanger 让两个线程可以互换信息。用一个例子来解释比较容易。例子中服务生线程往空的杯子里倒水，顾客线程从装满水的杯子里喝水，然后通过 Exchanger 双方互换杯子，服务生接着往空杯子里倒水，顾客接着喝水，然后交换，如此周而复始。
| class FillAndEmpty { // 初始化一个 Exchanger ，并规定可交换的信息类型是 DataCup Exchanger exchanger = new Exchanger(); Cup initialEmptyCup = ...; // 初始化一个空的杯子 Cup initialFullCup = ...; // 初始化一个装满水的杯子 // 服务生线程 class Waiter implements Runnable { public void run() { Cup currentCup = initialEmptyCup; try { // 往空的杯子里加水 currentCup.addWater(); // 杯子满后和顾客的空杯子交换 currentCup = exchanger.exchange(currentCup); } catch (InterruptedException ex) { ... handle ... } } } // 顾客线程 class Customer implements Runnable { public void run() { DataCup currentCup = initialFullCup; try { // 把杯子里的水喝掉 currentCup.drinkFromCup(); // 将空杯子和服务生的满杯子交换 currentCup = exchanger.exchange(currentCup); } catch (InterruptedException ex) { ... handle ...} } }
void start() { new Thread(new Waiter()).start(); new Thread(new Customer()).start(); } } |
6: BlockingQueue接口
BlockingQueue 是一种特殊的 Queue ，若 BlockingQueue 是空的，从 BlockingQueue 取东西的操作将会被阻断进入等待状态直到 BlocingkQueue 进了新货才会被唤醒。同样，如果 BlockingQueue 是满的任何试图往里存东西的操作也会被阻断进入等待状态，直到 BlockingQueue 里有新的空间才会被唤醒继续操作。 BlockingQueue 提供的方法主要有：
- add(anObject): 把 anObject 加到 BlockingQueue 里，如果 BlockingQueue 可以容纳返回 true ，否则抛出 IllegalStateException 异常。
- offer(anObject) ：把 anObject 加到 BlockingQueue 里，如果 BlockingQueue 可以容纳返回 true ，否则返回 false 。
- put(anObject) ：把 anObject 加到 BlockingQueue 里，如果 BlockingQueue 没有空间，调用此方法的线程被阻断直到 BlockingQueue 里有新的空间再继续。
- poll(time) ：取出 BlockingQueue 里排在首位的对象，若不能立即取出可等 time 参数规定的时间。取不到时返回 null 。
- take() ：取出 BlockingQueue 里排在首位的对象，若 BlockingQueue 为空，阻断进入等待状态直到 BlockingQueue 有新的对象被加入为止。
根据不同的需要 BlockingQueue 有 4 种具体实现：
- ArrayBlockingQueue ：规定大小的 BlockingQueue ，其构造函数必须带一个 int 参数来指明其大小。其所含的对象是以 FIFO （先入先出）顺序排序的。
- LinkedBlockingQueue ：大小不定的 BlockingQueue ，若其构造函数带一个规定大小的参数，生成的 BlockingQueue 有大小限制，若不带大小参数，所生成的 BlockingQueue 的大小由 Integer.MAX_VALUE 来决定。其所含的对象是以 FIFO （先入先出）顺序排序的。 LinkedBlockingQueue 和 ArrayBlockingQueue 比较起来，它们背后所用的数据结构不一样，导致 LinkedBlockingQueue 的数据吞吐量要大于 ArrayBlockingQueue ，但在线程数量很大时其性能的可预见性低于 ArrayBlockingQueue 。
- PriorityBlockingQueue ：类似于 LinkedBlockingQueue ，但其所含对象的排序不是 FIFO ，而是依据对象的自然排序顺序或者是构造函数所带的 Comparator 决定的顺序。
- SynchronousQueue ：特殊的 BlockingQueue ，对其的操作必须是放和取交替完成的。
下面是用 BlockingQueue 来实现 Producer 和 Consumer 的例子：
| public class BlockingQueueTest { static BlockingQueue basket; public BlockingQueueTest() { // 定义了一个大小为 2 的 BlockingQueue ，也可根据需要用其他的具体类 basket = new ArrayBlockingQueue (2); } class Producor implements Runnable { public void run() { while(true){ try { // 放入一个对象，若 basket 满了，等到 basket 有位置 basket.put("An apple"); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } class Consumer implements Runnable { public void run() { while(true){ try { // 取出一个对象，若 basket 为空，等到 basket 有东西为止 String result = basket.take(); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } public void execute(){ for(int i=0; i<10; i++){ new Thread(new Producor()).start(); new Thread(new Consumer()).start(); } } public static void main(String[] args){ BlockingQueueTest test = new BlockingQueueTest(); test.execute(); } } |
7：Atomics 原子级变量
原子量级的变量，主要的类有 AtomicBoolean, AtomicInteger, AotmicIntegerArray, AtomicLong, AtomicLongArray, AtomicReference …… 。这些原子量级的变量主要提供两个方法：
- compareAndSet(expectedValue, newValue): 比较当前的值是否等于 expectedValue , 若等于把当前值改成 newValue ，并返回 true 。若不等，返回 false 。
- getAndSet(newValue): 把当前值改为 newValue ，并返回改变前的值。
这些原子级变量利用了现代处理器（ CPU ）的硬件支持可把两步操作合为一步的功能，避免了不必要的锁定，提高了程序的运行效率。
8：Concurrent Collections 共点聚集
在 Java 的聚集框架里可以调用 Collections.synchronizeCollection(aCollection) 将普通聚集改变成同步聚集，使之可用于多线程的环境下。 但同步聚集在一个时刻只允许一个线程访问它，其它想同时访问它的线程会被阻断，导致程序运行效率不高。 Java 5.0 里提供了几个共点聚集类，它们把以前需要几步才能完成的操作合成一个原子量级的操作，这样就可让多个线程同时对聚集进行操作，避免了锁定，从而提高了程序的运行效率。 Java 5.0 目前提供的共点聚集类有： ConcurrentHashMap, ConcurrentLinkedQueue, CopyOnWriteArrayList 和 CopyOnWriteArraySet.