Question

我正在做大学任务（坦率地说）。问题是我应该在任何时候运行4个客户端线程（上升数字n）。因此，当任何线程终止时，必须生成一个新线程。

  public static void main(String[] args) throws IOException,InterruptedException

   {
     /* some declarations.. */

     ClientThread client=new ClientThread ();

 Runnable intr =client;

 for(count=1;count<=number;count++)

 {
                 /* If 4 client threads has been spawned, wait until 1 of them exits */
           while(Thread.activeCount()<5) 
            ;
            new Thread(intr).start();
   }


       /* Wait until all other threads exits. */
       while(Thread.activeCount()!=1)
        ;   

 System.out.println("\n The sum of factorials is: "+client.getResult());
   }

我想删除忙碌等待，因为它违背了我的程序的目的。我如何制作主线程wait ?? （它显示wait是非静态方法，不能从静态方法调用。）请帮忙。

Answer 1

java.util.concurrent。 CountDownLatch 专为您的情况而设计。

定义CountDownLatch doneSignal = new CountDownLatch(4);

doneSignal.await()将等到doneSignal.countDown()被调用四次。因此，当doneSignal退出时，让ClientThread持有相同的引用run()，请致电doneSignal.countDown()。

class ClientThread implements Runnable {
   private final CountDownLatch doneSignal;
   ClientThread (CountDownLatch doneSignal) {
      this.doneSignal = doneSignal;
   }
   public void run() {
      try {
        //Do something
        doneSignal.countDown();
      } catch (InterruptedException ex) {} 
   }
 }
...
//In main thread
doneSignal.await();

Answer 2

嗯 - 您是否必须手动完成或您的老师希望您发现Executors.newFixedThreadPool(4)？

这正是具有四个工作线程的线程池所能做的：并行运行四个客户端，如果一个终止，则free'd工作线程已准备好“获得新工作”。

这很简单：

public void test(int threads, int runnables) {
  ExecutorsService pool = Executors.newFixedThreadPool(threads);
  Runnable r = new Runnable() {
     public void run() {
       // calculate a factorial or do something else
       System.out.println(Thread.currenThread());
     }
  }
  for (int i = 0; i < runnables; i++)
    pool.execute(r);
}

让runnables大于threads，您将从结果中看到最多threads个线程被（重新）用于执行runnables。

Answer 3

您可以在主类中编写一个回调方法，该方法由一个退出的线程调用并生成一个新的回调方法。通过在主类中使用静态字段，您将跟踪产生的线程数，以获得与当前代码相同的效果。

看起来有点像这样：

class Main{

    private static ClientThread client;
    private static Runnable intr;
    private static int count;

    public static void main(String[] args)
    {
       count = 10; //Or something else
       runningThreads = 0;
       client=new ClientThread ();
       intr =client;
       for(i=0;i<5;i++)
          spawnThread();
    }

    private static void spawnThread()
    {
        Thread newThread;
        if(count>0)
        {
            newThread = new Thread(intr);
            newThread.start();
            count--;
        }

        if(count==0)
            System.out.println("\n The sum of factorials is: "+client.getResult());
    }

Answer 4

看看java.util.concurrent中的@ classes 特别 java.util.concurrent.CountDownLatch java.util.concurrent.locks.Condition中

Answer 5

对于您可以使用的主线程：

Thread.getCurrent().join();

这会在主线程终止之前等待所有生成的线程死掉。

使主线程等待事件

5 个答案: