1     public Semaphore(int permits) {

2         sync = new NonfairSync(permits);

3     }

1     public Semaphore(int permits, boolean fair) {

2         sync = fair ? new FairSync(permits) : new NonfairSync(permits);

3     }

1     public void acquire() throws InterruptedException {

2         sync.acquireSharedInterruptibly(1);

3     }

1     public void acquire(int permits) throws InterruptedException {

2         if (permits < 0) throw new IllegalArgumentException();

3         sync.acquireSharedInterruptibly(permits);

4     }

 import java.util.concurrent.ExecutorService;

 import java.util.concurrent.Executors;

 import java.util.concurrent.Semaphore;

 public class TIJ_semaphore {

     public static void main(String[] args) {

         ExecutorService exec = Executors.newCachedThreadPool();

         final Semaphore semp = new Semaphore(5); // 5 permits

         for (int index = 0; index < 20; index++) {

             final int NO = index;

             Runnable run = new Runnable() {

                 public void run() {

                     try {
                           // if 1 permit avaliable, thread will get a permits and go; if no permit avaliable, thread will block until 1 avaliable

                         semp.acquire(); 
                         System.out.println("Accessing: " + NO);

                         Thread.sleep((long) (10000);

                         semp.release();

                     } catch (InterruptedException e) {

                     }

                 }

             };

             exec.execute(run);

         }

         exec.shutdown();

     }

 public void await() throws InterruptedException {

         sync.acquireSharedInterruptibly(1);

     }

  public boolean await(long timeout, TimeUnit unit)

         throws InterruptedException {

         return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));

     }

 public void countDown() {

         sync.releaseShared(1);

     }

    public Map<String, List<JSONObject>> doDelete(final String reqUri, final HttpHeaders _headers)

          throws RestAPIException

    {

       setMethod(Method.DELETE);

       setUriTemplate(reqUri);

       headers = _headers;

       return processBroadcast();

    }

   private Map<String, List<JSONObject>> processBroadcast() throws RestAPIException

   {

      ...

      final Map<String, SaaSServerContext> dServers = RestRequestSender.deployedServers;

      if (!dServers.isEmpty())

      {

         final CountDownLatch doneSignal = new CountDownLatch(dServers.size());

         ...

         for (final String key : dServers.keySet())

         {

            ...

            executor.submit(new RRSRunnable(doneSignal, context, results, key, totalRecordsCounter));

         }

         try

         {

            if (!doneSignal.await(Configuration.NTS_MDM_API_BROADCAST_TIMEOUT.getInt(), TimeUnit.MINUTES)) // if timeout will retrun false

            {

               XLog.warning("MDM api broadcast timed out after " + Configuration.NTS_MDM_API_BROADCAST_TIMEOUT.getInt()

                     + " minutes. Timeout is set via notes.ini key "

                     + Configuration.NTS_MDM_API_BROADCAST_TIMEOUT.getNotesIniName());

            }

         }

         catch (final InterruptedException ie)

         {

            throw new RestAPIException("Interrupted", ie);

         }

      }

      return results; // if doneSingnal.await has been intrerrupted,  will this line still execute?

   }

class RRSRunnable implements Runnable

   {

      private final CountDownLatch    doneSignal;

      ...

      RRSRunnable(final CountDownLatch doneSignal, final SaaSServerContext context,

                  final Map<String, List<JSONObject>> results, final String serverKey,

                  final MaxRecordCounter recordCounter)

      {

         this.doneSignal = doneSignal;

         ...

      }

      @Override

      public void run()

      {

         ...

         try

         {

            processRequest(responses, context.getHostName(), client, context, recordCounter);

            final long elapsedTime = System.currentTimeMillis() - startTime;

            XLog.fine("Traveler API request completed. orgid=" + orgId + ";request=" + reqUri + ";pool=" + serverKey

                  + ";time=" + elapsedTime + "ms");

         }

         catch (final RestAPIException rae)

         {

            exceptionServerKey = serverKey;

            exception = rae;

         }

         finally

         {

            doneSignal.countDown();

         }

      }

   }

    public boolean start(final Object obj)

    {

       final long timeStart = System.currentTimeMillis();

       boolean rv = false;

       Barrier b = null;

       synchronized (this)

       {

          if (!latched.containsKey(obj))

          {

             b = new Barrier("Latch:" + name + "_Obj:" + obj, 1);

             latched.put(obj, b); // latched is a synchronizedHashMap

             rv = true;

          }

       }

       XLog.exiting("name=" + name, "obj=" + obj, "barrier=" + b, "rv=" + rv, ("Elapsed time="

             + (System.currentTimeMillis() - timeStart) + "ms"));

       return rv;

    }

    public void finish(final Object obj, final Object result)

    {

       final long timeStart = System.currentTimeMillis();

       final Barrier b;

       synchronized (this)

       {

          b = latched.remove(obj);

          if (null != b)

          {

             // there are waiters that need the result

             b.result = result;

             try

             {

                b.enter(0);

             }

             catch (final InterruptedException e)

             {

                // ignored

             }

          }

       }

       XLog.exiting("name=" + name, "obj=" + obj, "result=" + result, "barrier=" + b, ("Elapsed time="

             + (System.currentTimeMillis() - timeStart) + "ms"));

    }

     /** The lock for guarding barrier entry */

     private final ReentrantLock lock = new ReentrantLock();

     /** Condition to wait on until tripped */

     private final Condition trip = lock.newCondition();

