2

我有一个名为 action() 的方法，它部署了三个线程。每个部署的线程或工作线程都基于布尔类型的单个实例变量为 true 进入 while 循环，例如 boolean doWork = true，每个线程将有一个 while(doWork){} 循环。

当一个线程完成该作业时，会将 doWork 设置为 false 以阻止所有线程循环。然后我希望能够以某种方式让主线程调用 action() 方法来重新部署线程来完成另一项工作。（如果我使用其中一个工作线程来调用 action() 方法可以吗？）工作线程会在调用 action() 方法后终止并以某种方式死亡吗？

为简单起见，我将示例限制为两个线程

谢谢

class TestThreads{
    boolean doWork = true;

    void action(){
         ThreadOne t1 = new ThreadOne();
         ThreadTwo t2 = new ThreadTwo();
    }

    //innerclasses

    class ThreadOne implements Runnable{
          Thread trd1;
          public ThreadOne(){//constructor
              if(trd1 == null){
                   trd1 = new Thread(this);
                   trd1.start();
              }
          }
          @Override
          public void run(){
              while(doWork){
                   //random condition
                   //would set doWork = false;
                   //stop all other threads
              }
              action();//is the method in the main class
          }
    }
    class ThreadTwo implements Runnable{
          Thread trd2;
          public ThreadTwo(){//constroctor
              if(trd2 == null){
                   trd2 = new Thread(this);
                   trd2.start();
              }
          }
          @Override
          public void run(){
              while(doWork){
                   //random condition
                   //would set doWork = false;
                   //stop all other threads
              }
              action();//is the method in the main class
          }
    }

}
4

5 回答 5

4

这个实现怎么样：

声明一个类成员doWork、一个当前活动线程的计数器和一个同步对象：

private volatile boolean doWork = true;
private AtomicInteger activeThreads;
private Object locker = new Object();

主要：

while(true) {
    // call action to start N threads
    activeThreads = new AtomicInteger(N);
    action(N);
    // barrier to wait for threads to finish
    synchronized(locker) {
       while(activeThreads.get() > 0) {
           locker.wait();
       }
    }
}

在线程体中：

public void run() {
   while(doWork) {
      ...
      // if task finished set doWork to false
   }

   // signal main thread that I've finished
   synchronized(locker) {
      activeThreads.getAndDecrement();
      locker.notify();
   }
}
于 2012-02-01T17:57:36.930 回答
3

骨架代码

// OP said 3 threads...
ExecutorService xs = Executors.newFixedThreadPool(3);

...

// repeat the following as many times as you want...
// this is the setup for his 3 threads - as Callables.

ArrayList<Callable<T>> my3Callables = new ArrayList<Callable<T>>();
my3Callables.add(callable1);
my3Callables.add(callable2);
my3Callables.add(callable3);

try {
   List<Future<T>> futures = xs.invokeAll(my3Callables );

   // below code may not be needed but is useful for catching any exceptions
   for (Future<T> future : futures) {
      T t = future.get();
      // do something with T if wanted
   }
}
catch (ExecutionException ee) {
  // do something
}
catch (CancellationException ce) {
  // do something
}
catch (InterruptedException ie) {
  // do something
}
于 2012-02-01T17:56:25.993 回答
2

我将扩展我的评论（即使@babernathy 将其添加到他的答案中）。

通常，如果您有一个要执行某些工作的线程池ExecutorService，并且您有一个管理您想要完成的工作项的主线程，则提供了理想的框架。

在你的主对象中，你可以创建一个服务的实例（你想要的线程数），然后当你生成一个工作时，将它提交给服务，服务将从中选择下一个可用线程池并执行它。

如果您依赖于了解特定工作是否已完成，您可以使用类似 a 的东西CountDownLatch来跟踪线程何时完成其工作。我的意思是，这种活动有很多现有的框架，不需要重新经历痛苦......

于 2012-02-01T17:59:04.180 回答
1

没有任何代码给你一个精确的解决方案有点困难。听起来你在描述生产者/消费者模式，你给一组工作线程一些任务，当它们完成后，你给它们更多。

这是一个可以很好地描述要做什么的网页。

另请查看ExecutorService，它允许您提交 Runnables 并执行它们。

于 2012-02-01T17:43:45.193 回答
1

一个简单的解决方案是让主线程休眠：

static boolean doWork = true; // better to use AtomicBoolean

void action() {

    // start workers, which eventually set doWork = false

    while (doWork) {    
        Thread.sleep(/**time in millis**/); // main thread waits for workers
    }

    // logic to run action() again, etc.

}

主线程启动工作人员，定期唤醒以检查它们是否已终止。由于主线程是一个“仲裁者”，它可能不应该仅仅为了被它的一个孩子复活而死。

参考

于 2012-02-01T17:49:22.537 回答