Java中的线程作业

我想在Java中同时产生200个线程。我现在正在做的是运行一个循环，创建200个线程并启动它们。在这200个线程完成后，我想再生成200组线程，以此类推

这里的要点是，我生成的前200个线程需要在生成下一组之前完成。我尝试了下面的代码，但它不起作用

for(int i=0;i<200;i++){
    Thread myThread = new Thread(runnableInstance);
    myThread.start();
}
for(int i=0;i<200;i++){
    Thread myThread = new Thread(runnableInstance);
    myThread.start();
}

---

for（int i=0；i您需要使用
join（）等待线程完成：

//运行第一组线程
List threads=threadsList；//保存对所有线程的引用
用于（螺纹t：螺纹）{
t、 join（）；
}
//所有螺纹均已完成
//运行其他线程集
您应该保留一个已创建线程的列表。一旦启动了所有线程，就可以在列表上循环，并对每个线程执行
连接。当连接循环完成时，所有线程都将运行到完成

List<Thread> threads = new List<Thread>();
for(int i=0;i<200;i++){
    Thread myThread = new Thread(runnableInstance);
    myThread.start();
    threads.add(myThread);
}
//All threads are running
for(Thread t : threads) {
    t.join();
}
//All threads are done

List threads=newlist（）；
因为（inti=0；i感觉像是在做家务，但是

spawnAndWait() {
 Thread T[] = new Thread[n];
 for(int i=0;i<n;i++){
     T[i] = new Thread(runnableInstance);
     T[i].start();
 }
 for (Thread t : T) {
  t.join();
 }
}

spawnAndWait（）{
螺纹T[]=新螺纹[n]；
对于（inti=0；i如果您使用的是Java1.5，请使用concurrent软件包，如果您使用的是Java1.4.2，那么该软件包仍然可以作为后端口使用，我非常确定

话虽如此，我最近也有一个类似的任务要做；你可以很容易地完成它，通过使用它来知道你的任务是否完成。非常干净的模式-可能不完全是你想要实现的，但在现实生活中它工作得非常好：-）

一些代码：

BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
taskExecutor = new ThreadPoolExecutor(200, 200, 30, TimeUnit.SECONDS, workQueue);

futureList.add(taskExecutor.submit(new MyCallable()));

for (Future<Object> future : futureList) {
    future.get(); // wait for the task to complete
}

//... instantiate your second group of executors

BlockingQueue workQueue=新建LinkedBlockingQueue（）；
taskExecutor=新的ThreadPoolExecutor（200、200、30，TimeUnit.SECONDS，workQueue）；
添加（taskExecutor.submit（newmyCallable（））；
for（未来：未来列表）{
future.get（）；//等待任务完成
}
//…实例化第二组执行者
某种伪代码，acnt实例关联可调用；-）

while（更多线程）{
List threads=new ArrayList（）；
对于（int i=0；i<200；++i）{
添加（newcallable（））；
}
FixedThreadPool=Executers.newFixedThreadPool（200）；
pool.invokeAll（线程）；
pool.shutdown（）；
}
另一种解决方案是使用闩锁

final CountDownLatch latch = new CountDownLatch(200);

  for(int i=0; i<10; i++)
{

 Thread thread = new Thread()
{
    public void run()
{
     try{
         //do your work  

     }finally{
      latch.countDown();
     }
    }
   };

     }  
            //will block here util your threads all finished
  latch.await();

最终倒计时闩锁=新倒计时闩锁（200）；
对于（int i=0；我真的希望您使用200作为“一个非常大的数字”的示例。我能想到的任务很少会使用200个相同的线程。请小心，在某些版本的Linux上，200个线程已经接近生成的限制。在Windows上，您应该能够生成接近2000个线程。（这两个值都是通过尝试和错误找到的）。当我对不同的设备进行大量同步SNMP访问时，我必须这样做——CPU可以轻松处理上千个未完成的请求。然而，一旦NIO出现，异步显然是一个更好的选择，并且可以扩展得更高。@Bill K:Linux/Java的哪个版本以及为什么会这样？你是在谈论上个世纪的1.3 Java虚拟机？Linux上的AFAIK Java多年来一直使用NPTL，并且Linux已经证明能够在不到两秒钟的时间内扩展到100000个NTPL线程。现在可能存在内核或glibc限制（如果我没有弄错的话，默认为1024个），但用更高的值重新编译是很简单的。除非你给出更详细的解释，否则我称之为FUD。@Bill K:刚刚在我的Linux工作站上试用过：默认情况下，在不更改任何参数的情况下，我可以启动近4000个Java线程。简单的重新编译，我会让这个数字保持在5位（见鬼，在我普通的工作站上甚至可能有六个）。所以，是的，我真的把“200个线程相当接近在某些Linux版本上产生的极限”称为“胡说八道”。需要解释，因为你肯定不是在说“常规的”Linuxes/JVM。我很难想象Linux版本不支持超过200个NPTL。@WizardOfOdds很好，谢谢。当我尝试这一点时，它是在大约199x年或2000年初的Red Hat Linux上，所以可能情况已经改变了。我撤销了我的警告：）值得注意的是，有一个限制，它是OS和OS配置依赖的。而且，我倾向于考虑大约1/2个线程，我可以启动“极限”。因为在那之后，回收有时不够快，有时我因为它而无法创建新线程。所以windows实际上更接近4k，linux更接近400…我没有否决，但你在循环中的加入意味着它将等待每个线程完成，然后再开始下一个…你已经序列化了那200个线程。哟你需要在启动它们后加入。CPerkins-不正确，此代码段只是在线程上迭代并
join（）
s它们。无论如何@unholysampler有一个更好的代码段。请单击
edit
链接并检查右列信息以了解格式规则：）轻微键入：for（线程t:Thread）应该是for（线程t:threads）
while( moreThreads ) {
    List<Callable<Integer>> threads = new ArrayList<Callable<Integer>>();
    for( int i = 0; i < 200; ++i ) {
        threads.add(new Callable<Integer>() );
    }

    FixedThreadPool pool = Executers.newFixedThreadPool(200);
    pool.invokeAll(threads);
    pool.shutdown();
}

final CountDownLatch latch = new CountDownLatch(200);

  for(int i=0; i<10; i++)
{

 Thread thread = new Thread()
{
    public void run()
{
     try{
         //do your work  

     }finally{
      latch.countDown();
     }
    }
   };

     }  
            //will block here util your threads all finished
  latch.await();