Concurrent同步工具类03 - Semaphore

简介

Semaphore是一个计数信号量。信号量维护了一个许可集合; 通过acquire()和release() 来获取和释放访问许可证。只有通过acquire获取了许可证的线程才能执行,否则阻塞。 通过release释放许可证其他线程才能进行获取。 

公平性：没有办法保证线程能够公平地从信号量中获得许可。也就是说，无法保证第一个调用 acquire() 的线程会是第一个获得一个许可的线程。如果第一个线程在等 待一个许可时发生阻塞，而第二个线程前来索要一个许可的时候刚好有一个许可被释 放出来，那么它就可能会在第一个线程之前获得许可。如果你想要强制公平， Semaphore 类有一个具有一个布尔类型的参数的构造函数，通过这个参数告知 Semaphore 是否要强制公平。强制公平会影响到并发性能，所以除非你确实需要它否 则不要启用它。

应用场景

Semaphore 可以用来控制同时访问特定资源的线程数量，通过协调各个线程，以保证合理的使用资源，主要用来限流。

比如：数据库连接池，同时进行连接的线程有数量限制，连接不能超过一定的数量，当连接达到了限制数量后，后面的线程只能排队等前面的线程释放了数据库连接才能获得数据库连接。

比如：停车场场景，车位数量有限，同时只能容纳多少台车，车位满了之后只有等里面的车离开停车场外面的车才可以进入。

重要方法

acquire()  
获取一个令牌，在获取到令牌、或者被其他线程调用中断之前线程一直处于阻塞状态。
​
acquire(int permits)  
获取一个令牌，在获取到令牌、或者被其他线程调用中断、或超时之前线程一直处于阻塞状态。
    
acquireUninterruptibly() 
获取一个令牌，在获取到令牌之前线程一直处于阻塞状态（忽略中断）。
    
tryAcquire()
尝试获得令牌，返回获取令牌成功或失败，不阻塞线程。
​
tryAcquire(long timeout, TimeUnit unit)
尝试获得令牌，在超时时间内循环尝试获取，直到尝试获取成功或超时返回，不阻塞线程。
​
release()
释放一个令牌，唤醒一个获取令牌不成功的阻塞线程。
​
hasQueuedThreads()
等待队列里是否还存在等待线程。
​
getQueueLength()
获取等待队列里阻塞的线程数。
​
drainPermits()
清空令牌把可用令牌数置为0，返回清空令牌的数量。
​
availablePermits()
返回可用的令牌数量。

应用举例：（Semaphore实现模拟数据库连接池）

package com.test.lesson01.db;

import java.util.concurrent.TimeUnit;

/**
 * 连接对象
 */
public class Connect {

    private static int count = 1;
    private int id = count++;
    public Connect(){

        //假设打开一个连接需要耗费1秒
        try {
            TimeUnit.MICROSECONDS.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

package com.test.lesson01.db;

import java.util.concurrent.Semaphore;

/**
 * 连接池
 */
public class DataBasePool {

    //连接池大小
    private int size;
    //当前数据库可用数
    private int available;
    //数据库连接集合
    private Connect[] connects;
    //连接状态
    private boolean[] connectFlags;
    //信号量对象
    private Semaphore semaphore;
    //初始化连接池大小
    public DataBasePool(int size){

        this.size = size;
        this.available = size;
        //信号量初始值为10，每成功进行一次acquire()操作，信号数减1，release()操作，信号数加1
        semaphore = new Semaphore(size,true);
        connects = new Connect[size];
        connectFlags = new boolean[size];
        initConnects();
    }
    //数据库初始化
    private void initConnects() {
        for (int i = 0; i < this.size; i++) {
            connects[i] = new Connect();
        }

    }
    //获得某个数据库连接，采用semaphore来控制
    public Connect openConnect() throws InterruptedException{
        //请求许可证，如何没有许可证，则一直阻塞
        semaphore.acquire();
        return getConnect();
    }
    //因为可能存在多个线程请求连接，所以应该设为synchronized
    private synchronized Connect getConnect() {

        for(int i=0;i<connectFlags.length;i++)
        {
            //找到没有被使用的连接
            if(connectFlags[i]== false)
            {
                //将该连接设为被连接了
                connectFlags[i] = true;
                available--;
                System.out.println("【"+Thread.currentThread().getName()+"】已获取连接------剩余连接数：" + available);
                //获得这个连接
                return connects[i];
            }
        }
        return null;
    }
    //释放连接
    public synchronized void releaseConnect(Connect connect)
    {
        for (int i = 0; i < connectFlags.length; i++) {
            if(connect == connects[i])
            {
                connectFlags[i] = false;
                available++;
                System.out.println("【"+Thread.currentThread().getName()+"】已释放连接------剩余连接数：" + available);
                //信号量-1
                semaphore.release();
            }
        }
    }



}

package com.test.lesson01.db;


public class Test implements Runnable {

    private static DataBasePool pool = new DataBasePool(10);
    @Override
    public void run() {
        try {
            //打开一个连接
            Connect connect = pool.openConnect();
            Thread.sleep(100);
            pool.releaseConnect(connect);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public static void main(String[] args) {
        for (int i = 0; i < 15; i++) {
            // 用来测试数据库连接的打开和关闭
            Thread thread = new Thread(new Test());
            thread.start();
        }
    }

}

运行结果为：（其中的一种）

【Thread-0】已获取连接------剩余连接数：9
【Thread-5】已获取连接------剩余连接数：8
【Thread-6】已获取连接------剩余连接数：7
【Thread-8】已获取连接------剩余连接数：6
【Thread-4】已获取连接------剩余连接数：5
【Thread-1】已获取连接------剩余连接数：4
【Thread-3】已获取连接------剩余连接数：3
【Thread-2】已获取连接------剩余连接数：2
【Thread-7】已获取连接------剩余连接数：1
【Thread-9】已获取连接------剩余连接数：0
【Thread-5】已释放连接------剩余连接数：1
【Thread-6】已释放连接------剩余连接数：2
【Thread-0】已释放连接------剩余连接数：3
【Thread-11】已获取连接------剩余连接数：2
【Thread-10】已获取连接------剩余连接数：1
【Thread-12】已获取连接------剩余连接数：0
【Thread-2】已释放连接------剩余连接数：1
【Thread-4】已释放连接------剩余连接数：2
【Thread-1】已释放连接------剩余连接数：3
【Thread-7】已释放连接------剩余连接数：4
【Thread-8】已释放连接------剩余连接数：5
【Thread-3】已释放连接------剩余连接数：6
【Thread-9】已释放连接------剩余连接数：7
【Thread-14】已获取连接------剩余连接数：6
【Thread-13】已获取连接------剩余连接数：5
【Thread-10】已释放连接------剩余连接数：6
【Thread-12】已释放连接------剩余连接数：7
【Thread-11】已释放连接------剩余连接数：8
【Thread-14】已释放连接------剩余连接数：9
【Thread-13】已释放连接------剩余连接数：10