Java concurrent包下的并发开发辅助类（三）Semaphore

测试代码:

public class SemaphoreSample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < 10; i++) {
            Thread t = new SemaphoreWorker(semaphore);
            t.start();
        }
    }
}

class SemaphoreWorker extends Thread {
    private Semaphore semaphore;

    SemaphoreWorker(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            System.out.println(getName() + "is waiting for a permit!");

            semaphore.acquire();

            System.out.println(getName() + "acquired a permit!");

            Thread.sleep(10000);

            System.out.println(getName() + "executed!");

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {

            System.out.println(getName() + "released a permit!");

            semaphore.release();
        }
    }
}

测试结果：

Thread-4 is waiting for a permit!
Thread-4 acquired a permit!
Thread-3 is waiting for a permit!
Thread-3 acquired a permit!
Thread-2 is waiting for a permit!
Thread-6 is waiting for a permit!
Thread-6 acquired a permit!
Thread-0 is waiting for a permit!
Thread-0 acquired a permit!
Thread-2 acquired a permit!
Thread-9 is waiting for a permit!
Thread-1 is waiting for a permit!
Thread-5 is waiting for a permit!
Thread-8 is waiting for a permit!
Thread-7 is waiting for a permit!
Thread-0 executed!
Thread-0 released a permit!
Thread-2 executed!
Thread-2 released a permit!
Thread-4 executed!
Thread-4 released a permit!
Thread-5 acquired a permit!
Thread-3 executed!
Thread-3 released a permit!
Thread-6 executed!
Thread-8 acquired a permit!
Thread-1 acquired a permit!
Thread-9 acquired a permit!
Thread-6 released a permit!
Thread-7 acquired a permit!
Thread-8 executed!
Thread-8 released a permit!
Thread-7 executed!
Thread-7 released a permit!
Thread-9 executed!
Thread-9 released a permit!
Thread-1 executed!
Thread-1 released a permit!
Thread-5 executed!
Thread-5 released a permit!

Semaphore 一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。
获得一项前，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，将项返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。

1.构造方法Semaphore(int permits)
创建具有给定的许可数和非公平的公平设置的 Semaphore。
即同时可以允许多少线程进行访问
2.构造方法Semaphore(int permits, boolean fair)
fair为true时，线程按FIFO顺序获取许可，为false时即为竞争获取
3.public void acquire() throws InterruptedException { }
获取一个许可
public void acquire(int permits) throws InterruptedException { }
获取permits个许可
public void release() { }
释放一个许可
public void release(int permits) { }
释放permits个许可
acquire()用来获取一个许可，没有许可可以获取则会等待，直到获得许可。
release()用来释放许可。必须先获得许可后，才可以释放许可。
4.public boolean tryAcquire() { };
尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };
尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { };
尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { };
尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false