Question

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

为什么我创建了这种情况？

首先执行特定线程（第1点：包含3个线程），在完成处理后，我需要执行另外2个线程（第2点：包含2个线程）。当且仅当1和2点被覆盖时，我需要处理第3点。

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

对于上述情况，一切都在顺利进行，直到出现问题为止
为什么我需要更改上述方案？

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

所以，我需要利用并行线程，但我选择这种方式很容易，这对于应用程序来说已经变得很难处理了。
所以，我需要创建一个这样的场景，我应该为固定的顺序执行不同的并行线程。例如：

Order-1st =处理前3个并行线程
Order-2nd =   处理接下来的两个并行线程
Order-3rd =处理下一个   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();
}

// Level-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＆amp; 4 - ＆gt;应用生产者 - 消费者使用等待通知工作正常。

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

我想要并行执行这些不同的级别，但如果第一级别完成，那么此后应执行第二级别。

Answer 1

所以看起来你的Order-Instances有一些状态。状态为 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。

Answer 2

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

重复下一组。

这最终解决了我的问题。

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

2 个答案: