shz.model.PerpetualExecutor Maven / Gradle / Ivy

Go to download
package shz.model;

import shz.ThreadHelp;

import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public abstract class PerpetualExecutor {
    private final Executor executor;
    private final Lock lock;
    private final Condition finish;
    private final Condition sleep;
    private final Condition delay;
    private volatile boolean stop = true;
    private volatile boolean wait;

    public PerpetualExecutor(String threadName) {
        executor = ThreadHelp.getExecutor(ThreadHelp.TPConfig.of(threadName)
                .tpType(ThreadHelp.TPType.SINGLE_THREAD_EXECUTOR)
                .daemon(true)
                .workQueue(new LinkedBlockingQueue<>(1))
        );
        lock = new ReentrantLock();
        finish = lock.newCondition();
        sleep = lock.newCondition();
        delay = lock.newCondition();
    }

    protected boolean acceptable(T t) {
        return true;
    }

    protected abstract void consumer(T t);

    protected long sleepMillis(T t) {
        return 50L;
    }

    protected boolean stoppable(T t) {
        return false;
    }

    protected long finishMillis(T t) {
        return 0L;
    }

    protected long delayMillis(T t) {
        return 500L;
    }

    protected void log(Throwable cause) {
        cause.printStackTrace();
    }

    private void run(T t) {
        while (!stop) {
            if (!lock.tryLock()) break;
            try {
                while (!stop && acceptable(t)) {
                    //执行消费方法
                    consumer(t);
                    try {
                        long time = sleepMillis(t);
                        //消费睡眠
                        if (time > 0L) sleep.await(time, TimeUnit.MILLISECONDS);
                    } catch (InterruptedException e) {
                        log(e);
                    }
                }
                //判断是否结束线程任务
                if (!stop) stop = stoppable(t);
                try {
                    if (!stop) {
                        wait = true;
                        //当前没有可消费，等待被唤醒或等待超时
                        long time = finishMillis(t);
                        if (time > 0L) finish.await(time, TimeUnit.MILLISECONDS);
                        else finish.await();

                        //延迟执行
                        time = delayMillis(t);
                        if (time > 0L) delay.await(time, TimeUnit.MILLISECONDS);
                    }
                } catch (InterruptedException e) {
                    log(e);
                } finally {
                    wait = false;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public final void execute(T target) {
        if (executor != null && stop) try {
            lock.lock();
            stop = false;
            executor.execute(() -> run(target));
        } finally {
            lock.unlock();
        }
    }

    private void awaken() {
        try {
            lock.lock();
            if (wait) finish.signal();
            else sleep.signal();
        } finally {
            lock.unlock();
        }
    }

    public final void awaken(T target) {
        execute(target);
        awaken();
    }

    public final boolean isStop() {
        return stop;
    }

    public synchronized void stop() {
        if (!stop) {
            stop = true;
            if (wait) awaken();
        }
    }
}