一、交换器

    交换器提供了一个线程之间能够交换对象的同步点。每个线程都会往这个

交换器的exchange()方法传入一些对象，匹配伙伴线程，同时接受伙伴对象作为返

回值。java.util.conurrent.Exchange<V>实现了交换器。

    下面是一个代码小实例：

import java.util.concurrent.Exchanger;  import java.util.concurrent.ExecutorService;  import java.util.concurrent.Executors;    public class ExchangerTest {        public static void main(String[] args) {          ExecutorService service = Executors.newCachedThreadPool();          final Exchanger exchanger = new Exchanger();          service.execute(new Runnable(){              public void run() {                  try {                                       String data1 = "zxx";                      System.out.println("线程" + Thread.currentThread().getName() +                       "正在把数据" + data1 +"换出去");                      Thread.sleep((long)(Math.random()*10000));                      String data2 = (String)exchanger.exchange(data1);                      System.out.println("线程" + Thread.currentThread().getName() +                       "换回的数据为" + data2);                  }catch(Exception e){                                        }              }             });          service.execute(new Runnable(){              public void run() {                  try {                                       String data1 = "lhm";                      System.out.println("线程" + Thread.currentThread().getName() +                       "正在把数据" + data1 +"换出去");                      Thread.sleep((long)(Math.random()*10000));                                        String data2 = (String)exchanger.exchange(data1);                      System.out.println("线程" + Thread.currentThread().getName() +                       "换回的数据为" + data2);                  }catch(Exception e){                                        }                             }             });           }  }

二、信号量

    信号量维护了一组许可证，以约束访问被限制资源的线程数。当没有可用

的许可证时，线程的获取尝试会一直阻塞，直到其它的线程释放一个许可证。

    java.util.concurrent.Semaphor实现了这一同步器，同时将信号量概念化成一个

维护一组许可证的对象。他有两个构造器：

    Semaphore(int permits)

     Semaphore(int permits,boolean fair)

permits指定了许可证的数量，fair是是否设置公平策略，当设置为 false 时，此类不对线

程获取许可的顺序做任何保证。特别地，闯入 是允许的，也就是说可以在已经等待的线程前

为调用 acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列

的头部。当公平设置为 true 时，信号量保证对于任何调用获取方法的线程而言，都按照处

理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。

示例代码：

// 创建信号量对象，并给予3个资源Semaphore semaphore = new Semaphore(3);// 开启10条线程for ( int i=0; i<10; i++ ) {    new Thread( new Runnbale(){        public void run(){            // 获取资源，若此时资源被用光，则阻塞，直到有线程归还资源            semaphore.acquire();            // 任务代码            ……            // 释放资源            semaphore.release();        }    } ).start();}