併發--活動對象

活動對象

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. 活動對象之間的所有消息都要排隊。