Semaphore源码解析

最新推荐文章于 2024-04-10 09:30:00 发布
最新推荐文章于 2024-04-10 09:30:00 发布
阅读量106 收藏
点赞数
分类专栏： Semaphore java 多线程方法 文章标签： Java Semaphore 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38910645/article/details/103511966
版权
java 同时被 3 个专栏收录
19 篇文章 0 订阅
订阅专栏
多线程方法
15 篇文章 0 订阅
订阅专栏
Semaphore
0 篇文章 0 订阅
订阅专栏

Semaphore的使用

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    private final static int SEM_SIZE = 10;
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss SSS");

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(SEM_SIZE);
        MyThread thread1 = new MyThread("test1",semaphore);
        MyThread thread2 = new MyThread("test2",semaphore);
        thread1.start();
        thread2.start();
        int permits = 5;
        System.out.println(prinDate() + Thread.currentThread().getName() + " trying to acquire!");
        try {
            semaphore.acquire(permits);
            System.out.println(prinDate() + Thread.currentThread().getName() + " acquire successfully!");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            semaphore.release();
            System.out.println(prinDate() + Thread.currentThread().getName() + " release successfully!");
        }
    }

    static class MyThread extends Thread{
        private Semaphore semaphore;

        public MyThread(String name,Semaphore semaphore){
            super(name);
            this.semaphore = semaphore;
        }
        @Override
        public void run() {
            int count = 5;
            System.out.println(prinDate() + Thread.currentThread().getName() + " trying to acquire!");
            try {
                semaphore.acquire(count);
                System.out.println(prinDate() + Thread.currentThread().getName() + " acquire successfully!");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                semaphore.release(count);
                System.out.println(prinDate() + Thread.currentThread().getName() + " release successfully!");
            }
        }
    }

    private static String prinDate(){
        return simpleDateFormat.format(new Date()) + " ";
    }
}

Semaphore类图

在这里插入图片描述

Semaphore类的声明

public class Semaphore implements java.io.Serializable

Semaphore类的内部类

Semaphore总共Sync、NonfairSync、FairSync三个内部类，并且三个内部类是紧密相关，NonfairSync和FairSync继承自AQS，Sync继承自AbstractQueuedSynchronizer抽象类。

Sync源码解析

/**
*内部类Sync继承自AQS
*/
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;
            //许可小于0或者CAS设置状态成功
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                //返回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");
        //如果CAS设置成功
        if (compareAndSetState(current, next))
            //返回true
            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");
        //如果CAS成功
        if (compareAndSetState(current, next))
            //返回
            return;
    }
}
/**
*获取并返回所有许可
*/
final int drainPermits() {
    for (;;) {
        //获取许可数
        int current = getState();
        //如果current等于0或者CAS成功
        if (current == 0 || compareAndSetState(current, 0))
            //返回current
            return current;
    }
}

NonfairSync源码解析

NonfairSync类继承了Sync类，表示非公平策略获取资源，其只有一个tryAcquireShared()方式，重写了AQS的tryAcquireShared()方法：

/**
*非公平锁
*/
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;
    //构造器
    NonfairSync(int permits) {
        super(permits);
    }
    //共享模式下获取资源
    protected int tryAcquireShared(int acquires) {
        //调用父类Sync中的nonfairTryAcquireShared()方法
        return nonfairTryAcquireShared(acquires);
    }
}

FairSync源码解析

FairSync类继承了Sync类，表示公平策略获取资源，其只有一个tryAcquireShared()方法，重写了AQS的tryAcquireShared()方法：

static final class FairSync extends Sync {
    private static final long serialVersionUID = 2014338818796000944L;
    //构造器
    FairSync(int permits) {
        super(permits);
    }
    //共享模式下获取资源
    protected int tryAcquireShared(int acquires) {
        for (;;) {
            //同步队列存在比当前线程等待更久的线程
            //如果存在则返回-1
            if (hasQueuedPredecessors())
                return -1;
            //获取state状态
            int available = getState();
            //剩余的许可
            int remaining = available - acquires;
            //如果剩余许可小于0或者CAS成功
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                //返回remaining
                return remaining;
        }
    }
}

Semaphore类的属性

//序列化ID
private static final long serialVersionUID = -3222578661600680210L;
//Sync对象
private final Sync sync;

Semaphore自身只有两个属性，最重要的是Sync属性，基于Semaphore对象的操作绝大多数都转移到了对Sync的操作。

Semaphore类的构造器

/**
 *创建具有给定的许可数的非公平模式的Semaphore
 */
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

/**
 * 创建具有给定的许可数和给定的参数的模式的Semaphore
 */
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

Semaphore类的非公平模式获取许可源码解析

/**
*获取一个许可
*/
public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
/**
*获取多个许可
*/
public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

acquire()调用父类AQS中的acquireSharedInterruptibly()方法:

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    //如果线程已经被中断
    if (Thread.interrupted())
        //抛出InterruptedException异常
        throw new InterruptedException();
    //trytryAcquireShared()方法需要子类实现
    //如果tryAcquireShared()方法返回小于0
    //则获取资源失败
    if (tryAcquireShared(arg) < 0)
        //调用doAcquireSharedInterruptibly()方法
        doAcquireSharedInterruptibly(arg);
}

acquireSharedInterruptibly()方法调用的tryAcquireShared()方法在非公平模式下的实现：

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

tryAcquireShared()方法调用的nonfairTryAcquireShared()方法实现如下：

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

tryAcquireShared()方法返回小于0，则获取资源失败。执行doAcquireSharedInterruptibly()方法:

