Observable:

public interface Observable {
    enum Cycle{
        STARTED, RUNNING, DONE, ERROR
    }

    Cycle getCycle();

    void start();

    void interrupt();
}

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:

/*
    突然发现Observable中的start方法有点可怕的啊,这种写法,我感觉我是还每吃透
 */
public class ObservableThread<T> extends Thread
    implements Observable{
    private final TaskLifeCycle<T> lifeCycle;
    private final Task<T> task;
    private Cycle cycle;

    public ObservableThread(Task<T> task){
        this(new TaskLifeCycle.EmptyLifeCycle<>(),task);
    }

    public ObservableThread(TaskLifeCycle<T> lifeCycle,Task<T> task){

        super();

        if(task==null)
            throw new IllegalArgumentException("The task is required.");

        this.lifeCycle=lifeCycle;
        this.task=task;
    }

    public final void run(){
        this.update(Cycle.STARTED,null,null);
        try{
            this.update(Cycle.RUNNING,null,null);

            T result = this.task.call();

            this.update(Cycle.DONE,result,null);
        } catch (Exception e){
            this.update(Cycle.ERROR,null,e);
        }
    }

    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) {
            throw ex;
        }
    }

    public Cycle getCycle(){
        return this.cycle;
    }
}

测试代码:

/*
    突然发现Observable中的start方法有点可怕的啊,这种写法,我感觉我是还每吃透
 */
public class ObservableThread<T> extends Thread
    implements Observable{
    private final TaskLifeCycle<T> lifeCycle;
    private final Task<T> task;
    private Cycle cycle;

    public ObservableThread(Task<T> task){
        this(new TaskLifeCycle.EmptyLifeCycle<>(),task);
    }

    public ObservableThread(TaskLifeCycle<T> lifeCycle,Task<T> task){

        super();

        if(task==null)
            throw new IllegalArgumentException("The task is required.");

        this.lifeCycle=lifeCycle;
        this.task=task;
    }

    public final void run(){
        this.update(Cycle.STARTED,null,null);
        try{
            this.update(Cycle.RUNNING,null,null);

            T result = this.task.call();

            this.update(Cycle.DONE,result,null);
        } catch (Exception e){
            this.update(Cycle.ERROR,null,e);
        }
    }

    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) {
            throw ex;
        }
    }

    public Cycle getCycle(){
        return this.cycle;
    }
}

《Java高并发编程详解》笔记

Java监控任务的生命周期的更多相关文章

  1. [转]JAVA虚拟机的生命周期

    JAVA虚拟机体系结构 JAVA虚拟机的生命周期 一个运行时的Java虚拟机实例的天职是:负责运行一个java程序.当启动一个Java程序时,一个虚拟机实例也就诞生了.当该程序关闭退出,这个虚拟机实例 ...

  2. java 静态变量生命周期(类生命周期)

    Static: 加载:java虚拟机在加载类的过程中为静态变量分配内存. 类变量:static变量在内存中只有一个,存放在方法区,属于类变量,被所有实例所共享 销毁:类被卸载时,静态变量被销毁,并释放 ...

  3. Java类的生命周期详解

    引言 最近有位细心的朋友在阅读笔者的文章时,对java类的生命周期问题有一些疑惑,笔者打开百度搜了一下相关的问题,看到网上的资料很少有把这个问题讲明白的,主要是因为目前国内java方面的教材大多只是告 ...

  4. 【转】Java 类的生命周期详解

    一. 引 言 最近有位细心的朋友在阅读笔者的文章时,对java类的生命周期问题有一些疑惑,笔者打开百度搜了一下相关的问题,看到网上的资料很少有把这个问题讲明白的,主要是因为目前国内java方面的教材大 ...

  5. 【转载】详解java类的生命周期

    原文地址:http://blog.csdn.net/zhengzhb/article/details/7517213 引言 最近有位细心的朋友在阅读笔者的文章时,对java类的生命周期问题有一些疑惑, ...

  6. Java线程的生命周期(转)

    Java线程的生命周期 一个线程的产生是从我们调用了start方法开始进入Runnable状态,即可以被调度运行状态,并没有真正开始运行,调度器可以将CPU分配给它,使线程进入Running状态,真正 ...

  7. Java 对象的生命周期

    Java对象的生命周期 在Java中,对象的生命周期包含下面几个阶段: 1.      创建阶段(Created) 2.      应用阶段(In Use) 3.      不可见阶段(Invisib ...

  8. Java虚拟机(三)垃圾标记算法与Java对象的生命周期

    前言 这一节我们来简单的介绍垃圾收集器,并学习垃圾标记的算法:引用计数算法和根搜索算法,为了更好的理解根搜索算法,会在文章的最后介绍Java对象在虚拟机中的生命周期. 1.垃圾收集器概述 垃圾收集器( ...

  9. [Java]类的生命周期(上)类的加载和连接[转]

    本文来自:曹胜欢博客专栏.转载请注明出处:http://blog.csdn.net/csh624366188 类加载器,顾名思义,类加载器(class loader)用来加载 Java 类到 Java ...

随机推荐

  1. 微信小程序把玩(二十一)switch组件

    原文:微信小程序把玩(二十一)switch组件 switch开关组件使用主要属性: wxml <!--switch类型开关--> <view>switch类型开关</vi ...

  2. OpenDJ Roadmap

    Roadmap https://wikis.forgerock.org/confluence/display/OPENDJ/OpenDJ+Roadmap Forum https://forum.for ...

  3. QT运行cmd指令(两种办法:QProcess.start然后waitForFinished,运行cmd /c命令)

    QProcess p(); p.start("route");//写入要运行的指令即可 p.waitForStarted(); p.waitForFinished(); qDebu ...

  4. TopFreeTheme精选免费模板【20130626】

    有一段时间没有发布的模板了,相信很多喜欢新模板的朋友有点焦急了!还好,今天我今天整理了13个最新的模板,主要是WordPress的,另外3个是关于Joomla的模板,他们分别是游戏主题.俱乐部主题以及 ...

  5. 条款16:成对使用new和delete时要使用相同的形式

    请牢记: 如果在new表达式中使用[],必须在相应的delete表达式中也使用[]. new[]  对应  delete[] 如歌在new表达式中不适用[],一定不要在相应的delete表达式中使用[ ...

  6. flask(三)

    1.cbv的用法 from flask import Flask,views app = Flask(__name__) class Login(views.MethodView ): def get ...

  7. java中的String、StringBuffer、StringBuilder的区别

    java中String.StringBuffer.StringBuilder是编程中经常使用的字符串类,他们之间的区别也是经常在面试中会问到的问题.现在总结一下,看看他们的不同与相同. 1.可变与不可 ...

  8. vuejs 使用less

    当所有东西都 准备好之后 : 第一步: 安装less依赖, npm install less less-loader --save 第二步: 修改webpack.config.js文件,配置loade ...

  9. 打印第二列为oldboy的第一列内容(awk,grep,sed用法)

    [root@goldtest ~]# cat ip.log 10.0.0.1 oldboy 10.0.0.2 oldgirl 10.0.0.4 tingting 10.0.0.4 oldboy old ...

  10. 01 Javascript简介(了解)

    Web前端有三层: HTML:从语义的角度,描述页面结构 CSS:从审美的角度,描述样式(美化页面) JavaScript:从交互的角度,描述行为(提升用户体验) JavaScript历史背景介绍 布 ...