如何同时启动两个进程然后等待都完成？

Question

我想同时启动两个进程，并确保在继续其他步骤之前完成所有进程。你能帮我吗？我已经尝试过Thread，它不能同时启动两个并等到完成。

    final CyclicBarrier gate = new CyclicBarrier(3);
    Thread r2 = new Thread()
    {

        public void run()
        {
            try
            {
                int i = 0;
                while (i < 3)
                {
                    System.out.println("Goodbye, " + "cruel world!");
                    Thread.sleep(2000L);
                    i++;
                    gate.await();
                }
            }
            catch (InterruptedException | BrokenBarrierException iex)
            {
            }
        }
    };

    Thread r3 = new Thread()
    {
        public void run()
        {
            try
            {
                int i = 0;
                while (i < 3)
                {
                    System.out.println("Goodbye, " + "cruel world!");
                    Thread.sleep(2000L);
                    i++;
                    gate.await();
                }
            }
            catch (InterruptedException | BrokenBarrierException iex)
            {
            }
        }
    };

    r2.start();
    r3.start();
    gate.await();
    System.out.println("Donew");

Answer 1

您可以使用Thread.join() 等待子进程/线程完成。 你不应该需要CyclicBarrier。

Answer 2

你的问题是你在反复等待三方，但只有两个线程在反复调用await()。我希望您的代码立即打印出“再见，残酷的世界！”两次，然后“完成”，然后挂起，因为循环正在等待第三个线程再次调用await()，但主线程现在已经终止。

一种解决方案是让您的主线程循环，调用await() 的次数与您的任务执行的次数相同。但这会有点丑陋。

我建议使用ExecutorService 的invokeAll() 方法。这将在（大约）同一时间将您的任务提交给服务，然后阻塞直到所有任务完成。如果您想尝试提高任务开始的同时性，可以添加CyclicBarrier，但看起来您更关心任务何时结束，invokeAll() 会为您处理。

final class Sample
  implements Callable<Void>
{

  private static final int ITERATIONS = 3;

  private static final long AVG_TIME_MS = 2000;

  public static void main(String[] args)
    throws InterruptedException
  {
    List<Sample> tasks = Arrays.asList(new Sample(), new Sample());
    ExecutorService workers = Executors.newFixedThreadPool(tasks.size());
    for (int i = 1; i <= ITERATIONS; ++i) {
      /* invokeAll() blocks until all tasks complete. */
      List<Future<Void>> results = workers.invokeAll(tasks);
      for (Future<?> result : results) {
        try {
          result.get();
        }
        catch (ExecutionException ex) {
          ex.getCause().printStackTrace();
          return;
        }
      }
      System.out.printf("Completed iteration %d.%n", i);
    }
    workers.shutdown();
    System.out.println("Done");
  }

  @Override
  public Void call()
    throws InterruptedException
  {
    /* The average wait time will be AVG_TIME_MS milliseconds. */
    ThreadLocalRandom random = ThreadLocalRandom.current();
    long wait = (long) (-AVG_TIME_MS * Math.log(1 - random.nextDouble()));
    System.out.printf("Goodbye, cruel world! (Waiting %d ms)%n", wait);
    Thread.sleep(wait);
    return null;
  }

}

请注意我是如何通过随机等待时间来增加趣味性的。然而，invokeAll() 一直等到该迭代中的所有任务完成。

Answer 3

1. 单处理器机器是不可能的。
2. 即使您在线程上找到很多答案，它也不会同时启动两个进程
3. 如果您接受Relative Simultanity，那就很容易了。