1     public CyclicBarrier(int parties) {

2         this(parties, null);

3     }

1    public CyclicBarrier(int parties, Runnable barrierAction) {

2         if (parties <= 0) throw new IllegalArgumentException();

3         this.parties = parties;

4         this.count = parties;

5         this.barrierCommand = barrierAction;

6     }

 public int await() throws InterruptedException, BrokenBarrierException {

        try {

            return dowait(false, 0L);

        } catch (TimeoutException toe) {

            throw new Error(toe); // cannot happen

        }

    }

1     public int await(long timeout, TimeUnit unit)

2         throws InterruptedException,

3                BrokenBarrierException,

4                TimeoutException {

5         return dowait(true, unit.toNanos(timeout));

6     }

  private int dowait(boolean timed, long nanos)

         throws InterruptedException, BrokenBarrierException,

                TimeoutException {

         final ReentrantLock lock = this.lock;

         lock.lock();

         try {
               final Generation g = generation;

             ...

             if (Thread.interrupted()) {

                 breakBarrier();

                 throw new InterruptedException();

             }

             int index = --count;

             if (index == 0) {  // tripped

                 boolean ranAction = false;

                 try {

                     final Runnable command = barrierCommand;

                     if (command != null)

                         command.run();

                     ranAction = true;

                     nextGeneration();

                     return 0;

                 } finally {

                     if (!ranAction)

                         breakBarrier();

                 }

             }

             // loop until tripped, broken, interrupted, or timed out

             for (;;) {

                 try {

                     if (!timed)

                         /* The lock associated with this Condition is atomically
                              released and the current thread becomes disabled for thread scheduling
                              purposes */
                           trip.await();

                     else if (nanos > 0L)

                         nanos = trip.awaitNanos(nanos);

                 } catch (InterruptedException ie) {

                     if (g == generation && ! g.broken) {

                         breakBarrier();

                         throw ie;

                     } else {

                         // We're about to finish waiting even if we had not

                         // been interrupted, so this interrupt is deemed to

                         // "belong" to subsequent execution.

                         Thread.currentThread().interrupt();

                     }

                 }

                 if (g.broken)

                     throw new BrokenBarrierException();

                 if (g != generation)

                     return index;

                 if (timed && nanos <= 0L) {

                     breakBarrier();

                     throw new TimeoutException();

                 }

             }

         } finally {

             lock.unlock();

         }

     }

     private void breakBarrier() {

         generation.broken = true;

         count = parties;

         trip.signalAll();

     }

  public Connection getConnection(final boolean highpriority) throws SQLException

    {

       final long sTime = System.currentTimeMillis();

       Connection conn = null;

       boolean createConnection = false;

       boolean waitConnection = false;

       try

       {

          while (true)

          {

             createConnection = false;

             waitConnection = false;

             synchronized (dbConnections)

             {

                final List<Connection> dbConnectionsToBeFreedTemp = new ArrayList<Connection>();

                synchronized (dbConnectionsToBeFreed)

                {

                   if (!dbConnectionsToBeFreed.isEmpty())

                   {

                      dbConnectionsToBeFreedTemp.addAll(dbConnectionsToBeFreed);

                      dbConnectionsToBeFreed.clear();

                      if (1 == dbConnectionsToBeFreedTemp.size())

                      {

                         // only one, so only notify one

                         dbConnectionsToBeFreed.notify();  // Semaphore.release()

                      }

                      else

                      {

                         dbConnectionsToBeFreed.notifyAll(); // CountDownLatch.await()

                      }

                   }

                   if (isThrottDown && connectionCount <= Tier.ONE.value * .20F)

                   {

                      isThrottDown = false;

                      dbConnectionsToBeFreed.notifyAll();

                   }

                }

                if (!dbConnectionsToBeFreedTemp.isEmpty())

                {

                   for (final Connection connToFree : dbConnectionsToBeFreedTemp)

                   {

                      if (!closeConnectionIfAgedOut(connToFree))

                      {

                         dbConnections.add(connToFree);

                      }

                   }

                   dbConnectionsToBeFreedTemp.clear();

                }

                if (Configuration.NTS_DB_CONNECTION_THROTTLING.getBoolean())

                {

                   getCurrentTier();

                   if ((!dbConnections.isEmpty() && !isThrottDown)

                         && (highpriority || ((connectionCount - dbConnections.size()) < currentTier.value))) //Prevent non-high priority requests from grabbing freed high priority connections if connection is capped

                   {

                      conn = dbConnections.remove(0);

                   }

                   if (null == conn)

                   {

                      // See if we should create a new connection or have to wait

                      // if none are in the stack, then see if we should make another

                      if ((connectionCount < currentTier.value || (highpriority && (connectionCount < maxConnectionCount)))

                            && !isThrottDown)

                      {

                         createConnection = true;

                         connectionCount++;

                      }

                      else if (!isScheduled && conn == null && !highpriority && !createConnection

                            && currentTier != Tier.THREE && !isThrottDown)

                      {

                         WallClock.getInstance().addAlarm(ALARM_NAME,

                               Configuration.NTS_DB_POOL_STEP_INTERVAL_TIMER.getInt(), alarmStepUpTier);

                         isScheduled = true;

                         waitConnection = true;

                      }

                      else if (conn == null && !createConnection && currentTier == Tier.THREE

                            && connectionCount - dbConnections.size() >= Tier.THREE.value && !isScheduled)

                      {

                         WallClock.getInstance().addAlarm(ALARM_THROTTLE_DOWN,

                               Configuration.NTS_DB_POOL_STEP_INTERVAL_TIMER.getInt(), alarmThrottleDown);

                         isScheduled = true;

                         waitConnection = true;

                      }

                      else

                      {

                         // Connections are maxed out, so we have to wait

                         waitConnection = true;

                      }

                   }

                }

                else

                {

                   if (!dbConnections.isEmpty()

                         && (highpriority || ((connectionCount - dbConnections.size()) <= maxConnectionCount)))

                   {

                      conn = dbConnections.remove(0);

                   }

                   if (null == conn)

                   {

                      // See if we should create a new connection or have to wait

                      // if none are in the stack, then see if we should make another

                      if ((connectionCount < maxConnectionCount) || highpriority)

                      {

                         createConnection = true;

                         connectionCount++;

                      }

                      else

                      {

                         // Connections are maxed out, so we have to wait

                         waitConnection = true;

                      }

                   }

                }

             }

             if (null != conn)

             {

                // we have a Connection, so we are done

                break;

             }

             else if (createConnection)

             {

                if (!isDerby)

                {

                   // update user and password from Configuration

                   connProps.put("user", Configuration.NTS_DBUSER.getString());

                   connProps.put("password", Configuration.NTS_DBPASSWORD.getString());

                }

                try

                {

                   conn = DriverManager.getConnection(url, connProps);

                }

                catch (final SQLException sqle)

                {

                   connectionCount--; // count must be decremented since a connection was never created

                   DatabaseStatus.reportException(sqle);

                   throw sqle;

                }

                if (conn != null)

                {

                   DatabaseStatus.clearException();

                   if (peakConnections < connectionCount)

                   {

                      peakConnections = connectionCount;

                      Stats.setStat(Stats.DB_POOL_PEAK_CONNECTIONS_COUNT, peakConnections);

                      Stats.setStat(Stats.DB_POOL_PEAK_CONNECTIONS_TIME, new Date().toString());

                   }

                   allConnections.put(Integer.valueOf(conn.hashCode()), PersistentStore.createDeathTimeStamp());

                   break;

                }

                else if (Configuration.NTS_DB_CONNECTION_THROTTLING.getBoolean())

                {

                   // Unexpected Database exceptions will result in connection == null.

                   // Instead of retrying the connection, throw a checked exception.

                   throw new DBConnectionsAllUsedException("There are no DB Connections available");

                }

                else

                {

                   // don't break which will do the retry

                }

             }

             else if (waitConnection)

             {

                try

                {

                   Stats.inc(Stats.DB_THREADS_WAITING_FOR_CONNECTION);

                   synchronized (dbConnectionsToBeFreed)

                   {

                      dbConnectionsToBeFreed.wait(); // Semaphore.acquire() CountDownLatch.countdown()

                   }

                }

                finally

                {

                   Stats.dec(Stats.DB_THREADS_WAITING_FOR_CONNECTION);

                }

                // don't break which will do the retry

             }

             else

             {

                // should never hit this case

                break;

             }

          }

       }

       catch (final InterruptedException ie)

       {

          // expected

          throw new SQLException("Exception waiting for DB connection.", ie);

       }

       finally

       {

       }

       return conn;

    }

 final Semaphore sem = new Semaphore(0);

 for (int i = 0; i < num_threads; ++ i)

 {

   Thread t = new Thread() {

     public void run()

     {

       try

       {

         doStuff();

       }

       finally

       {

         sem.release();

       }

     }

   };

   t.start();

 }

 sem.acquire(num_threads);

 final CountDownLatch latch = new CountDownLatch(num_threads);

 for (int i = 0; i < num_threads; ++ i)

 {

   Thread t = new Thread() {

     public void run()

     {

       try

       {

         doStuff();

       }

       finally

       {

         latch.countDown();

       }

     }

   };

   t.start();

 }

 latch.await();