观察者模式

观察者模式

抽象被观察者角色：也就是一个抽象主题，它把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。

具体被观察者角色：也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。

具体观察者角色：实现抽象观察者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。

 

实现监控线程生命周期

一、接口定义

   

public interface TaskLifecycle<T> {

/**

* 抽象的观察者;由被观察者通知观察者更新自己的内部状态

*/

void onStart(Thread thread);



void onRunning(Thread thread);



void onFinish(Thread thread,T result);



void onError(Thread thread,Exception e);

}



public interface Observerable {

/**

* 抽象的被观察者

*/

enum Cycle{

STARTED,RUNNING,DONE,ERROR

}

//获取当前任务状态

Cycle getCycle();



void start();



//定义线程打断方法

void interrupt();

}



public class EmptyLifecycle<T> implements TaskLifecycle{

/**

* 观察者的具体实现，实际上每一个动作，onStart,onRunning都可以作为一个观察者，一同组成一个观察者集合

* */

@Override

public void onStart(Thread thread) {

    System.out.println(thread.getName()+"onStart");

}



@Override

public void onRunning(Thread thread) {

    System.out.println(thread.getName()+"onRunning");

}



@Override

public void onFinish(Thread thread, Object result) {

    System.out.println(thread.getName()+"onRunning");

}



@Override

public void onError(Thread thread, Exception e) {

    System.out.println(thread.getName()+"onError");

}

}



public class ObservableThread<T> extends Thread implements Observerable{

/**

* 被观察者具体实现

*/

private Cycle cycle;

private Callable callable;

private TaskLifecycle taskLifecycle;//观察者



public ObservableThread(Callable<T> callable){

    this(new EmptyLifecycle<T>(),callable);

}



public ObservableThread(TaskLifecycle taskLifecycle,Callable<T> callable){

    this.taskLifecycle =taskLifecycle;

    this.callable = callable;

}



@Override

public final void run(){



}



private void update(Cycle cycle,T result,Exception e){

    this.cycle = cycle;

    if(taskLifecycle == null)

        return;

    try {

        switch (cycle){

            case STARTED:

                this.taskLifecycle.onStart(currentThread());

                break;

            case RUNNING:

                this.taskLifecycle.onRunning(currentThread());

                break;

            case DONE:

                this.taskLifecycle.onFinish(currentThread(),result);

                break;

            case ERROR:

                this.taskLifecycle.onError(currentThread(),e);

                break;

         }

    }catch (Exception ex){



    }

}



@Override

public Cycle getCycle() {

        return this.cycle;

}

}