Semaphore使用

 　　一个计数信号量。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。 

　　获得一项前，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，将项返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。注意，调用 acquire() 时无法保持同步锁定，因为这会阻止将项返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。

将信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，二进制信号量具有某种属性（与很多 Lock 实现不同），即可以由线程释放“锁定”，而不是由所有者（因为信号量没有所有权的概念）。在某些专门的上下文（如死锁恢复）中这会很有用。

此类的构造方法可选地接受一个公平 参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入 是允许的，也就是说可以在已经等待的线程前为调用 acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用 acquire 方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了 acquire，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的 tryAcquire 方法不使用公平设置，而是使用任意可用的许可。

通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。

此类还提供便捷的方法来同时 acquire 和 release 多个许可。小心，在未将公平设置为 true 时使用这些方法会增加不确定延期的风险。

 

 

import  java.util.concurrent.Semaphore;

public   class  SemaphoreTest  ... {

    private int lockNum = 10;

    private Semaphore locks = new Semaphore(lockNum);

    public static void main(String[] args) ...{
        new SemaphoreTest().testThread();
    }

    private void testThread() ...{

        for (int i = 0; i < 20; i++) ...{
            try ...{
                System.out.println("第" + i + "个任务获取许可");
                locks.acquire();//从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
                System.out.println("获取许可成功，剩余许可数:" + locks.availablePermits());
            } catch (InterruptedException e) ...{
                e.printStackTrace();
            }
            new Process(locks, i).start();
            try ...{
                Thread.sleep(1000 * 1);
            } catch (InterruptedException e) ...{
                e.printStackTrace();
            }
        }
        while (true) ...{
            System.out.println("释放许可数:" + locks.availablePermits());
            if (locks.availablePermits() == lockNum) ...{
                break;
            } else ...{
                try ...{
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) ...{
                    e.printStackTrace();
                }
            }
        }
        System.out.println("执行结束。");
    }

    public class Process extends Thread ...{

        private Semaphore lock;

        private int i;

        public Process(Semaphore lock, int n) ...{
            this.lock = lock;
            i = n;
        }

        public void run() ...{
            try ...{
                Thread.sleep(1000 * 20);
                System.out.println("执行任务:" + i);
            } catch (Exception ex) ...{
                ex.printStackTrace();
            } finally ...{
                lock.release();//释放一个许可，将其返回给信号量。
            }
        }
    }
}