多叉树抽象任务依赖-任务调度系列1

　　系统在空闲时可以跑一些任务来进行一些统计方面的运算，大多是取数据，插数据，统计数据。这些任务有时候是有依赖关系的，比如A任务统计依赖B任务完成，起初我们把B任务安排在2点跑，A任务3点跑，可是B任务如果在一个小时内不能完成，在跑A任务的时候就会有问题。那么必须要保证B任务是完成的情况下才开跑A任务。

　　所以是不是可以考虑用一个链表这种数据结构把任务串起来执行，并且也保证每个任务的业务都在代码层面上分开。

　　类似：

　　　　

　　代码示例：

BaseTask：

public abstract class BaseTask {

    private String id;
    
    public abstract void execute();

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

SimpleBaseTask：

public abstract class SimpleBaseTask extends BaseTask{

    public void execute() {
        beforeExecute();
        doTask();
        doNextTask();
        afterExecute();
    }

    public void doNextTask(){
        if(nextTasks != null){
            for (BaseTask task : nextTasks) {
                task.execute();
            }
        }
    }
    
    public abstract void beforeExecute();
    
    public abstract void afterExecute();
    
    public abstract void doTask();
    
    private String name;
    
    private BaseTask parentTask;
    // 每一个任务都可以拥有多个后续任务 这些任务都依赖本任务的执行完成
    private List<BaseTask> nextTasks;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BaseTask getParentTask() {
        return parentTask;
    }

    public void setParentTask(BaseTask parentTask) {
        this.parentTask = parentTask;
    }

    public List<BaseTask> getNextTasks() {
        return nextTasks;
    }

    public void setNextTasks(List<BaseTask> nextTasks) {
        this.nextTasks = nextTasks;
    }

}

ProcessGroup：

public abstract class ProcessGroup<T extends BaseTask> {

    // 每个任务进程执行的第一个任务逻辑
    private BaseTask firstTask;
    
    public BaseTask getFirstTask() {
        return firstTask;
    }

    public void setFirstTask(BaseTask firstTask) {
        this.firstTask = firstTask;
    }
    
    public abstract void beforeProcess();
    
    public abstract void afterProcess();
    
    public void doProcess(){
        beforeProcess();
        firstTask.execute();
        afterProcess();
    }
}

SimpleProcessGroup ：

public class SimpleProcessGroup extends ProcessGroup<SimpleBaseTask>{

    @Override
    public void beforeProcess() {
        System.out.println("beforeProcess");
    }

    @Override
    public void afterProcess() {
        System.out.println("afterProcess");
    }


}

这种抽象局限性太大，把所有任务串联起来会导致任务需要手动拆分，依赖关系植入代码，难以维护。并且多任务依赖依然无法符合要求。

所以需要，更加强大的一个任务调度系统来实现这种灵活的任务依赖关系。