Question

在我执行方案的过程中,一些校对已经开始。校对数量因用户界定的环境而有所不同,但所有校对都采用了具有不同变量的相同方法。

在某些情况下,清理需要中度执行,其中一部分是停止所有read子,我不想立即阻止,不过,我只是设定了一种变数,以证明终止这些.子。问题在于,在read线之前,它最多可达1/2。然而,我需要确保,在清理工作继续进行之前,所有线索都已停止。清理工作从另一个深层楼梯进行,在技术上,我需要这一read子等待其他read子完成。

我已想到这样做的几种方式,但似乎都过于复杂。我希望,有一些方法能够等待一组read子完成。是否有这样的东西?

Answer 1

赞成:

for (Thread thread : threads) {
  thread.join();
}

(你需要做一些与<条码>中断的Exception有关的事情,如果情况有误,你很可能要提供时间,但这一基本想法是......)

Answer 2

如果你使用java 1.5或以上,你可尝试http://java.sun.com/j2se/1.5.0/docs/api/java/util/contant/Cyclic Barrier.html> rel=“noreferer” Cyclic Barrier 。如果需要清理,你可以把清理行动作为建筑参数,就只能打上<条码> barrier.await(>。

Answer 3

您是否看到<条码>Executor各班<条码>。您可以通过<条码>Executorservice接手。它给你一个单一的物体,你可以用来勾销read子或等到底。

Answer 4

界定实用方法(或方法):

public static waitFor(Collection<? extends Thread) c) throws InterruptedException {
    for(Thread t : c) t.join();
}

或您可能拥有一阵列

public static waitFor(Thread[] ts) throws InterruptedException {
    waitFor(Arrays.asList(ts));
}

或者,请看在<条码>上使用<条码>Cyclic Barrier的图书馆,以实施一个任意的rendezvous在多个校对之间的点。

Answer 5

If you control the creation of the Threads (submission to an ExecutorService) then it appears you can use an ExecutorCompletionService see ExecutorCompletionService? Why do need one if we have invokeAll? for various answers there.

If you don t control thread creation, here is an approach that allows you to join the threads "one by one as they finish" (and know which one finishes first, etc.), inspired by the ruby ThreadWait class. Basically by newing up "watching threads" which alert when the other threads terminate, you can know when the "next" thread out of many terminates.

您这样说:

JoinThreads join = new JoinThreads(threads);
for(int i = 0; i < threads.size(); i++) {
  Thread justJoined = join.joinNextThread();
  System.out.println("Done with a thread, just joined=" + justJoined);
}

来文方:

public static class JoinThreads {
  java.util.concurrent.LinkedBlockingQueue<Thread> doneThreads = 
      new LinkedBlockingQueue<Thread>();

  public JoinThreads(List<Thread> threads) {
    for(Thread t : threads) {
      final Thread joinThis = t;
      new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            joinThis.join();
            doneThreads.add(joinThis);
          }
          catch (InterruptedException e) {
            // "should" never get here, since we control this thread and don t call interrupt on it
          }
        }
      }).start();
    }

  }

  Thread joinNextThread() throws InterruptedException {
    return doneThreads.take();
  }
}

其中的一点是,它与通用的 Java线合作,不作修改,任何透镜都可以加入。洞穴需要一些额外的翻新。同样,如果你不把整数时间推到NextThread(......)并且没有“独木”方法等,这种具体实施即为“le子”。在这里,如果你能创造出一个更加政治化的版本的话。你们也可以使用同样的“未来”模式,而不是像目标。

友情链接