java 利用同步工具类控制线程

---

前言

　　参考来源：《java并发编程实战》

　　 同步工具类：根据工具类的自身状态来协调线程的控制流。通过同步工具类，来协调线程之间的行为。

　　 可见性：在多线程环境下，当某个属性被其他线程修改后，其他线程能够立刻看到修改后的信息。典型的是用java内置关键字volatile，volatile变量可以让jvm知道这个变量是对所有线程共享的，jvm会做一定的同步工作，但不保证原子性。

　　　　　　 这一部分内容可以看一下http://www.cnblogs.com/dolphin0520/p/3920373.html

　　　　　　　　　　　　　　　　　http://www.cnblogs.com/Mainz/p/3556430.html#

　　 发布和逸出：

　　　　　　　　发布：发布一个对象指，使对象能够在当前作用域之外的代码使用。举个栗子就是，对象A持有对象C，把C的引用传递到其他地方，或者外界访问A有非私有方法返回C。发布一个对象时要考虑是否有足够理由发布出去，否则可能会引起同步问题。

　　　　　　　　　　　很明显，同步工具类肯定需要发布给通信双方。

　　　　　　　　逸出：当某个不应该发布的对象被发布时，叫做逸出。

　　线程之间通信，就需要把一个通信协议（某个对象）发布给双方，并且对双方来说都是可见的，这样来协调线程之间的行为。当然如果有特别需要，完全可以自己去写同步工具类。

---

闭锁

　　闭锁，可以使线程等待某个事件（信号）发生后才执行后续操作。闭锁有一个初始值，当初始值为0的时候闭锁终止，所有被该闭锁阻塞的线程都可以继续执行。假设有个线程A，我们想A启动之后需要等待线程B的信号才能继续执行，这时候我们可以把一个闭锁发布给A,B，A等待闭锁的结束，B来结束闭锁，这样A就能等B的命令才能继续执行。事实上，利用闭锁还可以让主线程等待所有子线程结束。有一点要注意的是，闭锁是一次性的，一旦进入终止状态（count==0），就不能被重置。

　　CountDownLatch简单用法介绍：

　　　　public CountDownLatch(int count)；　　构造函数，当count为0的时候，await方法不再阻塞。

　　　　public void countDown()；　　　　　　   使count减1。

　　　　public void await()；　　　　　　　　　　使当前线程阻塞，直到CountDownLatch的count为0。

　　下面这个例子显示了利用闭锁控制子线程执行和等待所有子线程结束。

 public class TestDownLatch {
     int count = 5;
     //控制子线程执行的闭锁
     final CountDownLatch startGate = new CountDownLatch(1);
     //让主线程等待所有子线程结束
     final CountDownLatch endGate = new CountDownLatch(count);

     //测试线程
     class Task extends Thread{

         int i;

         public Task(int i) {
             this.i = i;
         }

         @Override
         public void run() {
             //等待闭锁的结束
             try {
                 //等待主线程的命令
                 startGate.await();
                 System.out.println(i);
                 //告诉主线程我已经做完了
                 endGate.countDown();
             } catch (InterruptedException igored) {
             }
         }

     }

     public void test(){
         for (int i = 0; i < count; i++) {
             Task task = new Task(i);
             task.start();
         }
         System.out.println("所有线程已开启");
         try {
             Thread.sleep(3000);
             startGate.countDown();
             System.out.println("所有子线程开始输出");

             Thread.sleep(3000);
             endGate.await();
             System.out.println("主线程结束");
         } catch (InterruptedException ignored) {
         }

     }

     public static void main(String[] args) {
         TestDownLatch testDownLatch = new TestDownLatch();
         testDownLatch.test();
     }

 }

闭锁

运行结果：

aaarticlea/png;base64,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" alt="" />

---

FutureTask

　　《java并发编程实战》的翻译者没有翻译这个词，我也只能这么叫它先。FutureTask本身实现Runnable接口和Future接口。

