多线程设计模式：第六篇 - ThreadLocal和Active

一，ThreadLocal

        Java 中的 ThreadLocal 类给多线程编程提供了一种可以让每个线程具有自己独立空间的机制，在这个空间内存储的数据是线程特有的，不对外共享。

        ThreadLocal 类提供了 set() 和 get() 方法用于设置和获取线程特有数据，且 ThreadLocal 支持泛型，这样可以通过参数来指定要存储数据的类型。

二，Active Object模式

        Active Object模式的主要目的是实现方法调用和执行分离到不同的线程中，这样可以提高调用方的响应速度，同时执行方的执行策略对调用方透明，达到双方互不干扰。这和之前我们说的生产者-消费者模式，Worker-Thread模式非常相似。

        下面的程序示例，我们选择使用 juc 包中的 Executor 框架来实现一个Active Object模式：

/**
 * @author koma <komazhang@foxmail.com>
 * @date 2018-11-05
 */
public class Main {
    public static void main(String[] args) {
        ActiveObject activeObject = ActiveObjectFactory.createActiveObject();
        try {
            new MakerClientThread("Alice", activeObject).start();
            new MakerClientThread("Bobby", activeObject).start();
            Thread.sleep(5000);
        } catch (RejectedExecutionException e) {
        } catch (InterruptedException e) {
        } finally {
            activeObject.shutdown();
        }
    }
}

public interface ActiveObject {
    public abstract Future<String> makeString(int count, char fillchar);
    public abstract void displayString(String s);
    public abstract void shutdown();
}

public class ActiveObjectFactory {
    public static ActiveObject createActiveObject() {
        return new ActiveObjectImpl();
    }
}

public class ActiveObjectImpl implements ActiveObject {
    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @Override
    public Future<String> makeString(final int count, final char fillchar) {
        class MakeStringRequest implements Callable<String> {
            @Override
            public String call() throws Exception { //请求的执行在另外一个线程中异步执行
                char[] buffer = new char[count];
                for (int i = 0; i < count; i++) {
                    buffer[i] = fillchar;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                return new String(buffer);
            }
        }
        return executorService.submit(new MakeStringRequest()); //提交请求并马上返回
    }

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

public class MakerClientThread extends Thread {
    private final ActiveObject activeObject;
    private final char fillchar;

    public MakerClientThread(String name, ActiveObject activeObject) {
        super(name);
        this.activeObject = activeObject;
        this.fillchar = name.charAt(0);
    }

    @Override
    public void run() {
        try {
            for (int i = 0; true; i++) {
                //使用 Future 模式获取数据
                Future<String> future = activeObject.makeString(i, fillchar);
                Thread.sleep(100);
                String value = future.get();
                System.out.println(Thread.currentThread().getName()+": value = "+value);
            }
        } catch (InterruptedException e) {
        } catch (ExecutionException e) {
        }
    }
}

１，关于 Active Object模式 的说明

        Active Object模式揭示了一个事实即如果可以把方法调用和执行分到不同的线程，即跨越线程界线执行，那么就可以跨越计算机执行，即透过网络在远端计算机上执行方法。与该模式相关的 Java 技术叫 RMI。

２，POSA2 中的主动对象（Active Object）设计模式定义

        主动对象（Active Object）设计模式将方法执行和调用分离，加强并发和简化对驻留在自身控制线程中对象的同步访问。

        主动对象 别名 并发对象（Concurrent Object）