主动对象模式（Active Object）

七、主动对象模式（Active Object）
1、核心思想
一种异步编程思想，允许任务的提交（相当于对异步方法的调用）和任务的执行（相当于异步方法的真正执行）分离，实现了异步编程。
有利于提高并发性，从而提高系统的吞吐率
2、适用场景
适合分解一个比较耗时的任务（如I/O任务）已减少主线程的等待时间。
3、可复用代码
ActiveObjectProxy

public interface RequestPersistence {
    public void store(MMSDeliverReqest request);
}

public class AyncRequestPersistence implements RequestPersistence {

    private static final long ONE_MINITE_IN_SECONDS = 1;
    private final AtomicLong taskTimeConsumerdPerInterval = new AtomicLong(0);
    private final AtomicInteger requestSubmittedPerInterval = new AtomicInteger(0);

    //模式角色 ActiveObject.servent
    private final DiskbasedRequestPersistence delegate = new DiskbasedRequestPersistence();
    //模式角色 ActiveObject.Scheduler
    private final ThreadPoolExecutor scheduler;

    private AyncRequestPersistence(){
        scheduler = new ThreadPoolExecutor(10, 20, 60*ONE_MINITE_IN_SECONDS, TimeUnit.SECONDS,
                //模式角色 ActiveObject.ActivationQueue
                new ArrayBlockingQueue<Runnable>(200),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread  t;
                        t = new Thread(r, "AyncRequestPersistence");
                        return t;
                    }
                });

        //设置缓存队列饱和策略处理方式为在任务的提交放运行被拒绝的任务
        scheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        Timer monitorTimer = new Timer(true);
        monitorTimer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("task count:"+ requestSubmittedPerInterval
                        + ", Queue size:" + scheduler.getQueue().size()
                        + ", taskTimeConsumerdPerInterval:" + taskTimeConsumerdPerInterval.get() + " ms");

                requestSubmittedPerInterval.set(0);
                taskTimeConsumerdPerInterval.set(0);
            }
        }, 0, ONE_MINITE_IN_SECONDS*1000);
    }

    //用于保存AyncRequestPersistence的唯一实例
    private static class InstanceHolder{
        final static RequestPersistence INSTANCE = new AyncRequestPersistence();
    }

    //获取类AyncRequestPersistence的唯一实例
    public static RequestPersistence getInstance(){
        return InstanceHolder.INSTANCE;
    }

    @Override
    public void store(MMSDeliverReqest request) {
        Callable<Boolean> methodRequest = new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                long start = System.currentTimeMillis();
                try {
                    delegate.store(request);
                } finally{
                    taskTimeConsumerdPerInterval.addAndGet(System.currentTimeMillis() - start);
                }
                return Boolean.TRUE;
            }
        };

        scheduler.submit(methodRequest);
        requestSubmittedPerInterval.incrementAndGet();
    }
}


/**
 * 模式角色 servent
 * @author huzhiqiang
 *
 */
public class DiskbasedRequestPersistence implements RequestPersistence {
    @Override
    public void store(MMSDeliverReqest request) {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}



public class MMSDeliveryServlet {
    public static void main(String[] args) {
        while(true){

            for(int i=0; i<10; i++){
                MMSDeliverReqest request = new MMSDeliverReqest();
                AyncRequestPersistence.getInstance().store(request);
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

/**
 * Active Object 模式Proxy参与者的可复用实现
 * @author huzhiqiang
 *
 */
public abstract class ActiveObjectProxy {
    private static class DispatchInvocationHandler implements InvocationHandler{
        private final Object delegate;
        private final ExecutorService schedler;

        public DispatchInvocationHandler(Object delegate, ExecutorService schedler) {
            super();
            this.delegate = delegate;
            this.schedler = schedler;
        }

        private String makeDelegateMethodName(final Method method, final Object[] arg){
            String name = method.getName();
            name = "do" + Character.toUpperCase(name.charAt(0)) + name.substring(1);
            return name;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // TODO Auto-generated method stub
            Object returnValue = null;
            final Method delegateMethod;

            //如果拦截到的调用方法是异步方法，则将其转发到相应的doXXX方法
            if(Future.class.isAssignableFrom(method.getReturnType())){
                delegateMethod = delegate.getClass().getMethod(makeDelegateMethodName(method, args), 
                        method.getParameterTypes());

                final ExecutorService schedler = this.schedler;

                Callable<Object> methodRequest = new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        Object rv = null;

                        try {
                            rv = delegateMethod.invoke(delegate, args);
                        } catch (Exception e) {
                            throw new Exception(e);
                        }
                        return rv;
                    }
                };

                Future<Object> future = schedler.submit(methodRequest);
                returnValue = future;
            }else{
                //如果拦截到的调用方法不是异步方法，则直接转发
                delegateMethod = delegate.getClass().getMethod(method.getName(), method.getParameterTypes());

                returnValue = delegateMethod.invoke(delegate, args);
            }

            return returnValue;
        }
    }

    /**
     * 生成一个实现指定接口的Active Object proxy 实例
     * 对 interf所定义的异步方法的调用会被转发到servent的相应的doXXX方法
     * @param interf
     * @param servent
     * @param schedler
     * @return
     */
    public static <T> T newInstance(Class<T> interf, Object servent, ExecutorService schedler){
        @SuppressWarnings("unchecked")
        T f = (T) Proxy.newProxyInstance(interf.getClassLoader(), new Class[] { interf }, 
                new DispatchInvocationHandler(servent, schedler));

        return f;
    }

}