What is CountDownLatch in Java?

CountDownLatch in Java is a kind of synchronizer which allows one Thread to wait for one or more Threads before starts processing. This is very crucial requirement and often needed in server side core Java application and having this functionality built-in as CountDownLatch greatly simplifies the development. CountDownLatch in Java is introduced on Java 5 along with other concurrent utilities like CyclicBarrier, Semaphore, ConcurrentHashMap and BlockingQueue in java.util.concurrent package. In this Java concurrency tutorial we will learn what is CountDownLatch in Java, How CountDownLatch works in Java, an example of CountDownLatch in Java and finally some worth noting points about this concurrent utility. You can also implement same functionality using wait and notify mechanism in Java but it requires lot of code and getting it write in first attempt is tricky,  With CountDownLatch it can  be done in just few lines. CountDownLatch also allows flexibility on number of thread for which main thread should wait. It can wait for one thread or n number of thread, there is not much change on code.

Class CountDownLatch Demo 

package com.somitsolutions.training.java.ExperimentationWithCountdownLatch;

import java.util.concurrent.CountDownLatch;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CountDownLatchDemo {

   public static void main(String args[]) {
      final CountDownLatch latch = new CountDownLatch(3);
      Thread service1 = new Thread(new Service("Service1", 1000, latch));
      Thread service2 = new Thread(new Service("Service2", 1000, latch));
      Thread service3 = new Thread(new Service("Service3", 1000, latch));
     
      service1.start();

      service2.start();

      service3.start();
     
      // application should not start processing any thread until all service is //up
      // and ready to do there job.
      // Countdown latch is idle choice here, main thread will start with count 3
      // and wait until count reaches zero. each thread once up and read will do
      // a count down. this will ensure that main thread is not started processing
      // until all services is up.
     
      //count is 3 since we have 3 Threads (Services)
     
      try{
           latch.await();  //main thread is waiting on CountDownLatch to finish
           System.out.println("All services are up, Application is starting now");
      }catch(InterruptedException ie){
          ie.printStackTrace();
      }
     
   }
 
}

/**
* Service class which will be executed by Thread using CountDownLatch synchronizer.
*/
class Service implements Runnable{
   private final String name;
   private final int timeToStart;
   private final CountDownLatch latch;
 
   public Service(String name, int timeToStart, CountDownLatch latch){
       this.name = name;
       this.timeToStart = timeToStart;
       this.latch = latch;
   }
 
   @Override
   public void run() {
       try {

//Do all the processing. Here we have just made the thread sleep
           Thread.sleep(timeToStart);
       } catch (InterruptedException ex) {
           Logger.getLogger(Service.class.getName()).log(Level.SEVERE, null, ex);
       }
       System.out.println(