Semaphore详解

1.Semaphore(信号量)：

是一种计数器，用来保护一个或者多个共享资源的访问。如果线程要访问一个资源就必须先获得信号量。如果信号量内部计数器大于0，信号量减1，然后允许共享这个资源；否则，如果信号量的计数器等于0，信号量将会把线程置入休眠直至计数器大于0.当信号量使用完时，必须释放。
　构造方法1：

public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

permits 初始许可数，也就是最大访问线程数构造方法2：

public Semaphore(int permits, boolean fair) {
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

permits 初始许可数，也就是最大访问线程数
fair 当设置为false时，创建的信号量为非公平模式；当设置为true时，信号量是公平模式

2.主要方法

1. void acquire() ：从信号量获取一个许可，如果无可用许可前将一直阻塞等待，
2. void acquire(int permits) ：获取指定数目的许可，如果无可用许可前也将会一直阻塞等待
3. boolean tryAcquire()：从信号量尝试获取一个许可，如果无可用许可，直接返回false，不会阻塞
4. boolean tryAcquire(int permits)： 尝试获取指定数目的许可，如果无可用许可直接返回false
5. boolean tryAcquire(int permits, long timeout, TimeUnit unit)： 在指定的时间内尝试从信号量中获取许可，如果在指定的时间内获取成功，返回true，否则返回false
6. void release()： 释放一个许可，别忘了在finally中使用，注意：多次调用该方法，会使信号量的许可数增加，达到动态扩展的效果，如：初始permits为1， 调用了两次release，最大许可会改变为2
7. int availablePermits()： 获取当前信号量可用的许可

3.示例

    static Semaphore semaphore1 = new Semaphore(1);
    static Semaphore semaphore2 = new Semaphore(1);
    static Semaphore semaphore3 = new Semaphore(1);

    public static void main(String[] args) {
        try {
            semaphore2.acquire();
            semaphore3.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore1.acquire();
                    System.out.print("A");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore2.release();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore2.acquire();
                    System.out.print("B");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore3.release();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore3.acquire();
                    System.out.println("C");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore1.release();
                }
            }
        }).start();
    }

运行结果：