java高并发系列 - 第15天：JUC中的Semaphore（信号量）

最新推荐文章于 2024-04-10 16:31:38 发布
最新推荐文章于 2024-04-10 16:31:38 发布
阅读量184 收藏
点赞数
分类专栏： Java高并发 文章标签： Semaphore 信号量
原文链接：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933130&idx=1&sn=cecc6bd906e79a86510c1fbb0e66cd21&scene=19#wechat_redirect
版权

java高并发系列 - 第15天：JUC中的Semaphore（信号量）

原创： 路人甲Java 路人甲Java 7月22日

java高并发系列第15篇文章

Semaphore（信号量）为多线程协作提供了更为强大的控制方法，前面的文章中我们学了synchronized和重入锁ReentrantLock，这2种锁一次都只能允许一个线程访问一个资源，而信号量可以控制有多少个线程可以访问特定的资源。

Semaphore常用场景：限流

举个例子：

比如有个停车场，有5个空位，门口有个门卫，手中5把钥匙分别对应5个车位上面的锁，来一辆车，门卫会给司机一把钥匙，然后进去找到对应的车位停下来，出去的时候司机将钥匙归还给门卫。停车场生意比较好，同时来了100两车，门卫手中只有5把钥匙，同时只能放5辆车进入，其他车只能等待，等有人将钥匙归还给门卫之后，才能让其他车辆进入。

上面的例子中门卫就相当于Semaphore，车钥匙就相当于许可证，车就相当于线程。

Semaphore主要方法

Semaphore(int permits)：构造方法，参数表示许可证数量，用来创建信号量

Semaphore(int permits,boolean fair)：构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量

void acquire() throws InterruptedException：从此信号量获取1个许可前线程将一直阻塞，相当于一辆车占了一个车位，此方法会响应线程中断，表示调用线程的interrupt方法，会使该方法抛出InterruptedException异常

 

void acquire(int permits) throws InterruptedException ：和acquire()方法类似，参数表示需要获取许可的数量；比如一个大卡车要入停车场，由于车比较大，需要申请3个车位才可以停放

 

void acquireUninterruptibly(int permits) ：和acquire(int permits) 方法类似，只是不会响应线程中断

 

boolean tryAcquire()：尝试获取1个许可，不管是否能够获取成功，都立即返回，true表示获取成功，false表示获取失败

boolean tryAcquire(int permits)：和tryAcquire()，表示尝试获取permits个许可

boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException：尝试在指定的时间内获取1个许可，获取成功返回true，指定的时间过后还是无法获取许可，返回false

boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException：和tryAcquire(long timeout, TimeUnit unit)类似，多了一个permits参数，表示尝试获取permits个许可

void release()：释放一个许可，将其返回给信号量，相当于车从停车场出去时将钥匙归还给门卫

void release(int n)：释放n个许可

int availablePermits()：当前可用的许可数

示例1：Semaphore简单的使用

package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
 */
public class Demo1 {
    static Semaphore semaphore = new Semaphore(2);

    public static class T extends Thread {
        public T(String name) {
            super(name);
        }

        @Override
        public void run() {
            Thread thread = Thread.currentThread();
            try {
                semaphore.acquire();
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",释放许可!");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new T("t-" + i).start();
        }
    }
}

输出：

1563715791327,t-0,获取许可!
1563715791327,t-1,获取许可!
1563715794328,t-0,释放许可!
1563715794328,t-5,获取许可!
1563715794328,t-1,释放许可!
1563715794328,t-2,获取许可!
1563715797328,t-2,释放许可!
1563715797328,t-6,获取许可!
1563715797328,t-5,释放许可!
1563715797328,t-3,获取许可!
1563715800329,t-6,释放许可!
1563715800329,t-9,获取许可!
1563715800329,t-3,释放许可!
1563715800329,t-7,获取许可!
1563715803330,t-7,释放许可!
1563715803330,t-8,获取许可!
1563715803330,t-9,释放许可!
1563715803330,t-4,获取许可!
1563715806330,t-8,释放许可!
1563715806330,t-4,释放许可!

 

代码中 newSemaphore(2)创建了许可数量为2的信号量，每个线程获取1个许可，同时允许两个线程获取许可，从输出中也可以看出，同时有两个线程可以获取许可，其他线程需要等待已获取许可的线程释放许可之后才能运行。为获取到许可的线程会阻塞在 acquire()方法上，直到获取到许可才能继续。

示例2：获取许可之后不释放

