Semaphore 源码解读

Semaphore 源码解读

/**
* 使用AQS的共享锁来实现的信号量，如果状态等于0，不允许获取共享锁，每次获取锁 state--; 释放锁 state++;
*/
public class Semaphore  {
    private final Sync sync;
    // 默认创建非公平的Sync, permits许可，用AQS的state 保存permits的值，
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }
}

获取许可的逻辑

public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

非公平锁逻辑

static final class NonfairSync extends Sync {
  
    NonfairSync(int permits) {
        super(permits);
    }
    // AQS的模板方法
    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }
}

Sync类方法

final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        // 自旋锁
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
            // cas 修改许可
            compareAndSetState(available, remaining))
            // <0，需要进行AQS排队，>=0 成功获取锁
            return remaining;
    }
}

公平锁的逻辑

static final class FairSync extends Sync {
    FairSync(int permits) {
        super(permits);
    }

    protected int tryAcquireShared(int acquires) {
        for (;;) {
            //判断是否有正在排队的节点，如果有直接去AQS队列中排队
            if (hasQueuedPredecessors())
                return -1;
            int available = getState();
            int remaining = available - acquires;
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                return remaining;
        }
    }
}

释放许可的逻辑

public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}

// AQS 释放共享锁的模板方法
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");
        // cas
        if (compareAndSetState(current, next))
            return true;
    }
}

总结

信号量的实现是比较简单，使用AQS的共享锁的来实现，许可==state；公平锁和非公平锁的区别就是在获取共享锁，公平锁需要判断AQS的排队是否有元素，如果有直接去方法-1去排队等待，非公平锁没有这个操作。