Question

我有一个执行程序服务，该服务同时提交x数量的线程以执行较长的任务。我需要能够停止所有当前正在运行的线程，并阻止启动排队的任务。我正在尝试实现一种方法来处理正在等待同步方法的停止线程，在该方法中，可运行对象将字符串列表传递回调用它的接口。

    @Override
        public synchronized void FilterResults(List<String> Results)  {
            //System.out.println("Result found: " + Results.size());
            try {
            Set<String> hs = new HashSet<>();
            hs.addAll(Results);
            Results.clear();
            Results.addAll(hs);
            for (String tempURL : Results) {
                //System.out.println("Found url: " + tempURL);
                if (!isCompleted(tempURL) && !isQueued(tempURL) && !isRunning(tempURL)) {
                    System.out.println("Added: " + tempURL + " to queue.");
                    queueLink(tempURL);
                    startNewThread(tempURL);
                }
            }
            }catch(Exception e) {

            }
            return;
        }
        private synchronized void startNewThread(String seedURL) {
                if (!isCompleted(seedURL) && !isRunning(seedURL)  ) {
                    if (completedSize("") + runningSize() > 99) {
                        Stop();
                    }

                    String tempProxy = "";
                    String tempPort = "";
                    if (UseProxies) {
                    String Proxy = grabFreeProxy();
                    String[] splitProxy = Proxy.split(":");
                    tempProxy = splitProxy[0]; // 004
                    tempPort = splitProxy[1]; // 034556
                    }
                    //System.out.println("Proxy: " + tempProxy);
                    //System.out.println("Port: " + tempPort);
                    execService.submit(new Crawl(seedURL, this, tempProxy, tempPort, UseProxies));
                    removeFromQueue(url);
                }

            }

@Override
    public Collection<String> Stop() {
        try {
            execService.shutdown();
            if (execService.awaitTermination(45, TimeUnit.SECONDS)) {
                  System.out.println("task completed");
                } else {

                  execService.shutdownNow();

                }
        } catch (InterruptedException e) {

        }
        return PROFILES;
    }

    The Runnable

    public class Crawl implements Runnable{
    public void run() {
            while(!Thread.currentThread().isInterrupted() && shutdown == false) {
             try {
                     //System.out.println(crawler.queueSize());
                     Thread.sleep(100);
                         Crawl(url);
             }catch (InterruptedException e) {
                    Thread.currentThread().interrupt();  // set interrupt flag
                }
       }

      public void crawl(){
         try {
                submitResults(urls); //Calls FilterResults()
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                //e.printStackTrace();
                Thread.currentThread().interrupt();
            }
             crawler.removeUsedProxy(Proxy + ":" + Port);
             this.shutdown();
     }
    }

当我调用关闭方法时，需要花费45秒以上的时间才能可靠地取消任务，而无需等待很长时间？随着线程数量的增加，这个数字也随之增加，并且由于所有线程都在等待提交结果，因此可能需要一些时间。如果我手动取消任务，我不在乎结果是否存储，我只需要能够取消即可。有什么想法吗？

更新我已经尝试过ExecutorService#shutdownNow。它不可靠当要杀死仍被synchronized方法阻止的任务时。

Answer 1

似乎您需要使用ExecutorService#shutdownNow，以防万一您不想等待并完成所有工作，并且会收到未执行任务的列表。如果希望/需要提供时间等待任务完成，可以使用ExecutionService#awaitTermination（参数不同于45秒）。

Executors.newFixedThreadPool如何在同步方法上停止所有活动线程

1 个答案: