【Java】一个标准的后台线程的封装

最新推荐文章于 2022-08-02 17:30:15 发布

weixin_33713503

最新推荐文章于 2022-08-02 17:30:15 发布

阅读量297

点赞数

文章标签： java

原文链接：https://juejin.im/post/5cca56846fb9a0320d60f9ac

版权

前言：

我们日常总会碰到这样的需求：

把这个任务放到另外一个线程执行。
我需要周期性执行任务的线程。那我们通常都是怎么解决这个问题呢？
对于问题1，最简单的做法就是new thread，然后结束了。但在生产环境中，你常常会困扰，我这个线程到底执行没，或者是否正在执行。任务报错了日志在哪里呢？
对于问题2，我们可能会选择定时器，ScheduledExecutor，但如果你想追踪你的线程运行情况，或者捕获异常，这都没法随心所欲

针对上面常见的两个问题，我自己封装了一个标准的后台线程模型

一、完整代码实现

/**
 * DefaultThread 后台标准线程
 */
public final class DefaultThread extends Thread {
    /** log */
    private static final Logger log = InternalLoggerFactory.getLogger(DefaultThread.class);
    
    /** 标准后台线程循环间隔时间 - 1分钟 */
    public static final long DEFAULT_INTERVAL = 60 * 1000;
    /** 标准后台线程循环最小间隔 - 300ms */
    public static final long MIN_INTERVAL = 300;
    
    /** 默认日志输出级别 -- debug */
    public static final LogLevel DEFAULT_LEVEL = LogLevel.DEBUG;
    
    private String name;
    private Runnable runnable;
    private boolean runOnce;
    private volatile boolean stop;
    private volatile long interval;
    private volatile LogLevel level = DEFAULT_LEVEL;
   
    /**
     * 构造函数
     * <p>将构造一个标准后台线程，每分钟运行1次
     * @param name
     * @param runnable
     */
    public DefaultThread(String name, Runnable runnable) {
        super(name);
        this.name = name;
        this.runnable = runnable;
        this.runOnce = false;
        this.stop = false;
        this.interval = DEFAULT_INTERVAL;
    }
    
    /**
     * 构造函数
     * <p>将构造一个标准后台线程
     * @param name
     * @param runnable
     * @param runOnce
     * @param interval
     */
    public DefaultThread(String name, Runnable runnable, boolean runOnce) {
        super(name);
        this.name = name;
        this.runnable = runnable;
        this.runOnce = runOnce;
        this.stop = false;
        this.interval = DEFAULT_INTERVAL;
    }
    
    /**
     * 构造函数
     * <p>将构造一个标准后台线程，指定间隔运行一次（不能小于最小间隔时间{@link #MIN_INTERVAL}}）
     * @param name
     * @param runnable
     * @param runOnce
     * @param interval
     */
    public DefaultThread(String name, Runnable runnable, long interval) {
        super(name);
        this.name = name;
        this.runnable = runnable;
        this.runOnce = false;
        this.stop = false;
        this.interval = Math.max(MIN_INTERVAL, interval);
    }
    
    @Override
    public void start() {
        super.start();
    }

    public void stop() {
        try {
            this.interrupt();
        } catch (Exception e) {
            // Ignore
        }
        this.stop = true;
    }

    /**
     * 获得线程名称
     */
    public String getThreadName() {
        return this.name;
    }
    
    /**
     * 设置日志隔离级别
     */
    public void setLogLevel(LogLevel level) {
        this.level = level;
    }
    
    /**
     * 执行任务
     * @see java.lang.Thread#run()
     */
    public final void run() {
        if (runOnce) {
            runOnce();
            return;
        }
        
        while (!stop) {
            runOnce();
            
            try {
                sleep(interval);
            } catch (InterruptedException e) {
                // Ignore this Exception
            }
        }
    }

    /**
     * 执行一次
     */
    private void runOnce() {
        long startTime = 0;
        if (log.isLogEnabled(level)) {
            startTime = System.currentTimeMillis();
        }
        
        try {
            runnable.run();
        } catch (Throwable t) {
            log.error("thread run error [name:{}, runOnce:{}]", t, name, runOnce);
        }
        
        if (log.isLogEnabled(level)) {
            log.log(level, "{}#{}", (System.currentTimeMillis() - startTime));
        }
    }复制代码