#yyds干货盘点# Semaphore详解

Posted 2022-04-15 灰太狼_cxh

Semaphore详解

Semaphore源码分析

类的继承关系

public class Semaphore implements java.io.Serializable 

说明: Semaphore实现了Serializable接口，即可以进行序列化。

类的内部类

Semaphore总共有三个内部类，并且三个内部类是紧密相关的

说明: Semaphore与ReentrantLock的内部类的结构相同，类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync与FairSync类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。下面逐个进行分析。

类的内部类 - Sync类

Sync类的源码如下

// 内部类，继承自AQS
abstract static class Sync extends AbstractQueuedSynchronizer 
    // 版本号
    private static final long serialVersionUID = 1192457210091910933L;
    
    // 构造函数
    Sync(int permits) 
        // 设置状态数
        setState(permits);
    
    
    // 获取许可
    final int getPermits() 
        return getState();
    

    // 共享模式下非公平策略获取
    final int nonfairTryAcquireShared(int acquires) 
        for (;;)  // 无限循环
            // 获取许可数
            int available = getState();
            // 剩余的许可
            int remaining = available - acquires;
            if (remaining < 0 ||
                compareAndSetState(available, remaining)) // 许可小于0或者比较并且设置状态成功
                return remaining;
        
    
    
    // 共享模式下进行释放
    protected final boolean tryReleaseShared(int releases) 
        for (;;)  // 无限循环
            // 获取许可
            int current = getState();
            // 可用的许可
            int next = current + releases;
            if (next < current) // overflow
                throw new Error("Maximum permit count exceeded");
            if (compareAndSetState(current, next)) // 比较并进行设置成功
                return true;
        
    

    // 根据指定的缩减量减小可用许可的数目
    final void reducePermits(int reductions) 
        for (;;)  // 无限循环
            // 获取许可
            int current = getState();
            // 可用的许可
            int next = current - reductions;
            if (next > current) // underflow
                throw new Error("Permit count underflow");
            if (compareAndSetState(current, next)) // 比较并进行设置成功
                return;
        
    

    // 获取并返回立即可用的所有许可
    final int drainPermits() 
        for (;;)  // 无限循环
            // 获取许可
            int current = getState();
            if (current == 0 || compareAndSetState(current, 0)) // 许可为0或者比较并设置成功
                return current;
        
    

类的内部类 - NonfairSync类

NonfairSync类继承了Sync类，表示采用非公平策略获取资源，其只有一个tryAcquireShared方法，重写了AQS的该方法，其源码如下:

static final class NonfairSync extends Sync 
    // 版本号
    private static final long serialVersionUID = -2694183684443567898L;
    
    // 构造函数
    NonfairSync(int permits) 
        super(permits);
    
    // 共享模式下获取
    protected int tryAcquireShared(int acquires) 
        return nonfairTryAcquireShared(acquires);
    

说明: 从tryAcquireShared方法的源码可知，其会调用父类Sync的nonfairTryAcquireShared方法，表示按照非公平策略进行资源的获取。

类的内部类 - FairSync类

FairSync类继承了Sync类，表示采用公平策略获取资源，其只有一个tryAcquireShared方法，重写了AQS的该方法，其源码如下。

protected int tryAcquireShared(int acquires) 
    for (;;)  // 无限循环
        if (hasQueuedPredecessors()) // 同步队列中存在其他节点
            return -1;
        // 获取许可
        int available = getState();
        // 剩余的许可
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining)) // 剩余的许可小于0或者比较设置成功
            return remaining;