private void doAcquireInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

最终可以获取大致的方法调用序列（假设使用非公平策略）：
在这里插入图片描述

Semaphore类的非公平模式释放许可源码解析

//释放1个许可
public void release() {
    sync.releaseShared(1);
}
//释放多个许可
public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}

release()方法调用AQS中的releaseShared()方法：

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

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");
        if (compareAndSetState(current, next))
            return true;
    }
}

如果tryReleaseShared()方法返回true将执行:

private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

Semaphore类的公平模式获取许可源码解析

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

与非公平模式相比，公平模式多了hasQueuedPredecessors()方法调用。

Semaphore类的公平模式释放许可源码解析

公平模式的释放许可与非公平模式释放许可源码相同。

努力的小强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Semaphore 源码解析
04-25
具体来看Semaphore的源码： 1. `Semaphore(int permits)`和`Semaphore(int permits, boolean fair)`构造器：根据传入的参数创建非公平锁或公平锁实例。`permits`表示初始的许可数。 2. `Sync`抽象静态类：继承自...
一看就懂的Semaphore源码解析，诸佬们快来看看吧
热门推荐
小威的博客
02-24 3万+
一位朋友问到了我Semaphore类相关的知识，简单看了一下源码复习了一下，写下本篇文章做一个回顾。
Semaphore源码分析
sermonlizhi的博客
01-26 951
一、Semaphore介绍 Semaphore，俗称信号量，它是操作系统PV操作原语在JDK中的实现，同样，它也是基于AbstractQueuedSynchronizer来实现的。 Semaphore通俗理解就是常说的共享锁，它可以定义共享资源的个数，只要共享资源还有，其他线程就可以执行，否则就会被阻塞。 而关于操作系统中PV操作的原语可以参考《详解进程同步》这篇文章中对信号量的详细介绍 Semaphore的功能非常强大，大小为1的信号量，它的功能就类似于互斥锁(ReentrantLock)，同时只能有一个
深入理解 Semaphore 【源码分析】
最新发布
weixin_42118323的博客
04-10 1091
Semaphore 是信号量的意思，一般用来控制同时访问某个资源的线程数量，协调各个线程合理的访问公共资源，Semaphore 的底层依赖的是 AQS。Semaphore 使用计数器来控制对共享资源的访问， 如果计数器大于0，则表示允许访问共享资源， 如果为 0，则表示共享资源已经达到访问的上限就拒绝访问， 计数器的计数的就是允许同时访问共享资源的线程数。
Semaphore 源码解读
小毕超博客
03-09 483
通过阅读Semaphore的源码可以发现，大量依赖于AQS中提供的方法，如果有阅读过ReentrantLock 锁源码的分析，可以发现相似度极高，都是使用AQS所提供的的特征实现某些场景的应用。
FrameWork源码解析1
08-03
【标题】: "深入理解Android Binder机制：前置知识解析" 【描述】: "本文将带你探索Binder成为Android系统核心组件的基石，分析学习Binder前必须掌握的Linux IPC基础概念，帮助你迈向高级工程师之路。" 【标签】: ...
Linux内核源码深度解析与开发实战视频.zip
11-27
19：可睡眠锁：信号量semaphore_rec 20：可睡眠锁：读写信号量rwsem_rec 21：可睡眠锁：完成变量completion_rec 22：可睡眠锁：SRCUsleepable_read-copy-update_rec 23：原子操作_rec 24：内存屏障_rec ...........
Java并发系列之AbstractQueuedSynchronizer源码分析（概要分析）
08-27
**Java并发系列之AbstractQueuedSynchronizer源码分析概要** **1. AbstractQueuedSynchronizer（AQS）的定义与作用** AbstractQueuedSynchronizer（AQS）是Java并发编程中的核心组件，它是一个抽象的、基于FIFO...
Java JDK实例宝典
06-16
7 表达式解析器 5. 8 字符串编码的转换 5. 9 字符串对齐器 5. 10 密码加密与验证 5. 11 制作命令行程序 5. 12 使用StringTokenizer 5. 13 使用正则表达式操作字符串 5. 14 使用正则...
Semaphore源码解读
桐花思雨
09-22 222
目录`Semaphore` 概述`Semaphore` 源码类图构造器及内部类 Semaphore 概述 Semaphore 来自于 JDK 1.5 的 JUC 包，直译过来就是 信号量，被作为一种多线程并发控制工具来使用 Semaphore 可以控制同时访问共享资源的线程个数，线程通过 acquire() 方法获取一个信号量，信号量减一，如果没有就等待；通过 release() 方法释放一个信号量，信号量加一 它通过控制信号量的总数量，以及每个线程所需获取的信号量数量，进而控制多个线程对共享资源访问的并
Semaphore 源码分析
小雨点的博客
01-18 397
Semaphore介绍：  Semaphore 用于对某一物理或逻辑资源被同一时间访问数量的限制.  实现：  Semaphore 是如何做到对某一物理或逻辑资源访问数量的限制了？  答案是 AQS.  比如我定义：Semaphore(10), 同一时刻只能有 10 个线程访问线程池，每来一个线程，state -1，当第11线程访问的结果是啥了？由于 state &lt; 0 而被阻塞....
CountDownLatch源码解析
09-21
在CountDownLatch的源码解析中，可以重点关注countDown方法和await方法的实现。countDown方法通过减少计数器的值来控制事件的完成。await方法则通过等待计数器变为0来实现阻塞。 另外，可以参考《Semaphore源码分析...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值