　　 FutureTask相当于一个助手，你把一个任务（有返回结果并且往往比较耗时）交给FutureTask，让它先计算结果，然后你去干别的事，这个助手（FutureTask）会帮你保存结果，等你需要结果时（调用Future#get），如果计算结束了，FutureTask直接把结果给你，如果还没计算完，就让你等待（阻塞），直到计算完了。

　　FutureTask简单用法介绍：

　　　　public FutureTask(Callable<V> callable)；　　构造方法。参数Callable，相当于一种可生成结果的Runnable，相当于上面的任务（带返回结果），V为结果的类型，实现Callable需要实现call（）。

　　　　public V get()；　　　　　　　　　　　　　　  获取Callable返回的结果，如果Callable没执行完，该方法会阻塞当前线程。

　　　　public boolean cancel(boolean mayInterruptIfRunning)；　　　　取消执行

　　　　另外还有isDone(),isCancelled()方法知道FutureTask状态；

以下代码测试FutureTask，先实例化一个FutureTask并自动获取当前时间（一秒的消耗时间），输出当时时间，然后三秒后再去FutureTask拿结果，可以看到两个时间没有三秒间隔，说明FutureTask花费一秒后算好结果就保存起来，等主线程获取结果。

 public class TestFutureTask {

     //任务，返回计算时的时间
     private final FutureTask<Date> future = new FutureTask<Date>(new Callable<Date>() {
         @Override
         public Date call() throws Exception {
             //1秒后再返回结果
             Thread.sleep(1000);
             return new Date();
         }

     });

     public TestFutureTask(){
         new Thread(future).start();
     }

     public Date get() throws InterruptedException, ExecutionException{
         return future.get();
     }

     public static void main(String[] args) {
         try {
             System.out.println(new Date());
             TestFutureTask task = new TestFutureTask();
             System.out.println("等待3秒.............");
             System.out.println(task.get());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }

 }

FutureTask

运行结果：

aaarticlea/png;base64,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" alt="" />

---

信号量

　　计数信号量用来控制同时访问某个特定资源的操作数量。信号量（Semaphore）维护的是一组许可，准确来说，信号量只是维护这组许可的数量。它有一个初始值，根据这个值的大小来决定每次请求许可时的行为，如果用过连接池就很容易明白，连接池里一开始放着一堆连接（Connection），每次从连接池拿出一个Connection，连接池就少一个Connection，每次Connection用完就还给连接池，方便以后的用户使用。这些资源池都拥有一个信号量，来控制资源的出入。同样，使用Semaphore可以将任何一种容器变成有界阻塞容器。

　　

　　Semaphore简单用法介绍：

　　　　public Semaphore(int permits)；　　构造方法。参数premits为初始化信号量大小，当permits为0，获取（调用acquire方法）资源会阻塞，直到permits>0。

　　　　public void acquire() throws InterruptedException；　　　当permits>0时获取许可，permits会减一，否则阻塞直到permits>0。

　　　　public void release()；　　　　　　　　　　　　　　　　　　释放许可，permits加一。

以下代码使用信号量简单模拟连接池，测试让连接池大小为5，然后开六个线程去获取连接，每个线程持有连接3秒，可以看到第六个线程阻塞住，要等有一个线程释放连接才可以获取到连接

 public class Pool {
     private final List<Connection> list;
     private final Semaphore sem;

     public Pool(int initSize) {
         //注意这里
         list = Collections.synchronizedList(new LinkedList<Connection>());
         for (int i = 0; i < initSize; i++) {
             list.add(new Connection());
         }
         sem = new Semaphore(initSize);
     }

     //获取连接
     public Connection get() throws InterruptedException{
         //如果sem当前许可数量为0，阻塞当前线程
         sem.acquire();
         return list.remove(0);

     }

     //释放连接
     public void release(Connection resource) throws InterruptedException{
         sem.release();
         list.add(resource);

     }

     public static void main(String[] args) {
         final Pool pool = new Pool(5);

         for (int i = 0; i < 6; i++) {
             pool.new TestSemaphore(i, pool).start();
         }
     }

     public class TestSemaphore extends Thread{

         final int i;
         final Pool pool;

         public TestSemaphore(int i,Pool pool) {
             this.i = i;
             this.pool = pool;
         }

         @Override
         public void run() {
             try {
                 Connection conn = pool.get();
                 System.out.println(i+"成功获取资源并占用三秒!");
                 Thread.sleep(3000);
                 pool.release(conn);
                 System.out.println(i+"已释放资源!!!");
             } catch (InterruptedException e) {
                 System.out.println(i+"获取资源失败----");
             }
         }
     }

 }

信号量

运行结果：

aaarticlea/png;base64,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" alt="" />

　　特别注意：Pool的构造方法用Collections.synchronizedList方法使保存连接的list变成线程安全，在调用list的方法时会自动加锁，但是如果用迭代器访问list的时候需要手动加锁，这一点在Collections的API文档有特别说明。

---

栅栏

　　栅栏跟闭锁很像，先说栅栏的作用——阻塞一组线程直到某个事件发生。闭锁和栅栏的最大区别就是，栅栏可以让所有线程必须同时到达栅栏位置，才能继续执行，闭锁最多做到线程执行到阻塞的位置必须等待闭锁的终止，而无法保证线程等待其他线程的执行。栅栏就像赛马的那个栏（我也不知道叫什么），所有马到了起点，栅栏一开，所有马都开始跑，闭锁是没办法知道所有马都到达栅栏处的。

　　CyclicBarrier简单用法介绍：

　　　　public CyclicBarrier(int parties, Runnable barrierAction)；　　构造方法。parties指一共有多少个线程，barrierAction就是所有线程通过栅栏的时回调函数。

　　　　public int await() throws InterruptedException, BrokenBarrierException；　　当前线程等待其他所有线程到达（也是等待栅栏打开）。

　　　　CyclicBarrier是指可以循环使用的栅栏，每次栅栏打开后都能重置以便下次使用。但是如果对await的调用超时，或者await阻塞的线程被中断，栅栏被认为是打破，所有阻塞的await调用都抛出BrokenBarrierException。

以下代码用栅栏使所有五个召唤师都到达战场后游戏开始，从开始连接到全军出击的时间差应该是五个召唤师最慢那个，就是LOL时半天进度条也没100的那个。虽然我戒撸很久了= =

 public class TestBarrier {
     private final CyclicBarrier barrier;

     public TestBarrier() {
         this.barrier = new CyclicBarrier(5, new Runnable() {
             @Override
             public void run() {
                 System.out.println(new Date()+"...全军出击!");
             }
         });
     }

     public void start(){
         System.out.println(new Date()+"开始连接-----");
         new Summoner(1,3).start();
         new Summoner(2,1).start();
         new Summoner(3,5).start();
         new Summoner(4,6).start();
         new Summoner(5,1).start();
     }

     public class Summoner extends Thread{

         int i;
         int preSecond;

         public Summoner(int i,int preSecond) {
             this.i = i;
             this.preSecond = preSecond;
         }

         @Override
         public void run() {
             try {
                 System.out.println("召唤师"+i+"需要"+preSecond+"秒到达战场");
                 Thread.sleep(preSecond*1000);
                 barrier.await();
                 System.out.println("------------ 召唤师"+i+":"+new Date());
             } catch (InterruptedException | BrokenBarrierException e) {
                 e.printStackTrace();
             }
         }

     }

     public static void main(String[] args) {
         new TestBarrier().start();
     }

 }

栅栏

运行结果：

aaarticlea/png;base64,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" alt="" />

---

小结

　　闭锁：当你的线程需要等待一个命令的时候可以用它。

　　FutureTask：当你有个耗时的过程想利用并行来提高效率，可以用FutureTask。

　　信号量：当你在多线程环境下想控制有限资源的访问，使一个容器变成有界阻塞容器，可以考虑信号量。

　　栅栏：当你的多个线程需要共同完成某些步骤才可以继续执行，例如子问题结果合并，可以使用栅栏。

---