聊聊并发：（十四）concurrent包并发辅助类之Semaphore分析

最新推荐文章于 2022-08-15 00:41:07 发布

wtopps

最新推荐文章于 2022-08-15 00:41:07 发布

阅读量395

点赞数

分类专栏： Java多线程开发聊聊Java并发文章标签： Semaphore Semaphore源码 Semaphore源码分析 Semaphore实现 Semaphore介绍

本文链接：https://blog.csdn.net/wtopps/article/details/85056122

版权

聊聊Java并发同时被 2 个专栏收录

21 篇文章 19 订阅

订阅专栏

Java多线程开发

19 篇文章 15 订阅

订阅专栏

前言

在前几篇文章中，

聊聊并发：（十三）concurrent包并发辅助类之CountDownLatch源码分析

聊聊并发：（十二）concurrent包并发辅助类之CyclicBarrier源码分析

聊聊并发：（七）concurrent包之AbstractQueuedSynchronizer分析

我们介绍了concurrent包中的并发控制辅助类——CyclicBarrier与CountDownLatch，这两个都可以用于控制线程之间的调度运行，本篇，我们继续介绍另外一个比较常用的并发辅助类——Semaphore介绍。

Semaphore介绍

Semaphore是一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。

Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

通俗点来讲，Semaphore可以理解为一个流量控制器，只允许指定数目的线程拿到许可，继续执行，当有其他线程再希望拿到许可时，需要阻塞等待，直到拿到许可的线程执行完毕后，释放许可，其他线程才可以获取到许可，进行执行。

Semaphore 有两种模式，即公平模式与非公平模式，可以通过构造方法进行指定。

Semaphore(int permits) 
创建具有给定的许可数和非公平的公平设置的 Semaphore。

---------------------------------------------------------------------

Semaphore(int permits, boolean fair) 
创建具有给定的许可数和给定的公平设置的 Semaphore。

在非公平模式下，不对线程获取许可的顺序做任何保证，即一个线程可能刚刚获取完许可并释放许可，可以立刻再次获取许可。

在公平模式下，对于任何调用获取方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。

我们来看一下Semaphore 比较重要的几个方法：

void acquire() 
从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。

void acquire(int permits) 
从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞，或者线程已被中断。

void release() 
释放一个许可，将其返回给信号量。

void release(int permits) 
释放给定数目的许可，将其返回到信号量。

Semaphore使用示例

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(1);
        ExecutorService executors = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            executors.execute(() -> {
                System.out.println("线程池A，启动线程，当前线程名称：" + Thread.currentThread().getName());
                try {
                    System.out.println("线程池A，当前线程名称：" + Thread.currentThread().getName() + "，准备尝试获取许可");
                    semaphore.acquire();
                    System.out.println("线程池A，当前线程名称：" + Thread.currentThread().getName() + "，获取许可成功");
                    Thread.sleep(5 * 1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                semaphore.release();
                System.out.println("线程池A，当前线程名称：" + Thread.currentThread().getName() + "释放许可成功");
            });
        }
    }
}

输出：

线程池A，启动线程，当前线程名称：pool-1-thread-2
线程池A，启动线程，当前线程名称：pool-1-thread-1
线程池A，当前线程名称：pool-1-thread-1，准备尝试获取许可
线程池A，启动线程，当前线程名称：pool-1-thread-3
线程池A，当前线程名称：pool-1-thread-1，获取许可成功
线程池A，当前线程名称：pool-1-thread-2，准备尝试获取许可
线程池A，当前线程名称：pool-1-thread-3，准备尝试获取许可
线程池A，当前线程名称：pool-1-thread-1释放许可成功
线程池A，当前线程名称：pool-1-thread-2，获取许可成功
线程池A，当前线程名称：pool-1-thread-2释放许可成功
线程池A，当前线程名称：pool-1-thread-3，获取许可成功
线程池A，当前线程名称：pool-1-thread-3释放许可成功

上面的实例简单演示了Semaphore的用法，我们初始化了一个Semaphore，初始化大小置为1，启动3个线程，线程只有获取到Semaphore的许可后，才可以继续执行，否则进入阻塞等待，Semaphore被一个线程获取许可后，只有其释放掉资源后，其他线程才可以继续获取。

Semaphore源码实现