门卫（Semaphore）有点呆，司机进去的时候给了钥匙，出来的时候不归还，门卫也不会说什么。最终结果就是其他车辆都无法进入了。

如下代码：

package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
 */
public class Demo2 {
    static Semaphore semaphore = new Semaphore(2);

    public static class T extends Thread {
        public T(String name) {
            super(name);
        }

        @Override
        public void run() {
            Thread thread = Thread.currentThread();
            try {
                semaphore.acquire();
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");
                TimeUnit.SECONDS.sleep(3);
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new T("t-" + i).start();
        }
    }
}

输出：

1563716603924,t-0,获取许可!
1563716603924,t-1,获取许可!
1563716606925,t-0,运行结束!
1563716606925,t-0,当前可用许可数量:0
1563716606925,t-1,运行结束!
1563716606925,t-1,当前可用许可数量:0

上面程序运行后一直无法结束，观察一下代码，代码中获取许可后，没有释放许可的代码，最终导致，可用许可数量为0，其他线程无法获取许可，会在 semaphore.acquire();处等待，导致程序无法结束。

示例3：释放许可正确的姿势

示例1中，在finally里面释放锁，会有问题么？

如果获取锁的过程中发生异常，导致获取锁失败，最后finally里面也释放了许可，最终会怎么样，导致许可数量凭空增长了。

示例代码：

package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
 */
public class Demo3 {
    static Semaphore semaphore = new Semaphore(1);

    public static class T extends Thread {
        public T(String name) {
            super(name);
        }

        @Override
        public void run() {
            Thread thread = Thread.currentThread();
            try {
                semaphore.acquire();
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());
                //休眠100秒                
                TimeUnit.SECONDS.sleep(100);
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
            System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T t1 = new T("t1");
        t1.start();
        //休眠1秒       
        TimeUnit.SECONDS.sleep(1);
        T t2 = new T("t2");
        t2.start();
        //休眠1秒        
        TimeUnit.SECONDS.sleep(1);
        T t3 = new T("t3");
        t3.start();        
        //给t2和t3发送中断信号        
        t2.interrupt();
        t3.interrupt();
    }
}

输出：

1563717279058,t1,获取许可,当前可用许可数量:0
java.lang.InterruptedException
1563717281060,t2,当前可用许可数量:1    
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)
1563717281060,t3,当前可用许可数量:2    
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)    
	at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)    
	at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)java.lang.InterruptedException    
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)    
	at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)    at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)

程序中信号量许可数量为1，创建了3个线程获取许可，线程t1获取成功了，然后休眠100秒。其他两个线程阻塞在 semaphore.acquire();方法处，代码中对线程t2、t3发送中断信号，我们看一下Semaphore中acquire的源码：

public void acquire() throws InterruptedException

这个方法会响应线程中断，主线程中对t2、t3发送中断信号之后， acquire()方法会触发 InterruptedException异常，t2、t3最终没有获取到许可，但是他们都执行了finally中的释放许可的操作，最后导致许可数量变为了2，导致许可数量增加了。所以程序中释放许可的方式有问题。需要改进一下，获取许可成功才去释放锁。

正确的释放锁的方式，如下：

package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
 */
public class Demo4 {
    static Semaphore semaphore = new Semaphore(1);

    public static class T extends Thread {
        public T(String name) {
            super(name);
        }

        @Override
        public void run() {
            Thread thread = Thread.currentThread();
            //获取许可是否成功            
            boolean acquireSuccess = false;
            try {
                semaphore.acquire();
                acquireSuccess = true;
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());
                //休眠100秒                
                TimeUnit.SECONDS.sleep(5);
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (acquireSuccess) {
                    semaphore.release();
                }
            }
            System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T t1 = new T("t1");
        t1.start();        
        //休眠1秒        
        TimeUnit.SECONDS.sleep(1);
        T t2 = new T("t2");
        t2.start();        
        //休眠1秒        
        TimeUnit.SECONDS.sleep(1);
        T t3 = new T("t3");
        t3.start();        
        //给t2和t3发送中断信号       
        t2.interrupt();
        t3.interrupt();
    }
}

输出：

1563717751655,t1,获取许可,当前可用许可数量:0
1563717753657,t3,当前可用许可数量:0
java.lang.InterruptedException
1563717753657,t2,当前可用许可数量:0    
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)    
	at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)    
	at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)java.lang.InterruptedException    
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)    
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)    
	at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)    
	at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)
