如何在Java中暂停/重新启动SingleThreadExecutor（ExecutorService）？

我实现了一个单例类“SingleTaskExecutor”，它使用SingleThreadExecutor按顺序一次执行一个任务。此类用于按顺序一次执行异步数据库操作。一切正常。但是现在我们有了一个用例，我们需要暂停这个服务一段时间，执行一些操作，然后恢复服务。不确定如何暂停/恢复服务。这是我的密码：

public class SingleTaskExecutor {

    private SingleTaskExecutor() {}
    private final ExecutorService executor =   Executors.newSingleThreadExecutor();

    private static class LazyHolder {
        private static final SingleTaskExecutor instance = new SingleTaskExecutor(); 
    }

    public static SingleTaskExecutor getInstance() {
        return LazyHolder.instance;
    }

    public <T> Task<T> create(Callable<T> callable) {
        Task<T> task = new Task<T>() {
            @Override
            protected T call() throws Exception {
                return callable.call();
            }
        };
        return task;
    }

    public <T> T execute(Task<T> task) {
        return (T) executor.submit(task);
    }

    public void shutDown() {
        executor.shutdown();
    }

    public void awaitTermination() {
        try {
            executor.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void waitPlease() {
        try {
            Thread.currentThread().wait();
            //executor.wait();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void resume() {
        Thread.currentThread().notifyAll();
        //executor.notifyAll();
    }
}

公共类SingleTaskExecutor{
私有SingleTaskExecutor（）{}
private final executor service executor=Executors.newSingleThreadExecutor（）；
私有静态类懒汉{
私有静态最终SingleTaskExecutor实例=新SingleTaskExecutor（）；
}
公共静态SingleTaskExecutor getInstance（）{
返回LazyHolder.instance；
}
公共任务创建（可调用可调用）{
任务=新任务（）{
@凌驾
受保护的T call（）引发异常{
返回callable.call（）；
}
};
返回任务；
}
公共T执行（任务）{
返回（T）执行者。提交（任务）；
}
公共空间关闭（）{
executor.shutdown（）；
}
公共合同终止（）{
试一试{
执行器等待终止（5，时间单位秒）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
公共图书馆请（）{
试一试{
Thread.currentThread（）.wait（）；
//执行者，等等；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
公众简历（）{
Thread.currentThread（）.notifyAll（）；
//executor.notifyAll（）；
}
}

如果我理解正确，您希望暂停任务的执行，然后执行一些明确的任务，然后继续执行。我实际上看到了以下解决方案：

private volatile boolean paused;

public <T> T execute(Task<T> task) {
    if(paused) {
        synchronized(this) {
            if(paused) {
                wait();
            }
        }
    }
    return (T) executor.submit(task);
}

public synchronized void waitPlease() {
    paused = true;
}

public synchronized void resume() {
    paused = false;
    notify();
}

private；
公共T执行（任务）{
如果（暂停）{
已同步（此）{
如果（暂停）{
等待（）；
}
}
}
返回（T）执行者。提交（任务）；
}
公共已同步的void waitPlease（）{
暂停=真；
}
公共同步无效恢复（）{
暂停=错误；
通知（）；
}

如果我理解正确，您希望暂停任务的执行，然后执行一些明确的任务，然后继续执行。我实际上看到了以下解决方案：

private volatile boolean paused;

public <T> T execute(Task<T> task) {
    if(paused) {
        synchronized(this) {
            if(paused) {
                wait();
            }
        }
    }
    return (T) executor.submit(task);
}

public synchronized void waitPlease() {
    paused = true;
}

public synchronized void resume() {
    paused = false;
    notify();
}

private；
公共T执行（任务）{
如果（暂停）{
已同步（此）{
如果（暂停）{
等待（）；
}
}
}
返回（T）执行者。提交（任务）；
}
公共已同步的void waitPlease（）{
暂停=真；
}
公共同步无效恢复（）{
暂停=错误；
通知（）；
}

不能挂起已启动的单个任务。您尚未显示任务是如何提交和排队的，但您可能应该让代码在挂起时停止提交任务。或者让任务检查布尔标志，并在需要时等待。任务Task=SingleTaskExecutor.getInstance（）.create（（）->{createOrUpdate（posOrder）；return null；}）；SingleTaskExecutor.getInstance（）.execute（任务）；task.get（）；不能挂起已启动的单个任务。您尚未显示任务是如何提交和排队的，但您可能应该让代码在挂起时停止提交任务。或者让任务检查布尔标志，并在需要时等待。任务Task=SingleTaskExecutor.getInstance（）.create（（）->{createOrUpdate（posOrder）；return null；}）；SingleTaskExecutor.getInstance（）.execute（任务）；task.get（）；谢谢你，伊利亚。你的解决方案看起来不错。我正在尝试这个。我会告诉你的，谢谢你。你的解决方案看起来不错。我正在尝试这个。我会让你知道的。