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

【问题标题】：Performing sequential operations for groups of Parallel Threads对并行线程组执行顺序操作
【发布时间】：2013-02-26 07:28:56
【问题描述】：

我有以下情况需要尽快更改：
1.一组顺序线程执行（包含3个线程）
2.另外一组顺序线程执行（包含2个线程）
3.一组并行线程执行（包含9个线程，正确应用线程的生产者-消费者方法）

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

要先执行一个特定的线程（point-1：包含 3 个线程），在它们的处理完成后，我需要执行另外 2 个线程（point-2：包含 2 个线程）。当且仅当第 1 点和第 2 点被涵盖时，我才需要处理第 3 点。

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

对于上述情况，一切正常，直到出现问题。

为什么我需要更改上述情况？

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

所以，我需要利用并行线程的好处，但我选择了这种简单的方式，这对于应用程序来说是一个难以处理的情况。
所以，我需要创建这样一个场景，在这个场景中我应该以固定的顺序执行不同的并行线程。例如：

Order-1st = 处理前 3 个并行线程
Order-2nd = 处理接下来的 2 个并行线程
Order-3rd = 处理下一个 9个并行线程

此外，上述情况有些限制，尽管我需要一个通用的解决方案。就像将来我想从 Order-1 中再添加 2 个线程，或者，如果我什至为任何顺序删除了一些线程，则组的序列应该按需要执行。
java中是否有任何方法可以让我们创建一组并行线程，以便它们可以按照我们指定的任何顺序执行？

编辑
如果您可以帮助我修改，我有以下代码sn-p：

// 一级

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 --> Applied Producer-Consumer 使用 wait-notify 工作正常。

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

我希望这些不同的级别并行执行，但如果第一级完成，第二级应该随后执行。

【问题讨论】：

你试过多级生产者消费者吗？我的意思是 Order-1 将成为 Order-2 的生产者，而 Order-2 将成为 Order-3 线程组的消费者。
不，我没有尝试多级生产者消费者。因为这样执行的线程数将受到限制。意思是，如果将来我需要向 Level-1 添加大约 50 多个线程，则不应进行代码更改。如果我们可以在不更改任何代码的情况下处理，那么请帮助我维护这个层次结构。
并非如此，您始终可以通过某些属性文件来保持可配置的线程数。应用程序将在启动时读取配置。

标签： java multithreading ipc

【解决方案1】：

所以看起来您的订单实例有一些状态。状态是Order-1、Order-2、Order-3和失败。

您可以使用 Producer-Consumer-Queues 来实现这些状态（甚至是一个单一的队列）。根据您的操作结果，实例将移至“下一个”队列，该队列由您需要的线程数量处理。

当使用单个队列时，一种可能的处理方式可能是包含计算的 Envelope-Object，例如

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。

【讨论】：

好的，这似乎是可行的。如果在处理上述解决方法时出现任何问题，我会通知您。

【解决方案2】：

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

重复下一组。

这最终解决了我的问题。

【讨论】：