AQS_Semaphore源码分析

最新推荐文章于 2024-08-22 15:21:00 发布
最新推荐文章于 2024-08-22 15:21:00 发布
阅读量196 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51809035/article/details/127577073
版权

基于AQS 的Semaphore 和 CountDownLatch 一样都是共享模式。
建议 把 Semaphore 和 CountDownLatch 放在一起对比这看。

CountDownLatch 在等待数字变为0，Semaphore在等待数字大于0.

1、Semaphore 简介

Semaphore 顾名思义 就是信号量的意思，是基于AQS 的一个类

Semaphore 维护了一个许可集合，在创建Semaphore的时候，设置上许可数，每条线程在只有在获得一个许可的时候才可以继续往下执行逻辑，申请多少许可，Semaphore的许可池中减少多少许可，当没有许可 或 许可不够的时候，申请许可的线程就会进入阻塞状态（加入阻塞队列）。

在这里插入图片描述

2、入门案例

Demo1

停车厂例子：
开始时 里面没有车，只进车，后来里面满了，后面的车等待里面的车出来，再后来，进车和出车达到平衡

//停车场同时容纳的车辆10
    private  static  Semaphore semaphore=new Semaphore(3);

    public static void main(String[] args) {

        //模拟100辆车进入停车场
        for(int i=0;i<10;i++){

            new Thread(() -> {
                try {
                    System.out.println("===="+Thread.currentThread().getName()+"来到停车场");
                    if(semaphore.availablePermits()==0){
                        System.out.println("车位不足，请耐心等待");
                    }
                    semaphore.acquire();//获取令牌尝试进入停车场
                    System.out.println(Thread.currentThread().getName()+"成功进入停车场");
                    Thread.sleep(new Random().nextInt(10000));//模拟车辆在停车场停留的时间
                    System.out.println(Thread.currentThread().getName()+"驶出停车场");
                    semaphore.release();//释放令牌，腾出停车场车位
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },i+"号车").start();

        }
    }

执行结果：

====0号车来到停车场
====2号车来到停车场
0号车成功进入停车场
====4号车来到停车场
====1号车来到停车场
====3号车来到停车场
车位不足，请耐心等待
====5号车来到停车场
车位不足，请耐心等待
车位不足，请耐心等待
4号车成功进入停车场
====7号车来到停车场
车位不足，请耐心等待
====6号车来到停车场
车位不足，请耐心等待
2号车成功进入停车场
4号车驶出停车场
3号车成功进入停车场
0号车驶出停车场
5号车成功进入停车场
2号车驶出停车场
1号车成功进入停车场
3号车驶出停车场
7号车成功进入停车场
5号车驶出停车场
6号车成功进入停车场
1号车驶出停车场
6号车驶出停车场
7号车驶出停车场

Demo2

三个线程，线程A先获取许可，然后休眠10秒

 public static void main(String[] args) throws InterruptedException {
        // 声明信号量，初始的许可（permits）为2
        // 公平模式：fair为true
        final Semaphore semaphore = new Semaphore(2, true);

        Thread tA = new Thread(() ->{
            try {
                // 每次调用acquire()都将消耗一个许可（permits）
                semaphore.acquire();
                System.out.println("线程A获取通行证成功");
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
            }finally {
                // 每次调用release()都将归还一个许可（permits）
                semaphore.release();
            }
        });
        tA.start();
        // 确保线程A已经执行
        TimeUnit.MILLISECONDS.sleep(200);

        Thread tB = new Thread(() ->{
            try {
                // 调用acquire(2)都将消耗2个许可（permits）
                semaphore.acquire(2);
                System.out.println("线程B获取通行证成功");
            } catch (InterruptedException e) {
            }finally {
                // 调用release(2)都将归还2个许可（permits）
                semaphore.release(2);
            }
        });
        tB.start();
        // 确保线程B已经执行
        TimeUnit.MILLISECONDS.sleep(200);

        Thread tC = new Thread(() ->{
            try {
                // 每次调用acquire()都将消耗一个许可（permits）
                semaphore.acquire();
                System.out.println("线程C获取通行证成功");
            } catch (InterruptedException e) {
            }finally {
                // 每次调用release()都将归还一个许可（permits）
                semaphore.release();
            }
        });
        tC.start();
    }

执行结果：

线程A获取通行证成功
线程B获取通行证成功
线程C获取通行证成功

线程B 会在线程A释放许可之后才会 获得许可，

3、源码分析

构造方法

	//一个参数： 代表许可的数量，当许可的数量为0时，后来获取许可的线程就进入阻塞状态
	//Semaphore默认使用 非公平模式
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
    // 两个参数，可以指定 是否 公平
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

公平锁：先检查队列是否有 其它线程等待，如果有排队 等待，如果没有获取锁
非公平锁：会先尝试获取锁，如果获取不到，再排队等待

内部类 Sync

通过 Sync 的几个实现方法，我们可以知道：

  1. 许可是在构造方法时传入的
  2. 许可存放在状态变量 state 中
  3. 尝试获取一个许可的时候，则state 的值减1
  4. 当state的值为 0时，则无法再获取许可
  5. 释放一个许可的时候，则state的值加1
  6. 许可的个数可以动态改变
    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，直接返回
                //当许可数大于等于0，尝试 原子更新state的值，成功的话返回许可
                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");
                //如果原子操作更新state成功,就说明释放许可成功,返回true
                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");
                // 原子更新state的值，成功了返回;
                if (compareAndSetState(current, next))
                    return;
            }
        }
        // 销毁许可
        final int drainPermits() {
            for (;;) {
                // 先看看还有几个许可
                int current = getState();
                // 如果为0，直接返回
                // 如果不为0，把state原子更新为0
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
    }

内部类 NonfairSync

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;
        // 构造方法，调用父类的构造方法
        NonfairSync(int permits) {
            super(permits);
        }
        // 尝试获取许可，调用父类的nonfairTryAcquireShared()方法
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }

