活动对象：
    java中的线程比较 复杂和难以控制，但是有另一种不同的实现方式被称为活动对象，这些对像每个都维护着它自己的工作器和消息对列，并且所有的对象的请求都将进入对列排队，任何时刻都只能运行一个，所以当你向一个活动对象发消息时，这条消息为一个任务，该任务会插入到这个对列中去，等待运行。有了活动对象我们就可串化消息而不是任务。
    示列：

    1. package com.package21.active;
    3. import java.util.concurrent.*;
    4. import java.util.*;
    6. public class ActiveObjectDemo {
    7.   @Override
    8.   public String toString() {
    9.     return "ActiveObjectDemo{" +
    10.             "ex=" + ex +
    11.             '}';
    12.   }
    14.   private ExecutorService ex = Executors.newSingleThreadExecutor();//任何时刻都只有一个线程执行
    15.   private void sleep() {
    16.     try {
    17.       TimeUnit.MILLISECONDS.sleep(10000);//休眠了一段时间
    18.     } catch(InterruptedException e) {
    19.       System.out.println("sleep() interrupted");
    20.     }
    21.   }
    22.   public Future<Integer> calculateInt(final int x, final int y) {
    23.     return ex.submit(new Callable<Integer>() {
    24.       public Integer call() {
    25.         sleep();//休眠一段时间
    26.         System.out.println("starting " + x + " + " + y);
    27.         sleep();//休眠一段时间
    28.         return x + y;
    29.       }
    30.     });
    31.   }
    32.   public Future<Float> calculateFloat(final float x, final float y) {
    33.     return ex.submit(new Callable<Float>() {//因为submit方法产生一个Future对象，但是这个对象直到任务完成后才会有一个结果。
    34.       public Float call() {
    35.         sleep();//休眠一段时间
    36.         System.out.println("starting " + x + " + " + y);
    37.         sleep();
    38.         return x + y;
    39.       }
    40.     });
    41.   }
    42.   public void shutdown() { ex.shutdown(); }
    43.   public static void main(String[] args) {
    44.     ActiveObjectDemo d1 = new ActiveObjectDemo();
    45.     List<Future<?>> results =new CopyOnWriteArrayList<>();
    46.     for(float f = 0.0f; f < 1.0f; f += 0.2f) {
    47.       results.add(d1.calculateFloat(f, f));
    48.     }
    49.     for(int i = 0; i < 5; i++) {
    50.       results.add(d1.calculateInt(i, i));
    51.     }
    52.     System.out.println("All asynch calls made");
    53.     System.out.println("集合的大小"+results.size());
    54.     //只要集合的size>0就会进入到循环中去，只有future中的结果完成，才回去取出结果，并在集合中移除，减小size的值，直到为0才回退出循环
    55.     while(results.size() > 0) {
    56.       for(Future<?> f : results)
    57.         if(f.isDone()) {//如果不为空才会取值
    58.           try {
    59.              System.out.println(f.get());
    60.           } catch(Exception e) {
    61.             throw new RuntimeException(e);
    62.           }
    63.           results.remove(f);//每成功取出值就会减少
    64.         }
    65.     }
    66.     d1.shutdown();
    67.   }
    68. }
    1.  示列详解：

    上述程序中，只要调用计算的方法就会先返回一个Future对象，然后就会添加到集合中去，但是这个时候的future对象还没有完成数据的传送，所以调用isDone时便不无法进入到取值任务中。而且此时集合的size还是一直大于0，所以程序会一直进行循环，知道返回一个值，idDone为true才会去进行取值，同时在将该元素从集合中移除。future就是一个活动对象，每个没有完成数据传送的future对象就是一个个任务进入对列中等待。此时只要有一个future对象完成了数据传输，然后isDone为true便开始取值。