Java多线程之Semaphore实现信号灯

public class SemaphoreTest {

     private static final Semaphore semaphore = new Semaphore( 3 );

     public static void main(String[] args) {

         Executor executor = Executors.newCachedThreadPool();

         String[] name = { "Jack" , "Pony" , "Larry" , "Martin" , "James" , "ZhangSan" , "Tree" };

         int [] age = { 21 , 22 , 23 , 24 , 25 , 26 , 27 };

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

         {

             Thread t1= new InformationThread(name[i],age[i]);

             executor.execute(t1);

         }

     }

     private static class InformationThread extends Thread {

         private final String name;

         private final int age;

         public InformationThread(String name, int age) {

             this .name = name;

             this .age = age;

         }

         @Override

         public void run() {

             try {

                 semaphore.acquire();

                 System.out.println(Thread.currentThread().getName()

                         + ":大家好，我是" + name + "我今年" + age +

                         "当前时间段为：" + System.currentTimeMillis());

                 Thread.sleep( 1000 );

                 System.out.println(name + "要准备释放许可证了，当前时间为：" + System.currentTimeMillis());

                 System.out.println( "当前可使用的许可数为：" + semaphore.availablePermits());

                 System.out.println( "是否有正在等待许可证的线程：" + semaphore.hasQueuedThreads());

                 System.out.println( "正在等待许可证的队列长度(线程数量)：" + semaphore.getQueueLength());

                 semaphore.release();

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         }

     }

}

private static final Semaphore semaphore= new Semaphore( 3 , true );

private static final Semaphore semaphore= new Semaphore( 1 );

public Semaphore( int permits) {

        sync = new NonfairSync(permits);

    }

    public Semaphore( int permits, boolean fair) {

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

    }

public void acquire( int permits) throws InterruptedException {

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

       sync.acquireSharedInterruptibly(permits);

   }

public final void acquireSharedInterruptibly( int arg)

         throws InterruptedException {

     if (Thread.interrupted()) //如果线程被中断了，抛出异常

         throw new InterruptedException();

     if (tryAcquireShared(arg) < 0 ) //获取许可失败，将线程加入到等待队列中

         doAcquireSharedInterruptibly(arg);

}

protected int tryAcquireShared( int acquires) {

             return nonfairTryAcquireShared(acquires);

         }

final int nonfairTryAcquireShared( int acquires) {

             for (;;) {

                 //获取剩余许可数量

                 int available = getState();

                 //计算给完这次许可数量后的个数

                 int remaining = available - acquires;

                 //如果许可不够或者可以将许可数量重置的话，返回

                 if (remaining < 0 ||

                     compareAndSetState(available, remaining))

                     return remaining;

             }

         }

protected int tryAcquireShared( int acquires) {

             for (;;) {

                 //如果前面有线程再等待，直接返回-1

                 if (hasQueuedPredecessors())

                     return - 1 ;

                 //后面与非公平一样

                 int available = getState();

                 int remaining = available - acquires;

                 if (remaining < 0 ||

                     compareAndSetState(available, remaining))

                     return remaining;

             }

         }

public void release( int permits) {

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

         sync.releaseShared(permits);

     }

public final boolean releaseShared( int arg) {

         //如果改变许可数量成功

         if (tryReleaseShared(arg)) {

             doReleaseShared();

             return true ;

         }

         return false ;

     }

protected final boolean tryReleaseShared( int releases) {

             for (;;) {

                 //获取当前许可数量

                 int current = getState();

                 //计算回收后的数量

                 int next = current + releases;

                 if (next < current) // overflow

                     throw new Error( "Maximum permit count exceeded" );

                 //CAS改变许可数量成功，返回true

                 if (compareAndSetState(current, next))

                     return true ;

             }

         }

protected void reducePermits( int reduction) {

         if (reduction < 0 ) throw new IllegalArgumentException();

         sync.reducePermits(reduction);

     }

final void reducePermits( int reductions) {

           for (;;) {

               //得到当前剩余许可数量

               int current = getState();

               //得到减完之后的许可数量

               int next = current - reductions;

               if (next > current) // underflow

                   throw new Error( "Permit count underflow" );

               //如果CAS改变成功

               if (compareAndSetState(current, next))

                   return ;

           }

       }

public int drainPermits() {

         return sync.drainPermits();

     }

final int drainPermits() {

            for (;;) {

                int current = getState();

                if (current == 0 || compareAndSetState(current, 0 ))

                    return current;

            }

        }