文档章节

JUC锁框架——Semaphore

长头发-dawn
 长头发-dawn
发布于 2018/09/17 13:25
字数 1467
阅读 29
收藏 6

Semaphore简单介绍

Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞,直到有一个许可证可以获得然后拿走一个许可证;每个release方法增加一个许可证,这可能会释放一个阻塞的acquire方法。然而,其实并没有实际的许可证这个对象,Semaphore只是维持了一个可获得许可证的数量。

Semaphore的简单示例

Semaphore经常用于限制获取某种资源的线程数量。下面举个例子,比如说操场上有5个跑道,一个跑道一次只能有一个学生在上面跑步,一旦所有跑道在使用,那么后面的学生就需要等待,直到有一个学生不跑了,下面是这个例子:

public class Playground {
    private String[] tracks = {"跑道1","跑道2","跑道3","跑道4","跑道5"};//一共有5个跑道
    private volatile boolean[] used = new boolean[5];//标记跑道是否被占用

    private Semaphore semaphore = new Semaphore(5, true);

    //获取一个跑道
    public String getTrack() throws InterruptedException {
        semaphore.acquire(1);
        return getNextAvailableTrack();
    }

    //返回一个跑道
    public void releaseTrack(String track) {
        if (makeAsUnused(track))
            semaphore.release(1);
    }

    //遍历,找到一个没人用的跑道
    private String getNextAvailableTrack() {
        for (int i = 0; i < used.length; i++) {
            if (!used[i]) {
                used[i] = true;
                return tracks[i];
            }
        }
        return null;
    }