1563717756656,t1,运行结束!
1563717756656,t1,当前可用许可数量:1

程序中增加了一个变量 acquireSuccess用来标记获取许可是否成功，在finally中根据这个变量是否为true，来确定是否释放许可。

示例4：在规定的时间内希望获取许可

司机来到停车场，发现停车场已经满了，只能在外等待内部的车出来之后才能进去，但是要等多久，他自己也不知道，他希望等10分钟，如果还是无法进去，就不到这里停车了。

Semaphore内部2个方法可以提供超时获取许可的功能：

public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)        throws InterruptedException

在指定的时间内去尝试获取许可，如果能够获取到，返回true，获取不到返回false。

示例代码：

package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
 */
public class Demo5 {
    static Semaphore semaphore = new Semaphore(1);

    public static class T extends Thread {
        public T(String name) {
            super(name);
        }

        @Override
        public void run() {
            Thread thread = Thread.currentThread();
            //获取许可是否成功            
            boolean acquireSuccess = false;
            try {
                // 尝试在1秒内获取许可，获取成功返回true，否则返回false                
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",尝试获取许可,当前可用许可数量:" + semaphore.availablePermits());
                acquireSuccess = semaphore.tryAcquire(1, TimeUnit.SECONDS);
                //获取成功执行业务代码                
                if (acquireSuccess) {
                    System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可成功,当前可用许可数量:" + semaphore.availablePermits());
                    //休眠5秒                    
                    TimeUnit.SECONDS.sleep(5);
                } else {
                    System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可失败,当前可用许可数量:" + semaphore.availablePermits());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (acquireSuccess) {
                    semaphore.release();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T t1 = new T("t1");
        t1.start();
        //休眠1秒        
        TimeUnit.SECONDS.sleep(1);
        T t2 = new T("t2");
        t2.start();
        //休眠1秒        
        TimeUnit.SECONDS.sleep(1);
        T t3 = new T("t3");
        t3.start();
    }
}

输出：

1563718410202,t1,尝试获取许可,当前可用许可数量:1
1563718410202,t1,获取许可成功,当前可用许可数量:0
1563718411203,t2,尝试获取许可,当前可用许可数量:0
1563718412203,t3,尝试获取许可,当前可用许可数量:0
1563718412204,t2,获取许可失败,当前可用许可数量:0
1563718413204,t3,获取许可失败,当前可用许可数量:0

代码中许可数量为1， semaphore.tryAcquire(1,TimeUnit.SECONDS);：表示尝试在1秒内获取许可，获取成功立即返回true，超过1秒还是获取不到，返回false。线程t1获取许可成功，之后休眠了5秒，从输出中可以看出t2和t3都尝试了1秒，获取失败。

其他一些使用说明

  1. Semaphore默认创建的是非公平的信号量，什么意思呢？这个涉及到公平与非公平。举个例子：5个车位，允许5个车辆进去，来了100辆车，只能进去5辆，其他95在外面排队等着。里面刚好出来了1辆，此时刚好又来了10辆车，这10辆车是直接插队到其他95辆前面去，还是到95辆后面去排队呢？让新来的去排队就表示公平，直接去插队争抢第一个，就表示不公平。对于停车场，排队肯定更好一些。不过对于信号量来说不公平的效率更高一些，所以默认是不公平的。

  2. 建议阅读以下Semaphore的源码，对常用的方法有个了解，不需要都记住，用的时候也方便查询就好。

