Count Down Latch explanation

Very important paragraph on how the CountDownLatch works.
CountDownLatch is a flexible latch implementation that can be used in any of these situations; 
it allows one or more threads to wait for a set of events to occur. The latch state consists of a counter initialized 
to a positive number, representing the number of events to wait for. The countDown method decrements the counter, 
indicating that an event has occurred, and the await methods wait for the counter to reach zero, which happens 
when all the events have occurred. If the counter is nonzero on entry, await blocks until the counter reaches zero, 
the waiting thread is interrupted, or the wait times out.
The following 2 paragraphs are very important on explaining an example how we use CountDownLatch
TestHarness illustrates two common uses for latches. TestHarness creates a number of threads 
that run a given task concurrently. It uses two latches, a "starting gate" and an "ending gate". The starting gate is 
initialized with a count of one; the ending gate is initialized with a count equal to the number of worker threads. 
The first thing each worker thread does is wait on the starting gate; this ensures that none of them starts working 
until they all are ready to start. The last thing each does is count down on the ending gate; this allows the master 
thread to wait efficiently until the last of the worker threads has finished, so it can calculate the elapsed time.
 
Why did we bother with the latches in TestHarness instead of just starting the threads immediately after they are created? 
Presumably, we wanted to measure how long it takes to run a task n times concurrently. If we simply created and 
started the threads, the threads started earlier would have a "head start" on the later threads, and the degree of 
contention would vary over time as the number of active threads increased or decreased. Using a starting gate allows 
the master thread to release all the worker threads at once, and the ending gate allows the master thread to wait for the 
last thread to finish rather than waiting sequentially for each thread to finish.

1)    The main thread start many threads, and let all of them await the startGate
2)    The main thread countdown the startGate---release them all
3)    The main thread await the endGate
4)    Every thread ends, the thread will countdown the endGate
5)    When all the threads finished, the main thread will be released to the next 
code line—which calculate the long end, calculate the total execution time.

public class TestHarness {
    public long timeTasks(int nThreads, final Runnable task)
            throws InterruptedException {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);
 
        for (int i = 0; i < nThreads; i++) {
            Thread t = new Thread() {
                public void run() {
                    try {
startGate.await();//await() means current thread holds on
                        try {
                            task.run();
                        } finally {
//if countdown() reaches 0, release all threads waiting on this gate
                            endGate.countDown();
                        }
                    } catch (InterruptedException ignored) { }
                }
            };
            t.start();
        }
 
        long start = System.nanoTime();
        startGate.countDown();
        endGate.await();
        long end = System.nanoTime();
        return end-start;
    }
}