对并行线程组执行顺序操作

Question

我有以下情况需要尽快改变：

1. 执行一组顺序线程(包含3个线程)
2. 执行另一组顺序线程(包含2个线程)。
3. 执行一组并行线程(包含9个线程，以便正确应用线程的生产者-使用者方法)

我为什么要创建这个场景？

要先执行一个特定的线程(点-1:包含3个线程)，在完成它们的处理之后，我需要再执行2个线程(点-2:包含2个线程)。当且仅当1点和2点包括在内，我需要处理第3点。

最初，我需要执行所有线程来处理并行操作，但我保留了这个想法，因为并行线程将同时执行。

​

在上述情况下，一切都很顺利，直到出现问题。

为什么我需要改变上面的场景？

有时，我会得到一个异常，它可以在并行线程情况下很好地处理。而同样的异常，如果我进入顺序线程，就会变得无法处理。因为，顺序线程的所有其他处理都处于等待状态，直到第一个线程完成。

​

因此，我需要利用并行线程的好处，但我选择这种方式变得很容易，这对于应用程序来说已经成为一个很难处理的情况。

因此，我需要创建这样一个场景，在这个场景中，我应该为一个固定的顺序执行不同的并行线程。例如：

​

Order-1=处理前3个并行线程 Order-2=处理下两个并行线程 Order-3=处理接下来的9个并行线程

另外，上面的情况有些限制，尽管我需要一个通用的解决方案。就像将来我希望从Order-1中再添加2个线程一样，或者，如果我为任何顺序删除了一些线程，那么组的序列应该按需要执行。

在java中，是否有任何方法可以使一组并行线程能够执行我们指定的任何顺序？

编辑

如果您可以帮助我修改，我有以下代码片段：

// Level-1

Thread[] threads = new Thread[list1.size()];
int j=0;
for(list1.size()){
    Object delegator1 = new Object("Level-1");
    Thread th = new Thread(delegator1);
    threads[j]=th;
    th.start();

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

// 2级

threads = new Thread[list2.size()];
j=0;
for(list2.size()){
    Object delegator2 = new Object("Level-2");
    Thread th = new Thread(delegator2);
    threads[j]=th;
    th.start();

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

// Level-3 &4->应用生产者--消费者使用等待-通知工作正常。

for(list3.size()){
    Object delegator3 = new Object("Level-3 & 4")
    Thread th = new Thread(delegator3);
    th.start();
}

我希望这些不同的级别并行执行，但如果第一级结束，则第二级应在其后执行。

Answer 1

如果您只想等待一组线程完成，可以在主线程中使用一个CountDownLatch，初始化为线程的数量。然后，主线程等待每个线程完成并通知闩锁。

下一组重复一遍。

最终解决了我的问题。

Answer 2

所以看起来你的订单实例有一些状态。状态是-1，2，3，失败了。

您可以使用生产者-消费者队列来实现这些状态(甚至是所有状态的单个队列)。根据操作的结果，实例被移动到“next”队列，该队列由所需的线程数量来处理。

当使用单个队列时，处理它的一种可能方法可能是包含计算的信封对象，如

class Order1Processor implements Runnable {
     Object delegate;
     Order1Processor(Object delegate) { this.delegate = delegate; }
     public void run() { 
       try {
          // do the Order-1st processing
          doSomethingWith(delegate);
          // submit to next free Thread for Order-2nd processing
          submitToQueue(new Order2Processor(delegate));
       } catch (Throwable t) {
          // signal/handle failure
          submitToQueue(new FailedProcessor(delegate, t))
       }
 }


}  
class Order2Processor .. 

现在，您可以使用任意数量的线程来处理订单。一个队列允许您根据需要自动分配尽可能多的重新源，这取决于当前要做的工作。如果您对订单或操作有一些订单或操作，则甚至可以使用PriorityQueue，这些订单或操作必须更早地或按特定顺序处理。