ACTIVE OBJECT 模式

一.概述

主动对象模式基于命令模式，是实现多线程控制的一项古老的技术。该模式有多种使用方式，为许多工业系统提供了一个简单的多任务核心。

二.实现

假如现在需要延时执行一个任务，并且不能阻塞下一个任务的执行

package cn.zzf.active.object;
import java.util.LinkedList;

/**
 * @author GaoFeng2017
 * @date 2018-06-03 15:29:24
 **/

public class ActiveObjectEngine {

    private LinkedList<Command> taskList = new LinkedList<>();

    public void addCommand(Command command) {
        taskList.add(command);
    }

    public void run() {
        while (!taskList.isEmpty()) {
            Command command = taskList.removeFirst();
            command.execute();
        }
    }
}

package cn.zzf.active.object;

/**
 * @author GaoFeng2017
 * @date 2018-06-03 15:33:39
 **/

public interface Command {
    void execute();
}

package cn.zzf.active.object;

/**
 * @author GaoFeng2017
 * @date 2018-06-03 15:33:39
 **/

public interface Command {
    void execute();
}

package cn.zzf.active.object;

/**
 * @author GaoFeng2017
 * @date 2018-06-03 15:34:03
 **/

public class SleepCommand implements Command {
    private boolean start = false;
    private long startTime;
    private Command executeCommand;
    private int delay;
    private ActiveObjectEngine engine;

    public SleepCommand(Command executeCommand, int delay, ActiveObjectEngine engine) {
        this.executeCommand = executeCommand;
        this.delay = delay;
        this.engine = engine;
    }

    @Override
    public void execute() {
        if (!start) {
            start = true;
            startTime = System.currentTimeMillis();
            engine.addCommand(this);
        } else if (System.currentTimeMillis() - startTime < delay) {
            engine.addCommand(this);
        } else {
            engine.addCommand(executeCommand);
        }
    }
}

package cn.zzf.active.object;

/**
 * @author GaoFeng2017
 * @date 2018-06-03 15:45:37
 **/

public class Test {
    private boolean stop = false;

    @org.junit.Test
    public void test() {
        ActiveObjectEngine engine = new ActiveObjectEngine();
        Command command = new Command() {
            @Override
            public void execute() {
                stop = true;
            }
        };

        long time = System.currentTimeMillis();
        SleepCommand sleepCommand = new SleepCommand(command,1000,engine);
        engine.addCommand(sleepCommand);
        engine.run();
        System.out.println(stop);
        System.out.println(System.currentTimeMillis() - time);

    }

}

运行结果

true
1000

分析

• 实现很简单，ActiveObjectEngine维护了一个commandList，我们可以把命令对象添加到engine中，并且调用run方法，遍历command链表，执行每一个command。试想一下，如果command对象能够创建或者克隆自己，并把创建或克隆的对象放入commandList中，那run会一直执行，commandList也不会为空，基于这个特点，我们在SleepCommand中，为exceute方法的实现加入了时间验证的逻辑，如果当前时间减去对象第一次加入的时间小于指定延时，就把自己重新加入到engine中，如果大于等于延时间，就把要执行的任务加入到engine中去执行。

三.案例

上面的实现已经演示了ACTIVE OBJECT模式是如何工作的，不过任务只被执行了一次，下面的案例将会让我们看到多个延时任务的循环执行，并且在指定延时后停止所有任务。

package cn.zzf.active.object;

/**
 * @author GaoFeng2017
 * @date 2018-06-03 17:00:10
 **/

public class DelayedTyper implements Command{

    private String name;
    private int delay;
    private static boolean stop = false;
    private static ActiveObjectEngine engine = new ActiveObjectEngine();

    @Override
    public void execute() {
        System.out.print(name);
        if (!stop) {
            repeatTask();
        }
    }

    public DelayedTyper(String name, int delay) {
        this.name = name;
        this.delay = delay;
    }


    public void repeatTask() {
        engine.addCommand(new SleepCommand(this,delay,engine));
    }

    public static ActiveObjectEngine getEngine() {
        return engine;
    }

    public static void main(String[] args) {

        engine.addCommand(new DelayedTyper("A",100));
        engine.addCommand(new DelayedTyper("B",300));
        engine.addCommand(new DelayedTyper("C",500));
        engine.addCommand(new DelayedTyper("D",700));

        engine.addCommand(new SleepCommand(() -> stop = true,5000,engine));
        engine.run();
    }
}

两次运行结果

ABCDAAABAACBADAABACAABAADABCAAABAACABDAAABACAABADAABCAAABAACDABAAABACAABDAAABCAAABADACABD

ABCDAAABACABADAAABCAABAADACABAAABACADABAABACAAABDAACABAAABACDAABAAABCAADABAACABAAABDACABD

分析
DelayTyper实现了Command，负责执行并添加任务，它的exceute方法不仅实现了延时后要执行的任务，而且会循环添加延时任务，直至stop被改变。具体步骤如下：

• 1.使用DelayTyper中的静态engine添加要循环执行的延时任务，这个任务本身也是DelayTyper对象
• 2.使用添加完延时任务的engine添加一个SleepCommand，其作用是改变stop标记，终止当前的循环任务。
• 3.执行engine的run方法，循环任务开始执行，此时commandList中的延时任务都会被执行一遍，这个执行没有延时。
• 4.接下来commandList会被放入和延时任务（最开始添加的DelayTyper）同等数量的SleepCommand，这些SleepCommand在engine的repeatTask方法里面被创建，最关键的是，SleepCommand的构造函数的Command参数是创建它们的DelayTyper。
• 5.在延时之前（System.currentTimeMillis() - startTime < delay），SleepCommand会一直把自己放入到commandList。
• 6.在延时之后，SleepCommand把创建自己的DelayTyper放入到commandList中，这个DelayTyper对象将等待遍历。
• 7.延时任务在DelaTyper（步骤6之后添加的）的exceute方法中执行，它打印了自己的name，接着它会创建一个新的SleepCommand对象，值得注意的是，这个对象和之前被创建的SleepCommand并没有变化（和5,6的逻辑是一样的），只是startTime不同而已。
• 8. 最后，当Stop被改变时，commandList内的命令对象只出不进，DelayTyper也会停止创建SleepCommand对象，整个循环任务将会结束。

可以看到，两次运行结果并不一样，书上的解释是cpu时钟和实时时钟没有完美的同步，个人感觉是每次测试时，方法（比如addCommand）执行的时间可能存在差异，当然这种差异可能是毫秒级别的。

四.总结

ACTIVE OBJECT是COMMAND模式的一个应用场景，它使用单线程环境构建了一个多线程系统，巧妙的进行了任务轮询，这样的好处在于，下一个任务(command)不会被上一个任务阻塞,并且这些任务是共享一个运行时堆栈，减少了内存占用，不会有同步问题出现。