Java Executor服务暂停/恢复特定线程

Question

有没有办法使用ExecutorService暂停/恢复特定线程？

private static ExecutorService threadpool = Executors.newFixedThreadPool(5);

想象一下，我想停止id=0的线程（假设为每个线程分配了一个增量id，直到达到线程池的大小）。

过了一会儿，按下一个按钮，比如说，我想恢复那个特定的线程，并让所有其他线程保持其当前状态，可以暂停或恢复。

我在Java文档中发现了PausableThreadPoolExecutor的一个未完成版本。但它不适合我的需要，因为它会恢复池中的所有线程。

如果ExecutorService的默认实现无法解决这个问题，有人能给我介绍一个Java实现吗？

Answer 1

一个场景可能是，一个想要模拟许多设备。设备有功能。总的来说，这组设备同时运行。现在，如果一个线程代表一个设备（或者一个线程代表一个设备的一个功能），那么可能需要控制设备的生命周期，比如start（）、shutdown（）、resume（）

Answer 2

建议：与正在使用的标志类似，为每个需要暂停/取消暂停的任务创建一个带有1个许可证的信号量（新信号量（1））。在任务的工作周期开始时，输入如下代码：

semaphore.acquire();
semaphore.release();

这会导致任务获取信号量许可证并立即释放它。现在，如果您想暂停线程（例如，按下一个按钮），请调用semaphore。从另一个线程获取（）。由于信号量现在有0个许可证，您的工作线程将在下一个周期开始时暂停，并等待您调用信号量。从另一个线程释放（）。

（如果工作线程在等待时被中断，acquire（）方法将抛出InterruptedException）。还有另一种方法acquireUnterruptibly（），它也尝试获取许可证，但不会被打断。）

Answer 3

你走错了路。线程池拥有这些线程，通过与代码共享它们，可能会把事情搞砸
您应该专注于使任务（传递给线程的任务是可取消/可中断的），而不是直接与池所拥有的线程交互
此外，当你试图中断线程时，你不知道正在执行什么作业，所以我不明白你为什么有兴趣这么做

更新：
取消您在线程池中提交的任务的正确方法是通过Future执行程序返回的任务。
1）这样您就可以确定您实际瞄准的任务正在尝试取消
2）如果您的任务已经设计为可取消的，那么您的任务已经完成了一半
3）不要使用标志来指示取消，而是使用Thread.currentThread（）。中断（）代替

更新：

public class InterruptableTasks {  

    private static class InterruptableTask implements Runnable{  
        Object o = new Object();  
        private volatile boolean suspended = false;  

        public void suspend(){          
            suspended = true;  
        }  

        public void resume(){       
            suspended = false;  
            synchronized (o) {  
                o.notifyAll();  
            }  
        }  


        @Override  
        public void run() {  

            while(!Thread.currentThread().isInterrupted()){  
                if(!suspended){  
                    //Do work here      
                }
                else{  
                    //Has been suspended  
                    try {                   
                        while(suspended){  
                            synchronized(o){  
                                o.wait();  
                            }                           
                        }                       
                    }  
                    catch (InterruptedException e) {                    
                    }             
                }                           
            }  
            System.out.println("Cancelled");        
        }

    }

    /**  
     * @param args  
     * @throws InterruptedException   
     */  
    public static void main(String[] args) throws InterruptedException {  
        ExecutorService threadPool = Executors.newCachedThreadPool();  
        InterruptableTask task = new InterruptableTask();  
        Map<Integer, InterruptableTask> tasks = new HashMap<Integer, InterruptableTask>();  
        tasks.put(1, task);  
        //add the tasks and their ids

        Future<?> f = threadPool.submit(task);  
        TimeUnit.SECONDS.sleep(2);  
        InterruptableTask theTask = tasks.get(1);//get task by id
        theTask.suspend();  
        TimeUnit.SECONDS.sleep(2);  
        theTask.resume();  
        TimeUnit.SECONDS.sleep(4);                
        threadPool.shutdownNow();      
    }