1.5 has some nifty tools for such a situation, but you can solve it in
1.4 by using some kind of "counter" of active threads. You "main" thread
wait()s on the counter, and each thread increments it when it starts,
and decrements it once it stops. notifying the main Thread if the
counter reaches 0.

for (int j = 0; j < threads.length; j++) {
    threads[j].join();
}

Ok, a full example:
<code>
public class WaitTest{
 public static void main(String[] args) throws InterruptedException {
   System.out.println("[main thread] Main thread started.
Constructing and starting threads...");
   Thread[] threads = new Thread[10];
    for (int j = 0; j < threads.length; j++)   {
       threads[j] = new Thread(task, "Task_"+j);
       System.out.println("[main thread] Starting task #"+j);
       threads[j].start();
    }
    System.out.println("[main thread] waiting for all the tasks to
complete...");
     for (int j = 0; j < threads.length; j++)  {
        threads[j].join();
     }
     System.out.println("[main thread] All tasks completed, can go on
with the main algorithm :)");
  }//end of main

static Runnable task = new Runnable() {
 public void run()  {
  long sleeptime = 1000+(int)(4000*Math.random());
  System.out.println(Thread.currentThread().getName()+" doing some
lenghty operation. It will take at least "+sleeptime+" ms");
  try   {
                        Thread.sleep(sleeptime);
  }catch(InterruptedException e){}//ignoring
  System.out.println(Thread.currentThread().getName()+" done!");
 }
};
}

Creating threads is expensive, no matter in what environment.
You surely can reuse the threads across servet invocation - but you
have to implement a thread pool yourself (or download such a beast),
there is no such thing in core library.

Other thing is that reusable threads usually never end their run()
method,
but wait() for their next use after finishing one task, so will never
join().
You have an idea of solution for such situation in other posts.
(main thread should wait() to stop executing; task that
completes as the last one should notify() the main thread to go on).

Adam

The usual approach is to use join() to wait until they've all finished:

   // start them all
   for(int j = 0 ; j < threads.length ; j++) {
       threads[j].start();
   }
   // wait for them all to finish
   for(int j = 0 ; j < threads.length ; j++) {
       threads[j].join();
   }

You can create a thing called a thread pool, but for a first go, it's
easier just to make threads when you need them. Threads are not very
expensive in java, but I have heard that "hundreds" of threads can get
bogged down in task switching.

Steve