Semaphore控制线程并发数

信号量用于控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理使用公用资源。

Semaphore的构造方法为Semaphore(int permits)接收一个整型数字，表示可用的许可数量。

主要方法：

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

Semaphore常用于流量控制，特别是公用资源特别有限的应用场景，比如数据库连接。假如有一个需求，要读取几万个文件的数据，因为那是IO密集型任务，我们可以启动几十个线程并发地读取，但是读取到内存之后，还需要存储到数据库中，而数据库连接的数量非常有限，只有10个，这时我们必须控制只有10个线程同时获取数据库连接保存数据。此时，可以使用Semaphore。

package piped;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreTest {

    private static ExecutorService threadPool = 
    Executors.newFixedThreadPool(30);

    private static Semaphore s = new Semaphore(10);

    public static void main(String[] args) {
        for (int i = 0 ; i < 30; i++) {
            threadPool.execute(new Runnable() {

                @Override
                public void run() {
                    try{
                        s.acquire();
                        System.out.println(Thread.
                        currentThread().getName() + ":  
                        SaveData" + "  waiting Threads: 
                        " + s.getQueueLength());                                                                                
                        s.release();
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        threadPool.shutdown();
    }

}