并行运行 100 个线程，如果之前的线程已完成，则运行缺失的线程

Question

例如，我需要始终运行 100 个线程来执行某些操作。 我有一个名为 ThreadsWorker 的类，它查找线程计数并在前面的一些线程完成时运行丢失的线程。 因此，这是描述情况的表格：

1 second: 100 threads
2 second: 92 threads (ThreadsWorker generates new 8 threads)
3 second: 100 theads
4 second: 72 threads (ThreadsWorker generates 28 threads)

等等。 我的线程是匿名调用（只是 new Thread(new Runnable(...)).start()），因为我不知道如何正确地将它们保存到 Threads[] 数组，因为虽然 ThreadsWorker 会保存 threads[i] = new Threads()，但某些线程可能会完成，然后会与数组索引发生一些冲突。

由于匿名调用，我现在使用 threadsCount 变量，并在线程主体开始处递增它，并在线程主体结束处递减（使用 synchronized）。好的，它工作正常，我的唯一方法是使用 while() 循环，在进度完成时检查 threadsCount == 0 是否。

我认为这是 C 风格，而不是 Java 风格:)那么，你能帮我用 Java 风格来做吗？

Answer 1

如果您的目标只是让 100 个线程主动处理，我建议查看 Java 线程池 （以及更一般的执行器）。

我不清楚您是要让所有 100 个线程继续运行还是等待它们全部完成。您的问题同时引用了两者（ThreadsWorker 生成 28 个新线程，threadsCount==0），它们似乎是矛盾的。

Answer 2

将所有线程放入数组或集合中。

然后循环遍历集合，对每个集合调用 Thread.join() 。当这个循环完成时，所有线程都完成了。

ArrayList threads = new ArrayList();
for (int i = 0; i < 5; i++) {
  Thread t = new AweseomeThread();
  t.start();
  threads.add(t);
}

for (Thread t : threads) {
  t.join();
}

您还需要一些异常处理（例如 InterruptedException）。但是，我会将其作为读者的练习......:)

Answer 3

http://download.oracle.com/javase /6/docs/api/java/util/concurrent/CountDownLatch.html

你可以尝试类CountDownLatch jdk api

private CountDownLatch latch;
private static class SimpleThread extends Thread {
 public void run() {
  latch.countDown();
 }
}
public static void main(String[] args) {
 int threadcount = 10;
 latch = new CountDownLatch(threadcount);
 for (int i = 0; i < 10; i++) {
  Thread t = new SimpleThread();
  t.start();
 }
 // waiting threads all finished
 latch.await();
}

从属性latch中获取线程计数主班

Answer 4

我相信您正在尝试让 ThreadWorker 为所有已完成的线程提交新线程。

我会使用一个 BlockingQueue，线程（您的可运行对象）在完成时添加到其中。 ThreadWorker 将等待一个线程完成，然后启动一个新线程。

public class YourRunnable implements Runnable {
  private final BlockingQueue<YourRunnable> queue;
  public YourRunnable(BlockingQueue<YourRunnable> queue){
    this.queue = queue;
  }
  public void run{
      // Your Code...
      // Finished Processing
      queue.add(this);
  }
}
public class ThreadWorkder implements Runnable { 
  private final BlockingQueue<YourRunnable> queue;
  ThreadWorker(BlockingQueue<YourRunnable> queue){
    this.queue = queue;
  }
  public void run{
    while(queue.take()){
       (new Thread(new YourRunnable(queue))).start();
    }
  }
  // general main method
  public static void main(String [] args){
    BlockingQueue<YourRunnable> queue = new LinkedBlockingQueue<YourRunnable>();
    ThreadWorker worker = new ThreadWorker(queue);
    Thread(worker).start();
    for (int i = 0; i < 100; i++){
      (new Thread(new YourRunnable(queue))).start();
    }
  }
}

Answer 5

使用集合而不是数组。当线程完成时，让它们从数组中删除自己。像这样的事情：

public class Foo {
  Vector<Thread> threads = new Vector<Thread>(); //Vector is threadsafe

  public ensureThreadCount(int count) {
    while (threads.size() < count) {
      Thread t = new AweseomeThread(threads);
      threads.add(t);
      t.start();
    }
  }
}

public class AwesomeThread {
  Collection threads;
  public AwesomeThread(Collection threads) {
    this.threads = threads;
  }

  public void run() {
    try {
      // do stuff
    } catch (Throwable t) {
    } finally {
      threads.remove(this);
    }
  }
}

然后，让你的工作人员调用 Foo.ensureThreadCount()。