主页 / 问题 / 1352391
Accepted
V-CHO
Asked:2022-04-21 22:27:56 +0000 UTC2022-04-21 22:27:56 +0000 UTC

收到某个结果时中断线程创建

  • 772

有这段代码：

List<Node> nodes = generator.generateNodes(board);
int cores = Runtime.getRuntime().availableProcessors();
ExecutorService es = Executors.newFixedThreadPool(cores);
List<Future<Integer>> tasks = new CopyOnWriteArrayList<>();
try {               
loop:
    for(int i = 0; i < nodes.size(); i++) {                 
    Future<Integer> score = es.submit
            (new ArtIntel(nodes.get(i), Copier.deepCopy(board), level));
    tasks.add(score);
        for(Future<Integer> task: tasks) {
            if(task.isDone() && task.get() > 500) {
                System.out.println("Calculation interrupted in " + 
                        Thread.currentThread());
                break loop;
            }
        }
    }                   
}
catch (InterruptedException exc) {
    exc.printStackTrace();
}
catch (ExecutionException exc) {
    exc.printStackTrace();
}
finally {
    es.shutdown();          
    es.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
}

有没有办法确保检查是在嵌套循环中执行的？底线是，如果之前的线程之一已经达到了预期的结果，那么 ExecutorService 将停止创建新线程。例如：线程 1 启动，然后线程 2 启动（而线程 1 仍在运行），然后线程 1 得到结果 > 500 和线程 3，分别根本没有创建。上面的代码说明了这个想法，但不幸的是，它什么也没做。

添加

这是在控制台中看到的：

根节点数：29

1400 1400 1400 1400 1200 140 -1700 -1700 1400 1400 1400 1600 1200 140 1400 1400 1400 1400 1400 1200 1400 140. 1400, 1400, 10,400, 10,400,

但它应该是，按照设计，例如：1400、1400，（可能还有 1-2 个会“滑倒”进行处理），然后是所有未处理节点的默认（开始）值。处理器是2核的，所以同时只有2个线程，不清楚为什么测试条件没有时间工作（控制台中没有出现“Calculation interrupted in”）。

此外，节点还由生成器（第一行代码）根据其潜在前景进行预排序。

更清楚的是：

根节点数：18

500, 500, 500, 500, 500, 500, 180, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, -2000,

任务数：18

80, 40, 120, 120, 140, 60, 1200, 120, 140, 170, 120, 80, 100, 140, 140, 100, 170, -1500,

第 7 行之后的所有节点（得分为 1200）在第二行中的值应与第一行相同，因为 用于处理的线程的创建应该被条件中断（更不用说在中断的情况下通常任务应该小于节点）。

java

1 个回答

  1. Best Answer

    改写如下：

    1. 主流：
        final int cores = Runtime.getRuntime().availableProcessors();
    ExecutorService es = Executors.newFixedThreadPool(cores);
    List<Future<Integer>> tasks = new ArrayList<>(nodes.size());
    boolean stopped = false;
    Interceptor f14 = new Interceptor(es, tasks, stopped);
    try {               
        for(Node node: nodes) {                 
        Future<Integer> score = es.submit
                (new ArtIntel(node, Copier.deepCopy(board), level));
        tasks.add(score);
        }
        f14.start();
    }
    finally {
        if(!stopped){
            es.shutdown();          
            es.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
            f14.interrupt();
        }
    }
    1. 中断控制（在一个单独的类中）：
        @Override
    public void run() {
        
        while(!Thread.interrupted()) {
            for(Future<Integer> task: tasks) {
                try {
                    if(task.isDone() && task.get() > 500) {
                        for(Future<Integer> each: tasks) {
                            each.cancel(true);
                        }
                        es.shutdownNow();
                        es.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
                        stopped = true;
                        System.out.println("Interrupted in " + 
                                Thread.currentThread());
                    }
                }
                catch (InterruptedException | ExecutionException exc) {
                    exc.printStackTrace();
                    Thread.currentThread().interrupt();
                }
            }
        }       
    }
    • 0

相关问题