  3. 方法中带有 throwsInterruptedException声明的，表示这个方法会响应线程中断信号，什么意思？表示调用线程的 interrupt()方法后，会让这些方法触发 InterruptedException异常，即使这些方法处于阻塞状态，也会立即返回，并抛出 InterruptedException异常，线程中断信号也会被清除。

爱我你会火_
关注
专栏目录
【高并发】java JUC中的Semaphore（信号量）
九师兄
11-27 345
1.概述 转载：添加链接描述 Semaphore（信号量）为多线程协作提供了更为强大的控制方法，前面的文章中我们学了synchronized和重入锁ReentrantLock，这2种锁一次都只能允许一个线程访问一个资源，而信号量可以控制有多少个线程可以访问特定的资源。 2.Semaphore常用场景：限流 举个例子： 比如有个停车场，有5个空位，门口有个门卫，手中5把钥匙分别对应5个车位上面的锁，来一辆车，门卫会给司机一把钥匙，然后进去找到对应的车位停下来，出去的时候司机将钥匙归还给门卫。停车场生意比较好.
Java多线程系列--“JUC锁”11之 Semaphore信号量的原理和示例
weixin_30539625的博客
03-22 231
概要 本章，我们对JUC包中的信号量Semaphore进行学习。内容包括：Semaphore简介Semaphore数据结构Semaphore源码分析(基于JDK1.7.0_40)Semaphore示例 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3534050.html Semaphore简介 Semaphore是一个计数信号量，它的本...
java学习系列-高并发14:JUC中的Semaphore（信号量）
星之宇的博客
08-10 316
Semaphore（信号量）为多线程协作提供了更为强大的控制方法，前面的文章中我们学了synchronized和重入锁ReentrantLock，这2种锁一次都只能允许一个线程访问一个资源，而信号量可以控制有多少个线程可以访问特定的资源。 Semaphore常用场景：限流 举个例子： 比如有个停车场，有5个空位，门口有个门卫，手中5把钥匙分别对应5个车位上面的锁，来一辆车，门卫会给司机一把钥匙，然后进去找到对应的车位停下来，出去的时候司机将钥匙归还给门卫。停车场生意比较好，同时来了100两车，门卫手中只有5
java高并发系列 - 第15天：JUC中的Semaphore，最简单的限流工具类，必备技能
07-24 543
这是java高并发系列第15篇文章 Semaphore（信号量）为多线程协作提供了更为强大的控制方法，前面的文章中我们学了synchronized和重入锁ReentrantLock，这2种锁一次都只能允许一个线程访问一个资源，而信号量可以控制有多少个线程可以同时访问特定的资源。 Semaphore常用场景：限流 举个例子： 比如有个停车场，有5个空位，门口有个门卫，手中5把钥匙分别对应5个车位上...
java高并发系列 - 第15天：JUC中的Semaphore（信号量，2024年最新面试完如何回复面试官
最新发布
m0_61549740的博客
04-10 304
System.out.println(System.currentTimeMillis() + “,” + thread.getName() + “,获取许可,当前可用许可数量:” + semaphore.availablePermits());System.out.println(System.currentTimeMillis() + “,” + thread.getName() + “,当前可用许可数量:” + semaphore.availablePermits());为获取到许可的线程会阻塞在。
java并发编程专题（六）----浅析（JUC）Semaphore
08-18
Java 并发编程专题（六）----浅析（JUC）Semaphore 是 Java 并发编程中的一种重要机制，它主要用于控制多个线程访问共享资源的同时性。Semaphore 是一种信号量机制，它维护了一个许可集，通过 acquire() 和 release...
【Java并发】从限流看JUC之Semaphore(信号量)
行雨斋
06-29 947
文章目录A.限流的定义B.QPS限流1.计数器算法（滑动窗口）2.令牌桶算法3.漏桶算法D.Semaphore(信号量)1.AQS2.信号量模型3.Semaphore如何实现信号量模型4.使用Semaphore实现并发数限流5.总结E.最后的总结 本文作者： AceCandy 博客原文链接： https://acecandy.top/archives/从限流看juc之semaphore 版权声明： 本博客所有文章除特别声明外，均采用CC BY-NC-SA 3.0 许可协议。转载请注明出处！ A.限流的定义
java高并发系列 - 第29天：高并发中常见的限流方式
路人甲Java
08-20 854
这是java高并发系列第29篇。环境：jdk1.8。本文内容介绍常见的限流算法通过控制最大并发数来进行限流通过漏桶算法来进行限流通过令牌桶算法来进行限流限流工具类Rate...
Java并发编程（JUC）模拟信号量集
丹丹的后花园
11-17 1729
​ 上一文中，我们使用JUC模拟了AND型信号量，对于信号量集，他的特点就是一次可以申请多个资源，并且可以设置资源分配下限，让设计者可以更好的来控制进程的执行。如果对于进程同步机制还有什么疑惑，可以参考我的另一篇博客。 ​ 为了方便编程，并且信号量集在使用时更加方便，我们定义了一个SemaphoreUnit对象，用这个对象来记录申请的信号量类型，申请的数量和分配下限值，SemaphoreUnit定...
JUC中的Semaphore（信号量）-限流
qq_42858175的博客
06-01 340
synchronized和重入锁ReentrantLock，这2种锁一次都只能允许一个线程访问一个资源，而信号量可以控制有多少个线程可以访问特定的资源 Semaphore常用场景：限流 看过一个大佬写过的例子： 比如有个停车场，有5个空位，门口有个门卫，手中5把钥匙分别对应5个车位上面的锁，来一辆车，门卫会给司机一把钥匙，然后进去找到对应的车位停下来，出去的时候司机将钥匙归还给门卫。停车场生意比较好，同时来了100两车，门卫手中只有5把钥匙，同时只能放5辆车进入，其他车只能等待，等有人将钥匙归还给门卫之后，
Java面试之JUC系列：Semaphore：信号量
Viper的程序员修炼手册
11-28 1501
Semaphore：信号量 概念 信号量主要用于两个目的 一个是用于共享资源的互斥使用 另一个用于并发线程数的控制 代码 我们模拟一个抢车位的场景，假设一共有6个车，3个停车位 那么我们首先需要定义信号量为3，也就是3个停车位 /** * 初始化一个信号量为3，默认是false 非公平锁， 模拟3个停车位 */ Semaphore semaphore = new Semaphore(3, false); 然后我们模拟6辆车同时并发抢占停车位，但第一个车辆抢占到停车位后，信号量需要减1 // 代表一辆车
Java JUC包源码分析 - 信号量Semaphore
ChaosKong的技术总结与分享
09-11 396
信号量是基于共享锁和许可的原理实现，在初始时给定许可数，获取时如果当前许可足够，就获得许可往下执行，否则就阻塞。 信号量还分公平信号量和非公平信号量，两者的区别就在于再尝试获取许可的时候，公平信号量还需要判断当前线程所在的节点是不是CLH队列的头节点，其他都一样。释放锁的过程两者也是一样的。 先看下用法： package com.pzx.test.test00001; import ja...
多线程之Semaphore
ABestRookie的博客
08-21 286
Semaphore 限流，在访问高峰期时，让请求线程阻塞，高峰期过去再释放许可，当然它只适合限制单机 线程数量，并且仅是限制线程数，而不是限制资源数.Semaphore 实现简单连接池，对比『享元模式』下的实现（用wait notify），性能和可读性显然更好.Semaphore 信号量，用来限制能同时访问共享资源的线程上限.
Java学习----JUC包和信号量
hanxuya的博客
09-08 523
JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！1、同步辅助类1）CountDownLatch闭锁是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待2）CyclicBarrier栅栏之所以叫barrier，是因为是一个同步辅助类，允许一组线程互相等待，直到到达某个公共屏障点 ，并且在释放等待线程后可以重用。
JUC系列——Semaphore
耘田
07-15 1641
简介 Semaphore是一种在多线程环境下负责协调各个线程，以保证它们能够正确、合理的使用公共资源。 Semaphore是一种计数信号量，用于管理一组资源，内部是基于AQS的共享模式。它相当于控制使用公共资源的活动线程的数量。 主要方法 主要方法： Semaphore(int permits):构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。 Semaphore(int perm...
【JUC】信号量Semaphore详解
BASK2311的博客
11-30 1352
大家应该都用过关键字加锁，用来保证某个时刻只允许一个线程运行。那么如果控制某个时刻允许指定数量的线程执行，有什么好的办法呢?答案就是JUC提供的信号量Semaphore。Semaphore（信号量）可以用来限制能同时访问共享资源的线程上限，它内部维护了一个许可的变量，也就是线程许可的数量Semaphore的许可数量如果小于0个，就会阻塞获取，直到有线程释放许可Semaphore是一个非重入锁构造方法permits表示许可线程的数量fair表示公平性，如果设为true。
瞅一瞅JUC提供的限流工具Semaphore
zsah2011的博客
07-05 419
微服务架构发展到今天，各个服务之前的调用、接口请求越来越频繁，服务器承受的压力自然也越来越大。如果放任所有请求请求到服务器，不管是服务器也好还是数据也好，都可能被因为无法承受大批量的请求而阻塞、宕机甚至是GG，尤其是一些查询接口请求特别频繁的情况下，是需要对请求进行一定限制的。 譬如：钉钉打卡数据，动辄几十上百万数据，这种数据一秒钟来个几百次请求，钉钉估计也够呛，调用频率肯定有限制。一些支付流水，对账单也是这个原理，在请求方面都有一些限制。 还有，服务接口限制，频繁点击提示亦或是
Java并发编程：JUC内存可见性深度解析
JUC包中包含了许多高级并发工具，如Semaphore信号量、CountDownLatch倒计时器、CyclicBarrier循环栅栏等，这些工具可以帮助开发者更好地控制线程间的协作和同步。例如，CountDownLatch可以在一组任务完成后再继续...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值