Semaphore的实现同样是基于AQS的，通过重写AQS的抽象方法，实现其功能，我们来看一下它的实现：

public class Semaphore implements java.io.Serializable {
    private static final long serialVersionUID = -3222578661600680210L;
    
    private final Sync sync;
    
    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))
                    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))
                    return current;
            }
        }
    }

    /**
     * NonFair version
     */
    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);
        }
    }

    /**
     * Fair version
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;

        FairSync(int permits) {
            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;
            }
        }
    }
    
    .......

这里我们只给出一小部分实现，如果看过之前系列文章的读者可以一眼看出，Semaphore的实现基本与另外几个并发辅助工具类差不多，内部实现一个同步器，去继承AQS，重写其模板方法，实现自己的功能。

Semaphore支持两种模式，一种是公平模式，一种是非公平模式，在前面我们已经提到了，这部分的实现也是基于AQS。

由于之前的文章中对AQS家族工具类已经有了很详细的分析，本篇我们就着重介绍两个方法的实现。

acquire()

我们首先来看一下acquire()方法的实现：

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

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

acquire()是调用了AQS的模板方法进行的实现，分为公平模式与非公平模式，我们来分别看一下它们的实现：

公平模式：

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

    FairSync(int permits) {
        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;
        }
    }
}

非公平模式：

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

final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

公平模式下，会检查当前同步队列中是否存在前驱节点，如果存在，直接将当前线程加入同步队列中，由于之前介绍AQS与锁的时候已经详细分析过这里的实现，此处不再赘述，感兴趣的朋友可以看一下之前的文章。

非公平模式下，将不会保证线程争抢资源的先后顺序，每次线程争抢同步资源时，将同步资源初始化值减一，当同步资源数小于0时，将当前线程放入同步队列中进行等待。

release()

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

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

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

释放资源的操作较为简单，将同步资源状态增量（其实就是加1），CAS设置同步资源状态，唤醒同步资源线程。

其他方法介绍

源码分析部分，我们只介绍acquire() 和 release() 这两个方法，这里我们简单介绍一下其他的方法：

acquireUninterruptibly() 
          从此信号量中获取许可，在有可用的许可前将其阻塞。
          
availablePermits() 
          返回此信号量中当前可用的许可数。
          
getQueuedThreads() 
          返回一个 collection，包含可能等待获取的线程。
          
getQueueLength() 
          返回正在等待获取的线程的估计数目。

tryAcquire(int permits) 
          仅在调用时此信号量中有给定数目的许可时，才从此信号量中获取这些许可。
          
tryAcquire(int permits, long timeout, TimeUnit unit) 
          如果在给定的等待时间内此信号量有可用的所有许可，并且当前线程未被中断，则从此信号量获取给定数目的许可。

Semaphore VS CountDownLatch VS CyclicBarrier

Semaphore、CountDownLatch、CyclicBarrier这三个类都是用于实现并发辅助的工具类，但是它们在使用场景上有略微的区别，这里我们横向对比一下：

CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：
- CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；
- 而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；
- 另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。
Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限，而锁是控制对某个资源的访问权限。

结语

本篇，我们介绍了Semaphore，同样是AQS家族的实现类，用于并发辅助的控制，如果您读过之前的文章，您会发现，关于锁、并发控制的类的实现全部是基于AQS的，所以理解透彻AQS的实现，对于理解这些工具类是至关重要的，如果您对于AQS的实现有不清楚的地方，建议您看一下之前的文章，对于AQS的分析，以及几篇关于锁的文章的介绍，希望可以帮助您更加深入理解并发工具类。

聊聊并发：（七）concurrent包之AbstractQueuedSynchronizer分析

从下篇开始，我们开始介绍并发容器的工具类的实现，敬请期待！

更多Java干货文章请关注我的个人微信公众号：老宣与你聊Java

在这里插入图片描述

wtopps

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
聊聊并发：（十四）concurrent包并发辅助类之Semaphore分析

前言在前几篇文章中，聊聊并发：（十三）concurrent包并发辅助类之CountDownLatch源码分析聊聊并发：（十二）concurrent包并发辅助类之CyclicBarrier源码分析聊聊并发：（七）concurrent包之AbstractQueuedSynchronizer分析我们介绍了concurrent包中的并发控制辅助类——CyclicBarrier与CountDown...
复制链接

扫一扫