java线程安全

为一个Java web开发人员，很少也不需要去处理线程，因为服务器已经帮我们处理好了。记得大一刚学Java的时候，老师带着我们做了一个局域网聊天室，用到了AWT、Socket、多线程、I/O，编写的客户端和服务器，当时做出来很兴奋，回学校给同学们演示，感觉自己好NB，呵呵，扯远了。上次在百度开发者大会上看到一个提示语，自己写的代码，6个月不看也是别人的代码，自己学的知识也同样如此，学完的知识如果不使用或者不常常回顾，那么还不是自己的知识。大学零零散散搞了不到四年的Java，我相信很多人都跟我一样，JavaSE基础没打牢，就急忙忙、兴冲冲的搞JavaEE了，然后学习一下前台开发(html、css、javascript)，有可能还搞搞jquery、extjs，再然后是Struts、hibernate、spring，然后听说找工作得会linux、oracle，又去学，在这个过程中，是否迷失了，虽然学习面很广，但就像《神雕侠侣》中黄药师评价杨过，博而不精、杂而不纯，这一串下来，感觉做Java开发好难，并不是学着难，而是知识面太广了，又要精通这个，又要精通那个，这只是我迷茫时候的想法，现在我已经找到方向了。

        回归正题，当我们查看JDK API的时候，总会发现一些类说明写着，线程安全或者线程不安全，比如说StringBuilder中，有这么一句，“将StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer。 ”，那么下面手动创建一个线程不安全的类，然后在多线程中使用这个类，看看有什么效果。

        Count.java：

 public class Count {
     private int num;
     public void count() {
         for(int i = 1; i <= 10; i++) {
             num += i;
         }
         System.out.println(Thread.currentThread().getName() + "-" + num);
     }
 }

        在这个类中的count方法是计算1一直加到10的和，并输出当前线程名和总和，我们期望的是每个线程都会输出55。

        ThreadTest.java：

 public class ThreadTest {
     public static void main(String[] args) {
         Runnable runnable = new Runnable() {
             Count count = new Count();
             public void run() {
                 count.count();
             }
         };
         for(int i = 0; i < 10; i++) {
             new Thread(runnable).start();
         }
     }
 }

        这里启动了10个线程，看一下输出结果：

 Thread-0-55
 Thread-1-110
 Thread-2-165
 Thread-4-220
 Thread-5-275
 Thread-6-330
 Thread-3-385
 Thread-7-440
 Thread-8-495
 Thread-9-550

        只有Thread-0线程输出的结果是我们期望的，而输出的是每次都累加的，这里累加的原因以后的博文会说明，那么要想得到我们期望的结果，有几种解决方案：

        1. 将Count中num变成count方法的局部变量；

 public class Count {
     public void count() {
         int num = 0;
         for(int i = 1; i <= 10; i++) {
             num += i;
         }
         System.out.println(Thread.currentThread().getName() + "-" + num);
     }
 }

        2. 将线程类成员变量拿到run方法中；

 public class ThreadTest4 {
     public static void main(String[] args) {
         Runnable runnable = new Runnable() {
             public void run() {
                 Count count = new Count();
                 count.count();
             }
         };
         for(int i = 0; i < 10; i++) {
             new Thread(runnable).start();
         }
     }
 }

        3. 每次启动一个线程使用不同的线程类，不推荐。
        上述测试，我们发现，存在成员变量的类用于多线程时是不安全的，而变量定义在方法内是线程安全的。想想在使用struts1时，不推荐创建成员变量，因为action是单例的，如果创建了成员变量，就会存在线程不安全的隐患，而struts2是每一次请求都会创建一个action，就不用考虑线程安全的问题。

