状态机模式中的Task与对象池

Task

抽象带来Task

首先，假设我们有这么一段逻辑：收到一个参数，先校验格式是否正确，再提取相关的参数出来，执行我们的事务，然后构建结果并返回。伪代码如下：

/**
* 一个engine类
**/
public class Engine {
    public void init();
    public void cancel();
    public void restart();
    // 处理逻辑
    public void handleEvent(Param param) {
        validateParam(param);

        retrieveParam(param);

        handleTransaction(param);

        buildResult(param);

        response(param);
    }
}

在上面的handleEvent方法里面，处理逻辑与Engine并没有太多的联系，我们可以将这个逻辑抽离出来，或者说可以变得更抽象一点，如下：

/**
 * 一个engine类
 **/
public class Engine {
    public void init();
    public void cancel();
    public void restart();
    // 将处理逻辑抽象成Task类之后，Engine变得很简洁了
    public void handleEvent(Param param) {
        new Task().start(param);
    }
}

class Task{
    public void start(Param param){
        validateParam(param);

        retrieveParam(param);

        handleTransaction(param);

        buildResult(param);

        response(param);
    }
}

当然，如果engine被调用非常频繁，那么每次处理都新建一个Task类的话，会容易浪费内存，可以再优化一下性能，如下：

/**
 * 一个engine类
 **/
public class Engine {
    public void init();
    public void cancel();
    public void restart();
    // 减少新对象的创建可以将Task对象变成单例模式，或者将方法变成静态，这里取后者
    public void handleEvent(Param param) {
        Task.start(param);
    }
}

class Task{
    public static void start(Param param){
        // ......
    }
}

异步需要状态

如果上面的处理步骤有一个很耗时，例如handleTransaction方法需要10s才能返回，那么我们就需要将这个方法改造成异步的了，要不然就很影响engine的吞吐效率。这样，我们就需要一个状态标识符，用来标识handleTransaction方法是否执行完成，这个标识符可以放在engine里面，engine创建一个Map<Param,boolean>的成员变量,当handleTransaction方法执行完成产生回调，engine继续执行剩下的方法。

/**
 * 一个engine类
 **/
public class Engine {
    private Map<Param, Boolean> statusMap = new HashMap<Param, Boolean>();

    public void init();
    public void cancel();
    public void restart();
    /**
     * 处理逻辑
     **/
    public void handleEvent(Param param) {
        boolean isInitHandle = statusMap.getOrDefault(param, Boolean.FALSE);
        if (isInitHandle) {
            Task.handleParamBeforeTransaction(param);
            Task.handleTransaction(param);
        }else{
            Task.buildResultAndResponse(param);
        }
    }
}

class Task{
    public static void handleParamBeforeTransaction(Param param){
        validateParam(param);

        retrieveParam(param);
    }

    public static void handleTransaction(Param param){

    }

    public static void buildResultAndResponse(Param param) {
        buildResult(param);

        response(param);
    }
}

不过，这样就破坏了Engine类的抽象，Engine是管理者，但是却持有每次请求的状态，这样的管理类管的太细。比较好的抽象方式是将赋予Task状态，Engine直接管理Task。

/**
 * 一个engine类
 **/
public class Engine {
    private Map<Param, Task> taskMap = new HashMap<Param, Task>();

    public void init();
    public void cancel();
    public void restart();
    /**
     * 处理逻辑
     **/
    public void handleEvent(Param param) {
        Task task = taskMap.computeIfAbsent(param, newParam ->new Task());
        task.handle(param);
    }

    public void releaseTask(Param param){
        taskMap.remove(param);
    }
}

class Task{
    private boolean isInit ;
    private Engine engine;
    public Task(Engine engine) {
        this.engine = engine;
        isInit=false;
    }

    public void handle(Param param) {
        if (!isInit) {
            handleParamBeforeTransaction(param);
            handleTransaction(param);
        }else{
            buildResultAndResponse(param);
            engine.releaseTask(param);
        }
    }

    private void handleParamBeforeTransaction(Param param){
        validateParam(param);

        retrieveParam(param);
    }

    private void handleTransaction(Param param){

    }

    private void buildResultAndResponse(Param param) {
        buildResult(param);

        response(param);
    }
}

Task含有一个isInit的成员变量，可以根据这个状态来判断应该执行什么操作，实际上这就是状态机模式了。我们进行这般改造之后，Engine的吞吐量会提高很多,而且抽象程度比较高。

不过，每次处理Task都需要新建一个对象出来，又回到了刚开始的时候。一旦Engine的tps上去，不断创建、释放的Task对GC肯定有不小的影响。

对象池

不断创建的Task实例，如果整个处理逻辑的时间都比较短，那么都可以在YGC时回收掉内存，如果时间比较长，那肯定有相当部分的Task实例被不断地移到老年代，这样很显然会导致更长时间的FGC。异步要求保留状态，而有状态就要求有新实例，Task的创建不可避免，可以考虑将Task实例放到对象池里面回收利用。

/**
 * 一个engine类
 **/
public class Engine {
    private Map<Param, Task> taskMap = new HashMap<Param, Task>();

    public void init();

    public void cancel();

    public void restart();

    /**
     * 处理逻辑
     **/
    public void handleEvent(Param param) {
        Task task = taskMap.computeIfAbsent(param, newParam -> TaskPool.getTask());
        task.init(this);
        task.handle(param);
    }

    public void releaseTask(Param param) {
        Task task = taskMap.remove(param);
        TaskPool.releaseTask(task);
    }
}

/**
Task实例的对象池
*/
class TaskPool {
    private static Queue<Task> taskPool = new LinkedList<>();

    public static Task getTask() {
        Task task = taskPool.poll();
        if (task == null) {
            task = new Task();
        }
        return task;
    }

    public static void releaseTask(Task task) {
        if(task!=null) {
            task.reset();
            taskPool.add(task);
        }
    }
}

class Task {
    private boolean isInit;
    private Engine engine;
    // 由于Task放到对象池当中，需要提供一个init与reset方法，以回收利用
    public void init(Engine engine) {
        this.engine = engine;
        isInit = false;
    }

    public void reset() {
        this.engine = null;
        isInit = false;
    }

    public void handle(Param param) {
        if (!isInit) {
            handleParamBeforeTransaction(param);
            handleTransaction(param);
        } else {
            buildResultAndResponse(param);
            engine.releaseTask(param);
        }
    }

    private void handleParamBeforeTransaction(Param param) {
        validateParam(param);

        retrieveParam(param);
    }

    private void handleTransaction(Param param) {

    }

    private void buildResultAndResponse(Param param) {
        buildResult(param);

        response(param);
    }
}

由于Task实例从对象池（会放置到老年代里面）当中获取，这样就可以减少从新生代创建的内存浪费。这样在engine高tps的情况下，可以减少些gc，相当于从JVM的世界里面偷了点时间出来（这样想想还是有点刺激的）。