    //释放跑道,将使用标志设置为false
    private boolean makeAsUnused(String track) {
        for (int i = 0; i < used.length; i++) {
            if (tracks[i].equals(track)) {
                if (used[i]) {
                    used[i] = false;
                    return true;
                } else {
                    return false;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Executor executor = Executors.newCachedThreadPool();
        Playground playground = new Playground();
        Runnable runnable = ()->{
            try {
                String track = playground.getTrack();//获取跑道
                if (track != null) {
                    System.out.println("学生" + Thread.currentThread().getId() + "在" + track.toString() + "上跑步");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println("学生" + Thread.currentThread().getId() + "释放" + track.toString());
                    playground.releaseTrack(track);//释放跑道
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        for (int i = 0; i < 100; i++) {
            executor.execute(runnable);
        }
    }
}

Semaphore的源码解析

semaphore的构造方法

public Semaphore(int permits) {
    sync = new NonfairSync(permits);//提供许可数量,默认为非公平模式
}

public Semaphore(int permits, boolean fair) {
    //提供许可数量,指定是否为公平模式
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

Sync类

Semaphore内部基于AQS的共享模式,所以实现都委托给了Sync类。

NonfairSync(int permits) {
    super(permits);
}
Sync(int permits) {
    setState(permits);//AQS的state表示许可证的数量
}

Semaphore的acquire获取许可方法

public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    //如果线程被中断了,抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //获取许可失败,将线程加入到等待队列中
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

NonfairSync中tryAcquireShared方法的实现

AQS子类如果要使用共享模式的话,需要实现tryAcquireShared方法,下面看NonfairSync的该方法实现:

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

该方法调用了父类中的nonfairTyAcquireShared方法,如下:

final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        //获取剩余许可数量
        int available = getState();
        //计算给完这次许可数量后的个数
        int remaining = available - acquires;
        //如果许可不够(获取许可失败)或者可以将许可数量重置(获取许可成功)的话,返回。
        //只有在许可不够时返回值才会小于0,其余返回的都是剩余许可数量,这也就解释了,一旦许可不够,后面的线程将会阻塞。
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

FairSync中tryAcquireShared方法的实现

protected int tryAcquireShared(int acquires) {
    for (;;) {
        //如果前面有线程再等待,直接返回-1
        if (hasQueuedPredecessors())
            return -1;
        //后面与非公平一样
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

FairSync与NonFairSync的区别就在于会首先判断当前队列中有没有线程在等待,如果有,就老老实实进入到等待队列;而不像NonfairSync一样首先试一把,说不定就恰好获得了一个许可,这样就可以插队了。

Semaphore的release()释放许可方法

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

releaseShared方法在AQS中,如下:

public final boolean releaseShared(int arg) {
    //如果改变许可数量成功
    if (tryReleaseShared(arg)) {
        doReleaseShared();//一旦CAS改变许可数量成功,就调用该方法释放阻塞的线程。
        return true;
    }
    return false;
}

AQS子类实现共享模式的类需要实现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改变许可数量成功,返回true
        if (compareAndSetState(current, next))
            return true;
    }
}

Semaphore的reducePermits减小许可数量方法

protected void reducePermits(int reduction) {
    if (reduction < 0) throw new IllegalArgumentException();
    sync.reducePermits(reduction);
}

可以看到,委托给了Sync,Sync的reducePermits方法如下:

 final void reducePermits(int reductions) {
    for (;;) {
        //得到当前剩余许可数量
        int current = getState();
        //得到减完之后的许可数量
        int next = current - reductions;
        if (next > current) // underflow
            throw new Error("Permit count underflow");
        //如果CAS改变成功
        //CAS改变AQS中的state变量,因为该变量代表许可证的数量。
        if (compareAndSetState(current, next))
            return;
    }
}

Semaphore的drainPermits获取剩余许可数量

Semaphore还可以一次将剩余的许可数量全部取走,该方法是drain方法,如下:

public int drainPermits() {
    return sync.drainPermits();
}

Sync的实现如下:

 final int drainPermits() {
     for (;;) {
         int current = getState();
         if (current == 0 || compareAndSetState(current, 0))//CAS将许可数量置为0。
             return current;
     }
 }

总结

Semaphore是信号量,用于管理一组资源。其内部是基于AQS的共享模式,AQS的状态表示许可证的数量,在许可证数量不够时,线程将会被挂起;而一旦有一个线程释放一个资源,那么就有可能重新唤醒等待队列中的线程继续执行。

参考地址:

本文转载自:https://blog.csdn.net/qq_19431333/article/details/70212663

长头发-dawn
粉丝 9
博文 27
码字总数 51237
作品 0
西安
私信 提问
Java 多线程系列目录(共43篇)

Java多线程系列目录(共43篇) 最近,在研究Java多线程的内容目录,将其内容逐步整理并发布。 (一) 基础篇 01. Java多线程系列--“基础篇”01之 基本概念 02. Java多线程系列--“基础篇”02之 ...

foxeye
2016/02/29
290
0
JUC整体架构图

JUC相关整体框架图 整体架构.png JUC相关UML图 reentrantlock uml图 reentrantreadwritelock uml图 countdownlatch uml图 semaphore uml图 cyclicbarrier uml图...

小鱼嘻嘻
2018/01/18
0
0
聊聊并发(十三)—AQS框架深入分析

并发系列 聊聊并发(一)深入分析Volatile的实现原理 聊聊并发(二)Java SE1.6中的Synchronized 聊聊并发(三)Java线程池的分析和使用 聊聊并发(四)深入分析ConcurrentHashMap 聊聊并发(...

陶邦仁
2015/11/20
460
0
显式锁(java.util.Concurrent)

一、前言   在分析完了集合框架后,很有必要接着分析java并发包下面的源码,JUC(java.util.concurrent)源码也是我们学习Java迈进一步的重要过程。我们分为几个模块进行分析,首先是对锁模...

狼王黄师傅
2018/11/27
45
0
深入理解JUC(java.util.concurrent)

Concurrent下的核心类 Executor:具有runnable任务的执行者 ExecutorService:一个线程池管理者,实现类有多种,能把runnable,callable提交到线程池中 Semaphore:一个计数信号量 ReentranLock...

最胖的瘦子
04/21
34
0

没有更多内容

加载失败,请刷新页面

加载更多

数据安全管理:RSA算法,签名验签流程详解

本文源码:GitHub·点这里 || GitEE·点这里 一、RSA算法简介 1、加密解密 RSA加密是一种非对称加密,在公开密钥加密和电子商业中RSA被广泛使用。可以在不直接传递密钥的情况下,完成加解密操...

知了一笑
34分钟前
5
0
Podman 使用指南

> 原文链接:Podman 使用指南 Podman 原来是 CRI-O 项目的一部分,后来被分离成一个单独的项目叫 libpod。Podman 的使用体验和 Docker 类似,不同的是 Podman 没有 daemon。以前使用 Docker...

米开朗基杨
今天
6
0
拯救 项目经理个人时间的5个技巧

优秀的项目经理都有一个共同点,那就是良好的时间管理能力。专业的项目经理会确保他们的时间投入富有成效,尽可能避免时间浪费。 时间管理叫做GTD,即Getting Things Done——“把事情做完”...

Airship
今天
7
0
LNMP环境介绍,Mariadb安装,服务管理,mariadb安装3

LNMP环境介绍 Nginx 处理的请求有两种,分为 静态与动态 图片,js,css,视频,音频,flash 等都是静态请求,这些数据都不是保存在数据库里面的 动态请求一般来说,需要的数据是在数据库里面...

doomcat
今天
3
0
前端技术之:Prisma Demo服务部署过程记录

安装前提条件: 1、已经安装了docker运行环境 2、以下命令执行记录发生在MackBook环境 3、已经安装了PostgreSQL(我使用的是11版本) 4、Node开发运行环境可以正常工作 首先需要通过Node包管...

popgis
今天
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部