高并发编程学习笔记(5)----监控任务的生命周期

虽然Thread提供了可获取状态，以及判断是否alive的方法，但是这些方法是针对线程本身的，而我们提交的任务Runnable在运行过程中所处状态是无法直接获得的。
当某一个对象发生状态改变需要通知第三方时，观察者模式就能够胜任这样的工作。
观察者模式需要定义三个接口

Observable接口

public interface Observable {
    enum Cycle{
        STARTED,RUNNING,DONE,ERROR
    }
    Cycle getCycle();
    void start();
    void interrupt();
}

该接口用于返回线程的状态。其中枚举类定义了线程的四个状态。
start()方法与interrupt()方法用于屏蔽Thread类其他API。

TaskLifecycle接口

public interface TaskLifecycle<T> {
    void onStart(Thread thread);
    void onRunning(Thread thread);
    void onFinish(Thread thread ,T result);
    void onError(Thread thread,Exception e);
    class EmptyLifecycle<T> implements TaskLifecycle<T>{

        @Override
        public void onStart(Thread thread) {
        }

        @Override
        public void onRunning(Thread thread) {
        }

        @Override
        public void onFinish(Thread thread, T result) {
        }

        @Override
        public void onError(Thread thread, Exception e) {
        }
    }
}

该接口定了了几个在线程不同状态下会被运行的方法。

Task接口

public interface Task<T> {
    T call();
}

相当于任务类，会被线程所执行。

实现ObservableThread

public class ObservableThread<T> extends Thread implements Observable{
    private  final  TaskLifecycle lifecycle;
    private  final  Task task;//任务
    private  Cycle cycle;
    //构造方法
    public ObservableThread(Task<T> task){
        this(new TaskLifecycle.EmptyLifecycle(),task);
    }
    //构造方法
    public ObservableThread(TaskLifecycle lifecycle, Task<T> task) {
        super();
        if(task==null)
            throw  new IllegalArgumentException("The task is required.");
        this.lifecycle = lifecycle;
        this.task = task;
    }
    //重写run方法
    public final void run(){
    	//先是STARTED状态
        this.update(Cycle.STARTED,null,null);
        try{
        	//RUNNING状态
            this.update(Cycle.RUNNING,null,null);
            //执行call方法
            T result = (T) this.task.call();
            //DONE状态
            this.update(Cycle.DONE,result,null);
        }catch (Exception e){
        //ERROR状态
            this.update(Cycle.ERROR,null,e);
        }
    }
    @Override
	//得到线程状态
    public Cycle getCycle() {
        return this.cycle;
    }
    //根据线程不同状态来调用TaskLifecycle中定义的方法
    private  void update(Cycle cycle, T result,Exception e){
        this.cycle=cycle;
        if(lifecycle==null){
            return ;
        }
        try{
            switch (cycle){
                case STARTED:
                    this.lifecycle.onStart(currentThread());break;
                case RUNNING:
                    this.lifecycle.onRunning(currentThread());break;
                case DONE:
                    this.lifecycle.onFinish(currentThread(),result);break;
                case ERROR:
                    this.lifecycle.onError(currentThread(),e);break;
            }
        }catch(Exception ex){
            if(cycle==Cycle.ERROR){
                throw  ex;
            }
        }
    }
}

run方法会在线程不同的时刻(Observable 提供)通过update方法来调用TaskLifecycle中定义好的方法。并且会在run方法中执行定义的任务接口中的方法Task();

测试

public class test {
    public static void main(String[] args) {
        //实现一个TaskLifecycle接口 并且重写方法，被线程在不同状态下调用
        final TaskLifecycle<Integer> lifecycle = new TaskLifecycle.EmptyLifecycle<Integer>() {
            @Override
            public void onStart(Thread thread) {
                System.out.println("线程准备运行");
            }

            @Override
            public void onRunning(Thread thread) {
                System.out.println("线程正在运行");
            }

            @Override
            public void onFinish(Thread thread, Integer result) {
                System.out.println("线程运行完成 结果为:"+result);
            }

            @Override
            public void onError(Thread thread, Exception e) {
                System.out.println("线程出错");
            }
        };
        
       Observable o =new ObservableThread<>(lifecycle,()->{
           int a=0;
           for(int i=0;i<10;i++){
               a+=i;
           }
           return a;
       });
       o.start();
    }
}