并发--活动对象

活动对象

1. 概念：
   活动对象或者行动者：每个对象都维护着自己的工作期线程和消息队列，并且所有对这种对象的请求都将进入队列排队，任何时刻都只能运行其中的一个。因此，有了活动对象，就可以串行化消息而不是方法，意味着不再需要防备一个任务在其循环的中间被中断这种问题。

2. 用处：
   当向一个活动对象发送消息时，这条消息会转变为一个人任务，该任务会被插入到这个对象的队列中，等待在以后的某个时刻运行。

3. 示例：Future

package com21并发1;

import java.util.List;
import java.util.Random;
import java.util.concurrent.*;

/**
 * Created by Panda on 2018/5/28.
 */
public class ActiveObjectDemo {
    private ExecutorService executorService = Executors.newSingleThreadExecutor();
    private Random random = new Random(47);

    private void pause(int factor) {
        try {
            TimeUnit.MILLISECONDS.sleep(100 + random.nextInt(factor));
        } catch (InterruptedException e) {
            System.out.println("sleep()  interruptedException");
        }
    }

    public Future<Integer> calculateInt(final int x, final int y) {
        return executorService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("starting " + x + " + " + y);
                pause(500);
                return x + y;
            }
        });
    }

    public Future<Float> calculateFloat(final float x, final float y) {
        return executorService.submit(new Callable<Float>() {
            @Override
            public Float call() throws Exception {
                System.out.println("starting " + x + " + " + y);
                pause(2000);
                return x + y;
            }
        });
    }

    public void shutdown() {
        executorService.shutdown();
    }

    public static void main(String[] args) {
        ActiveObjectDemo activeObjectDemo = new ActiveObjectDemo();
        List<Future<?>> results = new CopyOnWriteArrayList<>();

        for (float f = 0.0f; f < 1.0f; f += 0.2f) {
            results.add(activeObjectDemo.calculateFloat(f, f));
        }

        for (int i = 0; i < 5; i++) {
            results.add(activeObjectDemo.calculateInt(i, i));
        }

        System.out.println("All asynch calls made");

        while (results.size() > 0) {
            for (Future<?> f : results)
                if (f.isDone()) {  //如果任务已经完成，则返回true
                    try {
                        System.out.println("完成" + f.get());
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                    results.remove(f);
                }
        }
        activeObjectDemo.shutdown();
    }
    /**
     * starting 0.0 + 0.0
     All asynch calls made
     完成0.0
     starting 0.2 + 0.2
     starting 0.4 + 0.4
     完成0.4
     完成0.8
     starting 0.6 + 0.6
     完成1.2
     starting 0.8 + 0.8
     完成1.6
     starting 0 + 0
     完成0
     starting 1 + 1
     完成2
     starting 2 + 2
     完成4
     starting 3 + 3
     完成6
     starting 4 + 4
     完成8
     */
}

解释：
1. Executors.newSingleThreadExecutor()的调用产生的单线程执行器维护着它自己的无界阻塞队列，并且只有一个线程从该队列中取走任务并执行它们直至完成。
2. 活动对象的优点：

1. 每个对象都可以拥有自己的工作器线程。

2. 每个对象都将维护队它自己的域的全部控制权。

3. 所有在活动对象之间的通信都将以在这些对象之间的消息形式发生。

4. 活动对象之间的所有消息都要排队。