0

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

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

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

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

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

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

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


所以，我需要利用并行线程的好处，但我选择这种方式很容易，这已经成为应用程序难以处理的情况。
所以，我需要创建这样一个场景，在这个场景中我应该以固定的顺序执行不同的并行线程。例如：

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

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

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

// 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 --> Applied Producer-Consumer 使用等待通知工作正常。

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

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

4

2 回答 2

1

所以看起来你的订单实例有一些状态。状态为Order-1、 Order-2、Order-3和Failed。

您可以使用 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。

于 2013-02-26T07:56:15.137 回答
0

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

重复下一组。

这最终解决了我的问题。

于 2013-04-13T07:36:38.590 回答