Java源码分析系列笔记-18.Semaphore

目录

• 1. 是什么
• 2. 原理分析
  • 2.1. uml
• 3. 公平信号量
  • 3.1. 是什么
  • 3.2. 使用
  • 3.3. 原理分析
    • 3.3.1. 构造方法
      • 3.3.1.1. 公平Sync
    • 3.3.2. acquire
      • 3.3.2.1. 调用AQS加共享锁
        • 3.3.2.1.1. 尝试加锁【公平：队列前面有人排队那么直接返回失败】
    • 3.3.3. release
      • 3.3.3.1. 调用AQS释放共享锁
        • 3.3.3.1.1. 尝试释放共享锁
• 4. 非公平信号量
  • 4.1. 是什么
  • 4.2. 使用
  • 4.3. 原理分析
    • 4.3.1. 构造方法
      • 4.3.1.1. 非公平Sync
    • 4.3.2. acquire
      • 4.3.2.1. 调用AQS加共享锁
        • 4.3.2.1.1. 尝试加共享锁【非公平：不管队列前面是否有人我直接尝试加锁】
    • 4.3.3. release
      • 4.3.3.1. 调用AQS释放共享锁
        • 4.3.3.1.1. 尝试释放锁

1. 是什么

限流工具类，同一时间只允许n个线程访问某资源

2. 原理分析

2.1. uml

@startuml
skinparam classAttributeIconSize 0

class Semaphore{
}

class AbstractQueuedSynchronizer{
}

class Sync{
}

class FairSync{
}

class NonfairSync{

}

Sync <|-- FairSync

Sync <|-- NonfairSync

AbstractQueuedSynchronizer <|-- Sync

Semaphore --> Sync
@enduml

可以看出Semaphore也有公平的和非公平之分

3. 公平信号量

3.1. 是什么

限流，使用的公平策略

3.2. 使用

public class SemaphoreTest
{
    private final static int THREAD_COUNT = 100;
    private final static CountDownLatch countDownLatch = new CountDownLatch(THREAD_COUNT);

    public static void main(String[] args) throws InterruptedException
    {
        Semaphore semaphore = new Semaphore(10, true);//true代表公平

        for (int i = 0; i < THREAD_COUNT; i++)
        {
            new Thread(()->{
                try
                {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "正在访问资源。。。");
                    TimeUnit.SECONDS.sleep(3);

                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
                finally
                {
                    semaphore.release();
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();
    }
}

3.3. 原理分析

3.3.1. 构造方法

public Semaphore(int permits, boolean fair) {
    //公平用的是FairSync
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

3.3.1.1. 公平Sync

• FairSync

static final class FairSync extends Sync {
    private static final long serialVersionUID = 2014338818796000944L;

    FairSync(int permits) {
        //Semaphore.Sync#Sync
        super(permits);
    }

    protected int tryAcquireShared(int acquires) {
        for (;;) {
            if (hasQueuedPredecessors())
                return -1;
            int available = getState();
            int remaining = available - acquires;
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                return remaining;
        }
    }
}

• Sync

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;

    Sync(int permits) {
        //最终就是设置了permits个信号量
        setState(permits);
    }
}

3.3.2. acquire

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

3.3.2.1. 调用AQS加共享锁

• AQS acquireSharedInterruptibly

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //Semaphore.FairSync重写了tryAcquireShared
    //如果信号量不够那么返回负数，这里执行doAcquireSharedInterruptibly入AQS队,并且阻塞等待唤醒
    //如果信号量够的话返回>=0的数，那么调用此acquire方法的代码就可以继续执行业务代码
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

3.3.2.1.1. 尝试加锁【公平：队列前面有人排队那么直接返回失败】

• Semaphore.FairSync#tryAcquireShared

protected int tryAcquireShared(int acquires) {
    for (;;) {
        //如果队列中我的前面有人排队，那么返回-1
        if (hasQueuedPredecessors())
            return -1;
        //当前的信号量
        int available = getState();
        //当前的信号量够不够我获取？
        int remaining = available - acquires;
        //<0表示不够的话返回这个数
        if (remaining < 0 ||
             //>=0说明够了，那么CAS修改剩余信号量
            compareAndSetState(available, remaining))
            return remaining;
    }
}

3.3.3. release

• Semaphore#release()

public void release() {
    //AQS的releaseShared
    sync.releaseShared(1);
}

3.3.3.1. 调用AQS释放共享锁

• AQS#releaseShared

public final boolean releaseShared(int arg) {
    //Semaphore.Sync重写了tryReleaseShared
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

3.3.3.1.1. 尝试释放共享锁

• Semaphore.Sync#tryReleaseShared

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;
    }
}

4. 非公平信号量

4.1. 是什么

限流，使用的非公平策略

4.2. 使用

public class SemaphoreTest
{
    private final static int THREAD_COUNT = 100;
    private final static CountDownLatch countDownLatch = new CountDownLatch(THREAD_COUNT);

    public static void main(String[] args) throws InterruptedException
    {
        Semaphore semaphore = new Semaphore(10);

        for (int i = 0; i < THREAD_COUNT; i++)
        {
            new Thread(()->{
                try
                {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "正在访问资源。。。");
                    TimeUnit.SECONDS.sleep(3);

                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
                finally
                {
                    semaphore.release();
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();
    }
}

4.3. 原理分析

4.3.1. 构造方法

public Semaphore(int permits) {
    //创建的是非公平的Sync
    sync = new NonfairSync(permits);
}

4.3.1.1. 非公平Sync

• NonfairSync

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;

    NonfairSync(int permits) {
        //调用Sync
        super(permits);
    }

    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }
}

• Sync

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;

    Sync(int permits) {
        //最终就是设置了permits个信号量
        setState(permits);
    }
}

4.3.2. acquire

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

4.3.2.1. 调用AQS加共享锁

• AQS acquireSharedInterruptibly

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //Semaphore.NonfairSync重写了tryAcquireShared
    //如果信号量不够那么返回负数，这里执行doAcquireSharedInterruptibly入AQS队,并且阻塞等待唤醒
    //如果信号量够的话返回>=0的数，那么调用此acquire方法的代码就可以继续执行业务代码
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

4.3.2.1.1. 尝试加共享锁【非公平：不管队列前面是否有人我直接尝试加锁】

• Semaphore.NonfairSync#tryAcquireShared

protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
}

• Semaphore.Sync#nonfairTryAcquireShared

final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        //当前的信号量
        int available = getState();
        //当前的信号量够不够我获取？
        int remaining = available - acquires;
        //<0表示不够的话返回这个数
        if (remaining < 0 ||
        //>=0说明够了，那么CAS修改剩余信号量
            compareAndSetState(available, remaining))
            return remaining;
    }
}

4.3.3. release

• Semaphore#release()

public void release() {
    //AQS的releaseShared
    sync.releaseShared(1);
}

4.3.3.1. 调用AQS释放共享锁

• AQS#releaseShared

public final boolean releaseShared(int arg) {
    //Semaphore.Sync重写了tryReleaseShared
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

4.3.3.1.1. 尝试释放锁

• Semaphore.Sync#tryReleaseShared

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;
    }
}