上篇通过一个简单的例子说明了线程安全与不安全，在例子中不安全的情况下输出的结果恰好是逐个递增的，为什么会产生这样的结果呢，因为建立的Count对象是线程共享的，一个线程改变了其成员变量num值，下一个线程正巧读到了修改后的num，所以会递增输出。

        要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现。拿上篇博文中的例子来说明，在多个线程之间共享了Count类的一个对象，这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程栈)，工作内存存储了主内存Count对象的一个副本，当线程操作Count对象时，首先从主内存复制Count对象到工作内存中，然后执行代码count.count()，改变了num值，最后用工作内存Count刷新主内存Count。当一个对象在多个内存中都存在副本时，如果一个内存修改了共享变量，其它线程也应该能够看到被修改后的值，此为可见性。由上述可知，一个运算赋值操作并不是一个原子性操作，多个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行账户存款100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇款，A从出内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后取款，此为有序性。

        下面同样用代码来展示一下线程同步问题。

        TraditionalThreadSynchronized.java：创建两个线程，执行同一个对象的输出方法。

 public class TraditionalThreadSynchronized {
     public static void main(String[] args) {
         final Outputter output = new Outputter();
         new Thread() {
             public void run() {
                 output.output("zhangsan");
             };
         }.start();
         new Thread() {
             public void run() {
                 output.output("lisi");
             };
         }.start();
     }
 }
 class Outputter {
     public void output(String name) {
         // TODO 为了保证对name的输出不是一个原子操作，这里逐个输出name的每个字符
         for(int i = 0; i < name.length(); i++) {
             System.out.print(name.charAt(i));
         }
     }
 }

        运行结果：

 zhlainsigsan

        显然输出的字符串被打乱了，我们期望的输出结果是zhangsanlisi，这就是线程同步问题，我们希望output方法被一个线程完整的执行完之后在切换到下一个线程，Java中使用synchronized保证一段代码在多线程执行时是互斥的，有两种用法：

        1. 使用synchronized将需要互斥的代码包含起来，并上一把锁。

 synchronized (this) {
     for(int i = 0; i < name.length(); i++) {
         System.out.print(name.charAt(i));
     }
 }

        这把锁必须是线程间的共享对象，像下面的代码是没有意义的。

 Object lock = new Object();
 synchronized (lock) {
     for(int i = 0; i < name.length(); i++) {
         System.out.print(name.charAt(i));
     }
 }

        每次进入output方法都会创建一个新的lock，这个锁显然每个线程都会创建，没有意义。

        2. 将synchronized加在需要互斥的方法上。

 public synchronized void output(String name) {
     // TODO 线程输出方法
     for(int i = 0; i < name.length(); i++) {
         System.out.print(name.charAt(i));
     }
 }

        这种方式就相当于用this锁住整个方法内的代码块，如果用synchronized加在静态方法上，就相当于用××××.class锁住整个方法内的代码块。使用synchronized在某些情况下会造成死锁，死锁问题以后会说明。

        每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个线程被唤醒(notify)后，才会进入到就绪队列，等待CPU的调度，反之，当一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒，这个涉及到线程间的通信，下一篇博文会说明。看我们的例子，当地一个线程执行输出方法时，获得同步锁，执行输出方法，恰好此时第二个线程也要执行输出方法，但发现同步锁没有被释放，第二个线程就会进入就绪队列，等待锁被释放。一个线程执行互斥代码过程如下：

        1. 获得同步锁；

        2. 清空工作内存；

        3. 从主内存拷贝对象副本到工作内存；

        4. 执行代码(计算或者输出等)；

        5. 刷新主内存数据；

        6. 释放同步锁。

        所以，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

        volatile是第二种Java多线程同步的手段，根据JLS的说法，一个变量可以被volatile修饰，在这种情况下内存模型确保所有线程可以看到一致的变量值，来看一段代码：

 class Test {
     static int i = 0, j = 0;
     static void one() {
         i++;
         j++;
     }
     static void two() {
         System.out.println("i=" + i + " j=" + j);
     }
 }

        一些线程执行one方法，另一些线程执行two方法，two方法有可能打印出j比i大的值，按照之前分析的线程执行过程分析一下：

        1. 将变量i从主内存拷贝到工作内存；

        2. 改变i的值；

        3. 刷新主内存数据；

        4. 将变量j从主内存拷贝到工作内存；

        5. 改变j的值；

        6. 刷新主内存数据；

        这个时候执行two方法的线程先读取了主存i原来的值又读取了j改变后的值，这就导致了程序的输出不是我们预期的结果，那么可以在共享变量之前加上volatile。

 class Test {
     static volatile int i = 0, j = 0;
     static void one() {
         i++;
         j++;
     }
     static void two() {
         System.out.println("i=" + i + " j=" + j);
     }
 }

        加上volatile可以将共享变量i和j的改变直接响应到主内存中，这样保证了i和j的值可以保持一致，然而我们不能保证执行two方法的线程是在i和j执行到什么程度获取到的，所以volatile可以保证内存可见性，不能保证并发有序性。           

