Here is another way of having the main thread wait for all child threads to complete, using java.util.concurrent.FutureTask and Callable.

package test.concurrent;  
 import java.util.Vector;  
 import java.util.concurrent.*;  
 
public class FutureTaskTest {  
   private Vector<String> threadNames = new Vector<String>();  
   public static void main(String[] args) {  
     FutureTaskTest test = new FutureTaskTest();  
     test.threadTest(Integer.parseInt(args[0]));  
     System.out.println(test.threadNames);  
   }  

   private void threadTest(int numOfThreads) {  
     Thread[] threads = new Thread[numOfThreads];  
     FutureTask<String>[] futureTasks = new FutureTask[numOfThreads];  
     for (int i = 0; i < threads.length; i++) {  
       futureTasks[i] = new FutureTask<String>(new MyCallable());  
       threads[i] = new Thread(futureTasks[i]);  
       threads[i].start();  
     }  
     for (FutureTask<String> f : futureTasks) {  
       try {  
         threadNames.add(f.get());  
       } catch (InterruptedException e) {  
         e.printStackTrace();  
       } catch (ExecutionException e) {  
         e.printStackTrace();  
       }  
     }  
   }  

   private static class MyCallable implements Callable<String> {  
     public String call() {  
       for (int i = 0; i < 1000000; i++) {  
         i = i + 0;  
       }  
       return Thread.currentThread().getName();  
     }  
   }  
 }

FutureTask is usually used along with ExecutorService, but it can also be passed to Thread constructor. The output is always in the order from thread-0 to thread-9, because when we iterate through futureTasks to get result, each get() call wait for a certain duration for the result to be published by child thread.

$ java test.concurrent.FutureTaskTest 10
[Thread-0, Thread-1, Thread-2, Thread-3, Thread-4, Thread-5, Thread-6, Thread-7, Thread-8, Thread-9]

The Vector field threadNames can also be replaced with ArrayList, since it is only accessed in the main thread and no synchronization is needed.