内部类FairSync

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

        FairSync(int permits) {
            super(permits);
        }

        /**
         * 尝试获取通行证，获取成功 返回 >=0 的值,获取失败 返回 <0 的值
         * @param acquires
         * @return
         */
        protected int tryAcquireShared(int acquires) {
            //自旋
            for (;;) {
                //判断当前AQS 阻塞队列内 是否有等待线程，如果有返回-1，表示acquire()操作的线程需要进入队列等待
                if (hasQueuedPredecessors())
                    return -1;

                //执行到这里的情况：
                //1. 调用acquire()时 AQS 阻塞队列内没有其它等待者
                //2. 当前节点在阻塞队列内是headNext节点

                //获取state,state 代表通行证
                int available = getState();
                //remaining 表示当前线程 获取完通行证完成之后, Semaphore 还剩余数量
                int remaining = available - acquires;

                //条件一：available < acquires
                //      说明我取通行证失败,继续自旋
                //条件二：前置条件remaining > 0, CAS更新state成功，说明线程获取通行证成功，相反则失败
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

        /* AQS */ //调用 acquire() 的时候会调用该方法，目的是为了获取 一个许可,否则进入等待
        public final void acquireSharedInterruptibly(int arg)
                throws InterruptedException {
            //说明当前调用await方法的线程 已经是 中断状态了，直接抛出异常
            if (Thread.interrupted())
                throw new InterruptedException();

            // 对应业务层面 执行任务的线程已经将latch打破了,然后再调用latch.await的线程,就不会在这里阻塞了.
            if (tryAcquireShared(arg) < 0)
                //说明尝试获取  通行证失败
                doAcquireSharedInterruptibly(arg);
        }

        /*AQS */
        private void doAcquireSharedInterruptibly(int arg)
                throws InterruptedException {
            //将调用latch.await 方法的线程包装成node 加入到 AQS 的阻塞队列中
            final Node node = addWaiter(Node.SHARED);
            boolean failed = true;

            try {
                for (;;) {
                    //获取前驱节点
                    final Node p = node.predecessor();
                    //说明当前节点是head.next节点
                    if (p == head) {
                        //head.next节点有权利获取共享锁
                        int r = tryAcquireShared(arg);

                        //站在Semaphore 角度：r代表还剩余的通行证数量
                        if (r >= 0) {
                            setHeadAndPropagate(node, r);
                            p.next = null; // help GC
                            failed = false;
                            return;
                        }
                    }
                    //shouldParkAfterFailedAcquire 给当前节点找一个正常的前驱节点,
                    //如果碰到取消状态的节点就跳过,设置正常节点为signal
                    // 找一个好爸爸，最终爸爸节点设置为 signal(-1) 状态，返回true
                    if (shouldParkAfterFailedAcquire(p, node) &&
                            //挂起当前节点
                            parkAndCheckInterrupt())
                        throw new InterruptedException();
                }
            } finally {
                if (failed)
                    cancelAcquire(node);
            }
        }

        /*AQS */
        private void setHeadAndPropagate(Node node, int propagate) {
            Node h = head; // Record old head for check below
            //当前节点设置为head节点
            setHead(node);
            //propagate=1 所以恒成立
            if (propagate > 0 || h == null || h.waitStatus < 0 ||
                    (h = head) == null || h.waitStatus < 0) {
                //后继节点
                Node s = node.next;
                //1.s==null   说明当前节点已经是tail,条件一定成立
                //2.前置条件:s!=null,要求s节点的模式必须是 共享模式,
                //latch.await ->addWaiter(Node.Shared)
                if (s == null || s.isShared())
                    //基本上都会执行到doReleaseShared
                    doReleaseShared();
            }
        }

        /*AQS  */
        public final boolean releaseShared(int arg) {
            // 条件成立：表示当前线程释放资源成功，释放资源成功后，去唤醒获取资源失败的线程..
            if (tryReleaseShared(arg)) {
                // 唤醒获取资源失败的线程..
                doReleaseShared();
                return true;
            }
            return false;
        }

        /*AQS 重点*/
        /** 唤醒获取资源失败的线程
         *
         * CountDownLatch版本：
         * 有哪几种情况调用doReleaseShared
         * 1.latch.countDown()->state==0 -> doReleaseShared 唤醒当前阻塞队列内的head，next对应的线程
         * 2.doAcquireSharedInterruptibly 方法中线程挂起后被唤醒,
         * 自旋发现前置节点是head节点,就会调用这个方法
         *
         * Semaphore 版本
         */
        private void doReleaseShared() {
            for (;;) {
                Node h = head;
                //1. 说明队列不为空
                //什么时候h==null: 没有调用await方法,直接调用了countDown操作, 此时state-1，但是队列没有节点
                //2. c说明当前除了头节点还有其它节点
                //h==tail:
                //  1.正常唤醒的情况下,依次获取到共享锁,当前线程执行到这里时,(这个线程就是tail节点)
                //  2.第一个调用await方法的线程 与 调用countDown且触发唤醒阻塞节点的线程 出现并发了
                //      就是说,第一次调用await时,队列什么也没有,它需要补充创建一个head节点,然后再次自旋时入队
                //      在await线程入队完成之后,假设当前队列内 只有 刚刚创建的空元素head,
                //      同期,外部有一个调用countDown 的线程,将state从1 变为0,就会执行该方法 唤醒阻塞队列内元素的逻辑
                if (h != null && h != tail) {
                    //能进入if说明当前节点肯定有后继节点

                    //头节点的状态
                    int ws = h.waitStatus;
                    //头节点的状态为Signal,则唤醒头节点,并修改状态为0
                    if (ws == Node.SIGNAL) {
                        //唤醒后继节点 将head节点的状态改为0
                        //为什么使用CAS呢?
                        //当doReleaseShared方法存在多个线程唤醒head.next逻辑时
                        //CAS可能失败
                        //案例:
                        //t3线程在if(h==head) 返回false时,t3会继续自旋,参与到下一个head.next的逻辑
                        //t3 此时执行到CAS会成功..t4在t3修改成功之前,也进入到if(ws == Node.SIGNAL)里面
                        //但是t4 修改CAS 会失败 因为t3已经改过了
                        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
                }
                //条件成立:
                //1.说明刚刚唤醒的 后继节点,还没执行到 setHeadAndPropagate 方法里面, 设置当前唤醒节点为head的逻辑
                //  这个时候,当前线程,直接跳出去
                //  此时用不用担心 唤醒逻辑 在这里断掉呢?
                //  不需要担心,因为被唤醒的线程早晚会执行到doReleaseShared
                //2.h==null latch创建出来后,没有调用await方法,直接调用了countDown操作,
                //  此时state-1，但是队列没有节点
                //3.h==tail: head 和 tail 指向的是同一个node对象

                //条件不成立：
                //被唤醒的节点 非常积极,直接将自己设置为了新的head,此时 唤醒它的节点(前驱),执行h==head条件不成立
                //此时head节点的前驱,不会跳出doReleaseShared 方法,会继续唤醒新head 节点的后继节点
                if (h == head)                   // loop if head changed
                    break;
            }
        }

    }

acquire() 方法

获取一个许可，默认是使用可中断方式，如果尝试获取许可失败，就加入AQS的队列中排队

可中断方式的获取许可 内部有一个中断判断

    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
可中断方式的获取许可 内部多了这样一个判断：
	if (Thread.interrupted())
	            throw new InterruptedException();
----------------------------------------------------------
    public void acquireUninterruptibly() {
        // 获取一个许可，非中断方式，如果尝试获取许可失败，会进入AQS的队列中排队。
        sync.acquireShared(1);
    }

acquire(int permits)方法

一次获取多个许可，可中断方式。

public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

// 一次获取多个许可，非中断方式。
public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
}

tryAcquire()方法

尝试获取一个许可，使用Sync的非公平锁尝试获取许可的方法，只尝试一个获取许可，获取失败就进入队列等待。

    public boolean tryAcquire() {
        return sync.nonfairTryAcquireShared(1) >= 0;
    }
    
    public boolean tryAcquire(long timeout, TimeUnit unit)
        throws InterruptedException {
        // 尝试获取一个许可，先尝试一次获取许可，如果失败则会等待timeout时间，这段时间内都没有获取到许可，则返回false，否则返回true；
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

release() 方法

释放一个许可，释放一个许可是state值会加1，并且会释放下一个正在等待获取 许可的线程

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

release(int permits) 方法

一次释放多个许可，state的值会相应增加permits的数量。

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

4、总结

  1. Semaphore 信号量，通常用于控制同一时刻对共享资源的访问，也就是限流场景；
  2. Semaphore 的内部实现是就与AQS的共享锁来实现的；
  3. Semaphore 是共享模式；
  4. Semaphore初始化的时候需要指定许可的次数，许可的次数是存储在state中；
  5. 获取一个许可时，则state值减1，释放一个许可时，则state值加1。
猴子会跳舞
关注
AQS源码分析 (1).pdf
01-22
接下来，我们来具体分析一下AQS的源码。AQS中定义了一个名为state的volatile变量，用于表示同步状态。这个变量有三种操作方法：getstate()、setstate()和compareAndSetState()，分别用于获取、设置和原子性地更新...
Semaphore源码分析
sermonlizhi的博客
01-26 1017
一、Semaphore介绍 Semaphore，俗称信号量，它是操作系统PV操作原语在JDK中的实现，同样，它也是基于AbstractQueuedSynchronizer来实现的。 Semaphore通俗理解就是常说的共享锁，它可以定义共享资源的个数，只要共享资源还有，其他线程就可以执行，否则就会被阻塞。 而关于操作系统中PV操作的原语可以参考《详解进程同步》这篇文章中对信号量的详细介绍 Semaphore的功能非常强大，大小为1的信号量，它的功能就类似于互斥锁(ReentrantLock)，同时只能有一个
深入理解 Semaphore 【源码分析】
weixin_42118323的博客
04-10 1157
Semaphore 是信号量的意思，一般用来控制同时访问某个资源的线程数量，协调各个线程合理的访问公共资源，Semaphore 的底层依赖的是 AQS。Semaphore 使用计数器来控制对共享资源的访问， 如果计数器大于0，则表示允许访问共享资源， 如果为 0，则表示共享资源已经达到访问的上限就拒绝访问， 计数器的计数的就是允许同时访问共享资源的线程数。
Semaphore 源码解读
小毕超博客
03-09 522
通过阅读Semaphore的源码可以发现，大量依赖于AQS中提供的方法，如果有阅读过ReentrantLock 锁源码的分析，可以发现相似度极高，都是使用AQS所提供的的特征实现某些场景的应用。
JAVA并发编程【Semaphore】源码解析
qq_43600166的博客
06-24 733
Semaphore翻译过来的意思是信号、信号量。该类的主要作用是用于限制线程访问共享资源的数量。通俗一点来说，就是起到限流的作用。比如我们最常见的接口限流：当我们对外暴露一个接口时，应该对该接口的最大并行数进行控制。而Semaphore正好可以控制线程访问共享资源的数量，因此在单机部署的情况下，可以使用Semaphore来处理接口限流。synchronized关键字想必大家并不会感到陌生，synchronized可以控制共享资源同时只能被一个线程访问，而Semaphore更像是synchronized的升级
8、深入理解AQS之共享锁Semaphore
最新发布
sproutBoy的博客
08-22 472
公平锁，优先判断等待队列中是否有挂起的线程，如果有，则将当前线程添加到等待队列中，等待唤醒后抢夺信号量；非公平锁，不管等待队列中是否有挂起线程，优先尝试获取信号量，获取失败，将当前线程添加到等待队列。
Java并发 结合源码分析AQS原理
08-25
Java并发结合源码分析AQS原理 Java并发编程中，AQS（AbstractQueuedSynchronizer）是一个核心组件，它提供了一个基于FIFO队列和状态变量的基础框架，用于构建锁和其他同步装置。在这篇文章中，我们将深入探讨AQS的...
Java并发系列之Semaphore源码分析
08-27
Java并发系列之Semaphore源码分析 Java并发系列之Semaphore源码分析是Java并发系列中的一篇重要文章，主要为大家详细介绍了Java并发系列之Semaphore源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 ...
7 AQS源码分析.docx
12-11
本文将详细分析AQS的源码，探讨其工作机制，以及在Java中如何实现不同类型的锁。 首先，我们需要了解锁的基本类型。在Java中，锁主要分为两类：悲观锁和乐观锁。悲观锁认为并发操作会导致数据不一致，因此在操作...
Java并发包源码分析(JDK1.8)
06-13
Java并发包源码分析(JDK1.8)：囊括了java.util.concurrent包中大部分类的源码分析，其中涉及automic包，locks包(AbstractQueuedSynchronizer、ReentrantLock、ReentrantReadWriteLock、LockSupport等)，queue...
一看就懂的Semaphore源码解析，诸佬们快来看看吧
热门推荐
小威的博客
02-24 3万+
一位朋友问到了我Semaphore类相关的知识，简单看了一下源码复习了一下，写下本篇文章做一个回顾。
Semaphore源码解读
桐花思雨
09-22 241
目录`Semaphore` 概述`Semaphore` 源码类图构造器及内部类 Semaphore 概述 Semaphore 来自于 JDK 1.5 的 JUC 包，直译过来就是 信号量，被作为一种多线程并发控制工具来使用 Semaphore 可以控制同时访问共享资源的线程个数，线程通过 acquire() 方法获取一个信号量，信号量减一，如果没有就等待；通过 release() 方法释放一个信号量，信号量加一 它通过控制信号量的总数量，以及每个线程所需获取的信号量数量，进而控制多个线程对共享资源访问的并
JUC-Semaphore源码分析
zqj1172102457的博客
07-24 292
建议阅读Semaphore源码分析之前，先阅读，了解一下Semaphore用处以及基本用法。我们知道Semaphore是一个信号量，在java并发编程中，Semaphore本质上是一个共享锁的，用来限制多线程对共享资源的并发访问的。......
Semaphore源码解析
qq_50313418的博客
01-18 611
目录1. 简介2. 小例子3. 源码解析3.1 内部类3.1.1 Sync3.1.2 NonfairSync3.1.3 FairSync3.2 成员变量3.3. 构造方法3.4 成员方法3.4.1 获取资源相关的成员方法3.4.1.1 acquire()方法3.4.1.2 acquireSharedInterruptibly(int arg)方法3.4.1.3 tryAcquireShared(int acquires)方法3.4.1.4 doAcquireSharedInterruptibly(int a
Java 并发 --- Semaphore源码分析
小张的专栏
12-03 406
Semaphore（信号量）是用来控制同时访问特定资源的线程数量,可以用于做流量控制，特别是公共资源有限的应用场景，如果熟悉操作系统的概念，那么肯定对这么名词不陌生，当初在学习Linux进程通信中，也简单的学习过，今天再次接触到Semaphore。
AQS源码解析：Java锁实现深度剖析
"AQS源码分析"是一份深入研究Java锁底层实现的关键文档，主要关注的是AbstractQueuedSynchronizer（AQS）类的内部工作机制。AQS是Java并发库中的一个重要组件，它提供了一个模板用于同步器的设计，许多Java内置的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值