上一篇讲述了线程的互斥(同步)，但是在很多情况下，仅仅同步是不够的，还需要线程与线程协作(通信)，生产者/消费者模式是一个经典的线程同步以及通信的模型。

        假设有这样一种情况，有一个盘子，盘子里只能放一个鸡蛋，A线程专门往盘子里放鸡蛋，如果盘子里有鸡蛋，则一直等到盘子里没鸡蛋，B线程专门从盘子里取鸡蛋，如果盘子里没鸡蛋，则一直等到盘子里有鸡蛋。这里盘子是一个互斥区，每次放鸡蛋是互斥的，每次取鸡蛋也是互斥的，A线程放鸡蛋，如果这时B线程要取鸡蛋，由于A没有释放锁，B线程处于等待状态，进入阻塞队列，放鸡蛋之后，要通知B线程取鸡蛋，B线程进入就绪队列，反过来，B线程取鸡蛋，如果A线程要放鸡蛋，由于B线程没有释放锁，A线程处于等待状态，进入阻塞队列，取鸡蛋之后，要通知A线程放鸡蛋，A线程进入就绪队列。我们希望当盘子里有鸡蛋时，A线程阻塞，B线程就绪，盘子里没鸡蛋时，A线程就绪，B线程阻塞，代码如下：

 import java.util.ArrayList;
 import java.util.List;
 /** 定义一个盘子类，可以放鸡蛋和取鸡蛋 */
 public class Plate {
     /** 装鸡蛋的盘子 */
     List<Object> eggs = new ArrayList<Object>();
     /** 取鸡蛋 */
     public synchronized Object getEgg() {
         while (eggs.size() == 0) {
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         Object egg = eggs.get(0);
         eggs.clear();// 清空盘子
         notify();// 唤醒阻塞队列的某线程到就绪队列
         System.out.println("拿到鸡蛋");
         return egg;
     }
     /** 放鸡蛋 */
     public synchronized void putEgg(Object egg) {
         while (eggs.size() > 0) {
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         eggs.add(egg);// 往盘子里放鸡蛋
         notify();// 唤醒阻塞队列的某线程到就绪队列
         System.out.println("放入鸡蛋");
     }
     static class AddThread extends Thread {
         private Plate plate;
         private Object egg = new Object();
         public AddThread(Plate plate) {
             this.plate = plate;
         }
         public void run() {
             plate.putEgg(egg);
         }
     }
     static class GetThread extends Thread {
         private Plate plate;
         public GetThread(Plate plate) {
             this.plate = plate;
         }
         public void run() {
             plate.getEgg();
         }
     }
     public static void main(String args[]) {
         Plate plate = new Plate();
         for(int i = 0; i < 10; i++) {
             new Thread(new AddThread(plate)).start();
             new Thread(new GetThread(plate)).start();
         }
     }
 }

        输出结果：

 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋
 放入鸡蛋
 拿到鸡蛋

        8 l程序开始，A线程判断盘子是否为空，放入一个鸡蛋，并且唤醒在阻塞队列的一个线程，阻塞队列为空；假设CPU又调度了一个A线程，盘子非空，执行等待，这个A线程进入阻塞队列；然后一个B线程执行，盘子非空，取走鸡蛋，并唤醒阻塞队列的A线程，A线程进入就绪队列，此时就绪队列就一个A线程，马上执行，放入鸡蛋；如果再来A线程重复第一步，在来B线程重复第二步，整个过程就是生产者(A线程)生产鸡蛋，消费者(B线程)消费鸡蛋。

        前段时间看了张孝祥老师线程的视频，讲述了一个其学员的面试题，也是线程通信的，在此也分享一下。

        题目：子线程循环10次，主线程循环100次，如此循环100次，好像是空中网的笔试题。

 public class ThreadTest2 {
     public static void main(String[] args) {
         final Business business = new Business();
         new Thread(new Runnable() {
             @Override
             public void run() {
                 threadExecute(business, "sub");
             }
         }).start();
         threadExecute(business, "main");
     }
     public static void threadExecute(Business business, String threadType) {
         for(int i = 0; i < 100; i++) {
             try {
                 if("main".equals(threadType)) {
                     business.main(i);
                 } else {
                     business.sub(i);
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 class Business {
     private boolean bool = true;
     public synchronized void main(int loop) throws InterruptedException {
         while(bool) {
             this.wait();
         }
         for(int i = 0; i < 100; i++) {
             System.out.println("main thread seq of " + i + ", loop of " + loop);
         }
         bool = true;
         this.notify();
     }
     public synchronized void sub(int loop) throws InterruptedException {
         while(!bool) {
             this.wait();
         }
         for(int i = 0; i < 10; i++) {
             System.out.println("sub thread seq of " + i + ", loop of " + loop);
         }
         bool = false;
         this.notify();
     }
 }

        大家注意到没有，在调用wait方法时，都是用while判断条件的，而不是if，在wait方法说明中，也推荐使用while，因为在某些特定的情况下，线程有可能被假唤醒，使用while会循环检测更稳妥。

  Timer和TimerTask可以做为实现线程的第三种方式，前两中方式分别是继承自Thread类和实现Runnable接口。

        Timer是一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行，可以看成一个定时器，可以调度TimerTask。TimerTask是一个抽象类，实现了Runnable接口，所以具备了多线程的能力。

        一个Timer可以调度任意多个TimerTask，它会将TimerTask存储在一个队列中，顺序调度，如果想两个TimerTask并发执行，则需要创建两个Timer。下面来看一个简单的例子：        

 import java.util.Timer;
 import java.util.TimerTask;
 public class TimerTest {
     static class MyTimerTask1 extends TimerTask {
         public void run() {
             System.out.println("爆炸！！！");
         }
     }
     public static void main(String[] args) {
         Timer timer = new Timer();
         timer.schedule(new MyTimerTask1(), 2000);// 两秒后启动任务
     }
 }

        schedule是Timer调度任务的方法，Timer重构了四个schedule方法，具体可以查看JDK API。

        看一个稍复杂的例子，假设有这样一种需求，实现一个连环炸弹，2秒后爆炸一次，3秒后爆炸一次，如此循环下去，这就需要创建两个任务，互相调度，代码如下：

 import java.util.Date;
 import java.util.Timer;
 import java.util.TimerTask;
 public class TimerTest {
     static class MyTimerTask1 extends TimerTask {
         public void run() {
             System.out.println("爆炸！！！");
             new Timer().schedule(new MyTimerTask2(), 2000);
         }
     }
     static class MyTimerTask2 extends TimerTask {
         public void run() {
             System.out.println("爆炸！！！");
             new Timer().schedule(new MyTimerTask1(), 3000);
         }
     }
     public static void main(String[] args) {
         Timer timer = new Timer();
         timer.schedule(new MyTimerTask2(), 2000);
         while(true) {
             System.out.println(new Date().getSeconds());
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
     }
 }

 自JDK5之后，Java推出了一个并发包，java.util.concurrent，在Java开发中，我们接触到了好多池的技术，String类的对象池、Integer的共享池、连接数据库的连接池、Struts1.3的对象池等等，池的最终目的都是节约资源，以更小的开销做更多的事情，从而提高性能。

        我们的web项目都是部署在服务器上，浏览器端的每一个request就是一个线程，那么服务器需要并发的处理多个请求，就需要线程池技术，下面来看一下Java并发包下如何创建线程池。

        1.  创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程。

 ExecutorService threadPool = Executors.newFixedThreadPool(3);// 创建可以容纳3个线程的线程池

        2. 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

 ExecutorService threadPool = Executors.newCachedThreadPool();// 线程池的大小会根据执行的任务数动态分配

        3. 创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。

 ExecutorService threadPool = Executors.newSingleThreadExecutor();<pre name="code" class="java">// 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务

        4. 创建一个可安排在给定延迟后运行命令或者定期地执行的线程池。

 ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器

        每种线程池都有不同的使用场景，下面看一下这四种线程池使用起来有什么不同。

        1. FixedThreadPool

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 public class ThreadPoolTest {
     public static void main(String[] args) {
         ExecutorService threadPool = Executors.newFixedThreadPool(3);
         for(int i = 1; i < 5; i++) {
             final int taskID = i;
             threadPool.execute(new Runnable() {
                 public void run() {
                     for(int i = 1; i < 5; i++) {
                         try {
                             Thread.sleep(20);// 为了测试出效果，让每次任务执行都需要一定时间
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                         System.out.println("第" + taskID + "次任务的第" + i + "次执行");
                     }
                 }
             });
         }
         threadPool.shutdown();// 任务执行完毕，关闭线程池
     }
 }

        输出结果：

 第1次任务的第1次执行
 第2次任务的第1次执行
 第3次任务的第1次执行
 第2次任务的第2次执行
 第3次任务的第2次执行
 第1次任务的第2次执行
 第3次任务的第3次执行
 第1次任务的第3次执行
 第2次任务的第3次执行
 第3次任务的第4次执行
 第2次任务的第4次执行
 第1次任务的第4次执行
 第4次任务的第1次执行
 第4次任务的第2次执行
 第4次任务的第3次执行
 第4次任务的第4次执行

        上段代码中，创建了一个固定大小的线程池，容量为3，然后循环执行了4个任务，由输出结果可以看到，前3个任务首先执行完，然后空闲下来的线程去执行第4个任务，在FixedThreadPool中，有一个固定大小的池，如果当前需要执行的任务超过了池大小，那么多于的任务等待状态，直到有空闲下来的线程执行任务，而当执行的任务小于池大小，空闲的线程也不会去销毁。
        2. CachedThreadPool

        上段代码其它地方不变，将newFixedThreadPool方法换成newCachedThreadPool方法。

        输出结果：

 第3次任务的第1次执行
 第4次任务的第1次执行
 第1次任务的第1次执行
 第2次任务的第1次执行
 第4次任务的第2次执行
 第3次任务的第2次执行
 第2次任务的第2次执行
 第1次任务的第2次执行
 第2次任务的第3次执行
 第3次任务的第3次执行
 第1次任务的第3次执行
 第4次任务的第3次执行
 第2次任务的第4次执行
 第4次任务的第4次执行
 第3次任务的第4次执行
 第1次任务的第4次执行

        可见，4个任务是交替执行的，CachedThreadPool会创建一个缓存区，将初始化的线程缓存起来，如果线程有可用的，就使用之前创建好的线程，如果没有可用的，就新创建线程，终止并且从缓存中移除已有60秒未被使用的线程。

        3. SingleThreadExecutor        上段代码其它地方不变，将newFixedThreadPool方法换成newSingleThreadExecutor方法。        输出结果：

 第1次任务的第1次执行
 第1次任务的第2次执行
 第1次任务的第3次执行
 第1次任务的第4次执行
 第2次任务的第1次执行
 第2次任务的第2次执行
 第2次任务的第3次执行
 第2次任务的第4次执行
 第3次任务的第1次执行
 第3次任务的第2次执行
 第3次任务的第3次执行
 第3次任务的第4次执行
 第4次任务的第1次执行
 第4次任务的第2次执行
 第4次任务的第3次执行
 第4次任务的第4次执行

        4个任务是顺序执行的，SingleThreadExecutor得到的是一个单个的线程，这个线程会保证你的任务执行完成，如果当前线程意外终止，会创建一个新线程继续执行任务，这和我们直接创建线程 不同，也和newFixedThreadPool(1)不同。

    4.ScheduledThreadPool    

 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 public class ThreadPoolTest {
     public static void main(String[] args) {
         ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1);
         // 5秒后执行任务
         schedulePool.schedule(new Runnable() {
             public void run() {
                 System.out.println("爆炸");
             }
         }, 5, TimeUnit.SECONDS);
         // 5秒后执行任务，以后每2秒执行一次
         schedulePool.scheduleAtFixedRate(new Runnable() {
             @Override
             public void run() {
                 System.out.println("爆炸");
             }
         }, 5, 2, TimeUnit.SECONDS);
     }
 }

         ScheduledThreadPool是一个固定大小的线程池，与FixedThreadPool类似，执行的任务是定时执行。

    Java的并发包很强大，上面所说只是入门，随着学习深入，会有更多记录在博客里。

 接着上一篇继续并发包的学习，本篇说明的是Callable和Future，它俩很有意思的，一个产生结果，一个拿到结果。

        Callable接口类似于Runnable，从名字就可以看出来了，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值，下面来看一个简单的例子：

 public class CallableAndFuture {
     public static void main(String[] args) {
         Callable<Integer> callable = new Callable<Integer>() {
             public Integer call() throws Exception {
                 return new Random().nextInt(100);
             }
         };
         FutureTask<Integer> future = new FutureTask<Integer>(callable);
         new Thread(future).start();
         try {
             Thread.sleep(5000);// 可能做一些事情
             System.out.println(future.get());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }

        FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值，那么这个组合的使用有什么好处呢？假设有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用这个组合，用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到，岂不美哉！这里有一个Future模式的介绍： http://caterpillar.onlyfun.net/Gossip/DesignPattern/FuturePattern.htm 。

        下面来看另一种方式使用Callable和Future，通过ExecutorService的submit方法执行Callable，并返回Future，代码如下：

 public class CallableAndFuture {
     public static void main(String[] args) {
         ExecutorService threadPool = Executors.newSingleThreadExecutor();
         Future<Integer> future = threadPool.submit(new Callable<Integer>() {
             public Integer call() throws Exception {
                 return new Random().nextInt(100);
             }
         });
         try {
             Thread.sleep(5000);// 可能做一些事情
             System.out.println(future.get());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }

        代码是不是简化了很多，ExecutorService继承自Executor，它的目的是为我们管理Thread对象，从而简化并发编程，Executor使我们无需显示的去管理线程的生命周期，是JDK 5之后启动任务的首选方式。

        执行多个带返回值的任务，并取得多个返回值，代码如下：

 public class CallableAndFuture {
     public static void main(String[] args) {
         ExecutorService threadPool = Executors.newCachedThreadPool();
         CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(threadPool);
         for(int i = 1; i < 5; i++) {
             final int taskID = i;
             cs.submit(new Callable<Integer>() {
                 public Integer call() throws Exception {
                     return taskID;
                 }
             });
         }
         // 可能做一些事情
         for(int i = 1; i < 5; i++) {
             try {
                 System.out.println(cs.take().get());
             } catch (InterruptedException e) {
                 e.printStackTrace();
             } catch (ExecutionException e) {
                 e.printStackTrace();
             }
         }
     }
 }

        其实也可以不使用CompletionService，可以先创建一个装Future类型的集合，用Executor提交的任务返回值添加到集合中，最后便利集合取出数据，代码略。

Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果，代码如下：

 public class LockTest {
     public static void main(String[] args) {
         final Outputter1 output = new Outputter1();
         new Thread() {
             public void run() {
                 output.output("zhangsan");
             };
         }.start();
         new Thread() {
             public void run() {
                 output.output("lisi");
             };
         }.start();
     }
 }
 class Outputter1 {
     private Lock lock = new ReentrantLock();// 锁对象
     public void output(String name) {
         // TODO 线程输出方法
         lock.lock();// 得到锁
         try {
             for(int i = 0; i < name.length(); i++) {
                 System.out.print(name.charAt(i));
             }
         } finally {
             lock.unlock();// 释放锁
         }
     }
 }

        这样就实现了和sychronized一样的同步效果，需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内。

        如果说这就是Lock，那么它不能成为同步问题更完美的处理方式，下面要介绍的是读写锁(ReadWriteLock)，我们会有一种需求，在对数据进行读写的时候，为了保证数据的一致性和完整性，需要读和写是互斥的，写和写是互斥的，但是读和读是不需要互斥的，这样读和读不互斥性能更高些，来看一下不考虑互斥情况的代码原型：

 public class ReadWriteLockTest {
     public static void main(String[] args) {
         final Data data = new Data();
         for (int i = 0; i < 3; i++) {
             new Thread(new Runnable() {
                 public void run() {
                     for (int j = 0; j < 5; j++) {
                         data.set(new Random().nextInt(30));
                     }
                 }
             }).start();
         }
         for (int i = 0; i < 3; i++) {
             new Thread(new Runnable() {
                 public void run() {
                     for (int j = 0; j < 5; j++) {
                         data.get();
                     }
                 }
             }).start();
         }
     }
 }
 class Data {
     private int data;// 共享数据
     public void set(int data) {
         System.out.println(Thread.currentThread().getName() + "准备写入数据");
         try {
             Thread.sleep(20);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         this.data = data;
         System.out.println(Thread.currentThread().getName() + "写入" + this.data);
     }
     public void get() {
         System.out.println(Thread.currentThread().getName() + "准备读取数据");
         try {
             Thread.sleep(20);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName() + "读取" + this.data);
     }
 }

        部分输出结果：

 Thread-1准备写入数据
 Thread-3准备读取数据
 Thread-2准备写入数据
 Thread-0准备写入数据
 Thread-4准备读取数据
 Thread-5准备读取数据
 Thread-2写入12
 Thread-4读取12
 Thread-5读取5
 Thread-1写入12

        我们要实现写入和写入互斥，读取和写入互斥，读取和读取互斥，在set和get方法加入sychronized修饰符：

 public synchronized void set(int data) {...}
 public synchronized void get() {...}

        部分输出结果：

 Thread-0准备写入数据
 Thread-0写入9
 Thread-5准备读取数据
 Thread-5读取9
 Thread-5准备读取数据
 Thread-5读取9
 Thread-5准备读取数据
 Thread-5读取9
 Thread-5准备读取数据
 Thread-5读取9

        我们发现，虽然写入和写入互斥了，读取和写入也互斥了，但是读取和读取之间也互斥了，不能并发执行，效率较低，用读写锁实现代码如下：

 class Data {
     private int data;// 共享数据
     private ReadWriteLock rwl = new ReentrantReadWriteLock();
     public void set(int data) {
         rwl.writeLock().lock();// 取到写锁
         try {
             System.out.println(Thread.currentThread().getName() + "准备写入数据");
             try {
                 Thread.sleep(20);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             this.data = data;
             System.out.println(Thread.currentThread().getName() + "写入" + this.data);
         } finally {
             rwl.writeLock().unlock();// 释放写锁
         }
     }
     public void get() {
         rwl.readLock().lock();// 取到读锁
         try {
             System.out.println(Thread.currentThread().getName() + "准备读取数据");
             try {
                 Thread.sleep(20);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName() + "读取" + this.data);
         } finally {
             rwl.readLock().unlock();// 释放读锁
         }
     }
 }

        部分输出结果：

 Thread-4准备读取数据
 Thread-3准备读取数据
 Thread-5准备读取数据
 Thread-5读取18
 Thread-4读取18
 Thread-3读取18
 Thread-2准备写入数据
 Thread-2写入6
 Thread-2准备写入数据
 Thread-2写入10
 Thread-1准备写入数据
 Thread-1写入22
 Thread-5准备读取数据

        从结果可以看出实现了我们的需求，这只是锁的基本用法，锁的机制还需要继续深入学习。

接近一周没更新《Java线程》专栏了，主要是这周工作上比较忙，生活上也比较忙，呵呵，进入正题，上一篇讲述了并发包下的Lock，Lock可以更好的解决线程同步问题，使之更面向对象，并且ReadWriteLock在处理同步时更强大，那么同样，线程间仅仅互斥是不够的，还需要通信，本篇的内容是基于上篇之上，使用Lock如何处理线程通信。

        那么引入本篇的主角，Condition，Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。下面将之前写过的一个线程通信的例子替换成用Condition实现(Java线程(三))，代码如下：

 public class ThreadTest2 {
     public static void main(String[] args) {
         final Business business = new Business();
         new Thread(new Runnable() {
             @Override
             public void run() {
                 threadExecute(business, "sub");
             }
         }).start();
         threadExecute(business, "main");
     }
     public static void threadExecute(Business business, String threadType) {
         for(int i = 0; i < 100; i++) {
             try {
                 if("main".equals(threadType)) {
                     business.main(i);
                 } else {
                     business.sub(i);
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 class Business {
     private boolean bool = true;
     private Lock lock = new ReentrantLock();
     private Condition condition = lock.newCondition();
     public /*synchronized*/ void main(int loop) throws InterruptedException {
         lock.lock();
         try {
             while(bool) {
                 condition.await();//this.wait();
             }
             for(int i = 0; i < 100; i++) {
                 System.out.println("main thread seq of " + i + ", loop of " + loop);
             }
             bool = true;
             condition.signal();//this.notify();
         } finally {
             lock.unlock();
         }
     }
     public /*synchronized*/ void sub(int loop) throws InterruptedException {
         lock.lock();
         try {
             while(!bool) {
                 condition.await();//this.wait();
             }
             for(int i = 0; i < 10; i++) {
                 System.out.println("sub thread seq of " + i + ", loop of " + loop);
             }
             bool = false;
             condition.signal();//this.notify();
         } finally {
             lock.unlock();
         }
     }
 }

        在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。

        这样看来，Condition和传统的线程通信没什么区别，Condition的强大之处在于它可以为多个线程间建立不同的Condition，下面引入API中的一段代码，加以说明。

 class BoundedBuffer {
    final Lock lock = new ReentrantLock();//锁对象
    final Condition notFull  = lock.newCondition();//写线程条件
    final Condition notEmpty = lock.newCondition();//读线程条件

    final Object[] items = new Object[100];//缓存队列
    int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/;

    public void put(Object x) throws InterruptedException {
      lock.lock();
      try {
        while (count == items.length)//如果队列满了
          notFull.await();//阻塞写线程
        items[putptr] = x;//赋值
        if (++putptr == items.length) putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0
        ++count;//个数++
        notEmpty.signal();//唤醒读线程
      } finally {
        lock.unlock();
      }
    }

    public Object take() throws InterruptedException {
      lock.lock();
      try {
        while (count == 0)//如果队列为空
          notEmpty.await();//阻塞读线程
        Object x = items[takeptr];//取值
        if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0
        --count;//个数--
        notFull.signal();//唤醒写线程
        return x;
      } finally {
        lock.unlock();
      }
    }
  }

        这是一个处于多线程工作环境下的缓存区，缓存区提供了两个方法，put和take，put是存数据，take是取数据，内部有个缓存队列，具体变量和方法说明见代码，这个缓存区类实现的功能：有多个线程往里面存数据和从里面取数据，其缓存队列(先进先出后进后出)能缓存的最大数值是100，多个线程间是互斥的，当缓存队列中存储的值达到100时，将写线程阻塞，并唤醒读线程，当缓存队列中存储的值为0时，将读线程阻塞，并唤醒写线程，下面分析一下代码的执行过程：

        1. 一个写线程执行，调用put方法；

        2. 判断count是否为100，显然没有100；

        3. 继续执行，存入值；

        4. 判断当前写入的索引位置++后，是否和100相等，相等将写入索引值变为0，并将count+1；

        5. 仅唤醒读线程阻塞队列中的一个；

        6. 一个读线程执行，调用take方法；

        7. ……

        8. 仅唤醒写线程阻塞队列中的一个。

        这就是多个Condition的强大之处，假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程，那么假设只有一个Condition会有什么效果呢，缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。