When to join threads with CountDownLatch

In my previous post When to join threads, Thread.join() is used to wait for all child threads to complete. Now I will update it using CountDownLatch instead:

package test.concurrent;
import java.util.Vector;
import java.util.concurrent.CountDownLatch;

public class ThreadTest {
    private Vector<String> threadNames = new Vector<String>();
    public static void main(String[] args) {
        ThreadTest test = new ThreadTest();
        test.threadTest(Integer.parseInt(args[0]));
        System.out.println(test.threadNames);
    }

    private void threadTest(int numOfThreads) {
        final CountDownLatch latch = new CountDownLatch(numOfThreads);
        Thread[] threads = new Thread[numOfThreads];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new ThreadTest.MyThread(latch);
            threads[i].start();
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private class MyThread extends Thread {
        private final CountDownLatch latch;
        public MyThread(CountDownLatch latch) {
            this.latch = latch;
        }

        @Override public void run() {
            for (int i = 0; i < 1000000; i++) {
                i = i + 0;
            }
            threadNames.add(getName());
            latch.countDown();
        }
    }
}

A CountDownLatch is created in main thread, passed to each child thread's constructor. Each child thread will count down by 1. After starting all child threads, the main thread then wait for the latch count to reach 0. To run it:

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