• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

通俗易懂的JUC源码剖析-Semaphore

互联网 diligentman 2周前 (02-17) 11次浏览

前言

Semaphore意为信号量,它用来限制某段时间内的最大并发资源数。例如数据库连接池,停车位等。下面通过停车位的栗子来说明Semaphore的使用方式。

import java.util.concurrent.Semaphore;
public class SemaphoreDemo {
    private static Semaphore semaphore = new Semaphore(10);
    public static void main(String[] args) {
        for (int i = 1; i <= 50; i++) {
            new Thread(() -> {
                try {
                    if (semaphore.availablePermits() == 0) {
                        System.out.println("车位已满,需要等待...");
                    }
                    semaphore.acquire();
                    System.out.println("有空余车位,驶进停车场");
                    // 模拟在停车场smoke or something
                    Thread.sleep(3000);
                    System.out.println("老婆喊我回家吃饭,驶出停车场");
                    semaphore.release();
                } catch (InterruptedException e) {
                    // ignored
                }
            }).start();
        }
    }
}

实现原理

看一眼Semaphore的类结构,内部类继承了AQS,同时提供了公平和非公平策略。
通俗易懂的JUC源码剖析-Semaphore
我们可以在构造函数中指定是公平还是非公平,默认是非公平策略。

public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

再来看重要方法(以NonfairSync为例分析):
acquire()

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

可以看到,调用了AQS的模板方法,acquireSharedInterruptibly里面会调用子类重写的tryAcquireShared,来看看相关逻辑:

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 调用子类方法尝试获取共享资源失败,则在队列中阻塞获取    
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}
protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
}
final int nonfairTryAcquireShared(int acquires) {
    // CAS + 自璇
    for (;;) {
        // 获取当前剩余资源数
        int available = getState();
        // 计算获取acquires个资源后,剩余资源数
        int remaining = available - acquires;
        // 如果不够用或者够用并且CAS设置剩余数成功,则返回
        // 否则循环重试CAS操作
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
 }
}

release()

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

同样,release调用了AQS的模板方法,releaseShared里面会调用子类重写的tryReleaseShared方法,来看看子类具体实现逻辑:

protected final boolean tryReleaseShared(int releases) {
    // CAS + 自璇
    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;
        }
}

代码逻辑也很简单,不做赘述。

FairSync公平式的获取,就是在tryAcquireShared时先判断队列中有无在等待的元素,有的话就返回-1,进入同步队列阻塞获取。相关代码如下:

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

参考资料:
《Java并发编程之美》


程序员灯塔
转载请注明原文链接:通俗易懂的JUC源码剖析-Semaphore
喜欢 (0)