Semaphore的使用

最新推荐文章于 2023-12-19 13:58:49 发布
最新推荐文章于 2023-12-19 13:58:49 发布
阅读量431 收藏 1
点赞数
分类专栏： Java JUC学习笔记 文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lazy__Feng/article/details/104169399
版权

Semaphore类

简介
   Semaphore类所提供的功能完全是synchorized关键字的升级版，但是它提供的功能更加的强大与方便，==主要作用就是控制线程并发的数量==，但是这一点，是synchorized所做不到的
常见API：

在这里插入图片描述

使用
   单词Semaphore的中文含义就是信号、信号系统，此类的主要作用的就是限制线程并发的数量，如果不限制现场并发的数量，则CPU资源很快被耗尽，每个线程执行的任务是相当缓慢。因为CPU要把时间片分配给不同的线程对象，而且上下文切换也要耗时，最终造成系统运行效率大幅降低。
   Smaphore类发放许可的计算方式是“减法”操作。
1、Semaphore类的同步性
   多线程中的同步概念其实就是排队执行任务，执行任务是一个一个执行，不能并行执行，优点是有助于程序逻辑的正确性，不会出现非线程安全的问题，保证软件功能的稳定性。
   现在使用一个案例来看Semaphore是如何限制并发数的：

public class Service {
    //permits为1代表同一时间内，最多允许一个线程同时执行acquire()和release()之间的代码
    private Semaphore semaphore = new Semaphore(1);
    public void testMethod(){
        try {
            //使用1个许可，是减法操作
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+"begin timer="+System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName()+"end timer="+System.currentTimeMillis());
            semaphore.release();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}



public class ThreadA extends Thread {

    private Service service;

    public ThreadA(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}


public class ThreadB extends Thread {

    private Service service;

    public ThreadB(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}


public class ThreadC extends Thread {

    private Service service;

    public ThreadC(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}


public class Run {

    
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        ThreadB b = new ThreadB(service);
        b.setName("B");
        ThreadC c = new ThreadC(service);
        c.setName("C");

        a.start();
        b.start();
        c.start();
    }
}

运行结果：

在这里插入图片描述
由此可看到3个线程是同步的

2、API 方法的使用
2.1、方法acquire(int permits)参数作用及动态添加permits许可数量
有参方法acquire(int permits)的功能是每调用1次该方法，就使用x个许可
代码示例如下：

public class Service {

	private Semaphore semaphore = new Semaphore(10);
	
	public void testMethod() {
		try {
			semaphore.acquire(2);
			System.out.println("Test");
			Thread.sleep(5000);
			semaphore.release(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

如果多次调用Semaphore类的release()或者release(int)方法时，还可以动态增加permits的个数，例如：

public class Run {

	public static void main(String[] args) {
		Semaphore semaphore = new Semaphore(5);
		try {
			semaphore.acquire();
			semaphore.acquire();
			semaphore.acquire();
			semaphore.acquire();
			semaphore.acquire();
			System.out.println(semaphore.availablePermits());
			semaphore.release();
			semaphore.release();
			semaphore.release();
			semaphore.release();
			semaphore.release();
			semaphore.release();
			System.out.println(semaphore.availablePermits());
			semaphore.release(4);
			System.out.println(semaphore.availablePermits());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

在这里插入图片描述
如结果所示：new Semaphore(5)中的5并不是最终的许可证数量，仅仅是初始的状态值。

2.2、方法acquireUninterruptibly的使用
方法acquireUninterruptibly()的作用是使等待进入acquire()方法的线程，不允许被中断。
中断案例：

public class Service {

	private Semaphore semaphore = new Semaphore(1);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
			for(int i=0;i<10000/50;i++) {
				System.out.println(i);
				Thread.sleep(1000);
				
			}
			System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
			semaphore.release();
		} catch (InterruptedException e) {
			System.out.println("线程"+Thread.currentThread().getName()+"进入了catch");
			e.printStackTrace();
		}
	}
}

public class Run {

	public static void main(String[] args)  {
		Service service  = new Service();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();
		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();
		a.interrupt();
		System.out.println("main中断了a");
	}
}


public class ThreadA extends Thread {

	private Service service;
	
	public ThreadA(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.testMethod();
	}
}

public class ThreadB extends Thread {

	private Service service;
	
	public ThreadB(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.testMethod();
	}
}

运行结果如图：
在这里插入图片描述
不可中断案例：
将Service中的acquire()修改成acquireUninterruptibly()方法，其他代码无需修改

public class Service {

	private Semaphore semaphore = new Semaphore(1);
	
	public void testMethod() {
		try {
		    //此处修改为不可中断获取
			semaphore.acquireUninterruptibly();
			System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
			for(int i=0;i<10000/50;i++) {
				System.out.println(i);
				Thread.sleep(1000);
				
			}
			System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
			semaphore.release();
		} catch (InterruptedException e) {
			System.out.println("线程"+Thread.currentThread().getName()+"进入了catch");
			e.printStackTrace();
		}
	}
}

结果如下：
在这里插入图片描述

在此我们可以看到当使用acquireUninterruptibly和acquire的使用场景是不一样的，acquire是等待许可的过程中允许中断的，acquireUninterruptibly是等待许可的过程中不允许中断的，acquireUninterruptibly()以及acquireUninterruptibly（int permits）作用是一样的，如果成功获取锁，则取得指定的permits许可个数，具体使用哪一个取决于我们业务逻辑和场景。
2.3、方法availablePermits()和drainPermits()的使用
availablePermits()返回Semaphore对象中当前可用的许可数，此方法通常用于开发调试，因为许可的数量是实时在变化，不是一个固定的值
drainPermits()可以获取并返回立即可用的所有许可个数，并且将可用许可置为0

案例如下：

public class MyService {

	private Semaphore semaphore = new Semaphore(10);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			System.out.println(semaphore.availablePermits());
			System.out.println(semaphore.drainPermits()+" "+semaphore.availablePermits());
			System.out.println(semaphore.drainPermits()+" "+semaphore.availablePermits());
			System.out.println(semaphore.drainPermits()+" "+semaphore.availablePermits());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			semaphore.release();
		}
	}
}

public class Run {

	public static void main(String[] args)  {
		MyService service = new MyService();
		service.testMethod();
	}
}

结果如图所示：
在这里插入图片描述

从结果我们可以发现:
drainPermits()会一次性消费所有的许可，因此当我们不想其他线程同时去消费许可，可以使用此方法来提前消费
2.4、方法getQueueLength()和hasQueueThreads()方法的使用
方法getQueueLength()的作用是取得等待许可的线程个数
方法hasQueueThreads()的作用是判断有没有线程在等待许可
这两个方法通常都是在判断当前有没有等待许可的线程信息时使用

案例如下：

public class MyService {
	
	private Semaphore semaphore  = new Semaphore(1);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			Thread.sleep(1000);
			System.out.println("还有大约:"+semaphore.getQueueLength()+"个线程在等待");
			System.out.println("是否有线程正在等待信号量呢?"+semaphore.hasQueuedThreads());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally {
			semaphore.release();
		}
	}

}

public class MyThread  extends Thread{
	
	private MyService service;
	public MyThread(MyService service) {
		super();
		this.service = service;
	}
	
	@Override
	public void run() {
		service.testMethod();
	}

}


public class Run {

	public static void main(String[] args) {
		MyService service = new MyService();
		MyThread firstThread = new MyThread(service);
		firstThread.start();
		
		MyThread[] threadArray = new MyThread[4];
		for(int i=0;i<4;i++) {
			threadArray[i] = new MyThread(service);
			threadArray[i].start();
		}
	}
}

结果如图所示：
在这里插入图片描述

2.5、方法tryAcquire()及其重载方法的使用
无参方法tryAcquire()的作用是尝试地获取1个许可，如果获取不到则返回false,此方法通常与if语句结合使用，其具有无阻塞的特点。无阻塞的特点可以使线程不至于在同步处一直持续等待的状态，如果if语句判断不成立则线程会继续走else语句，程序会继续运行。
有参方法tryAcquire(int permits)的作用是尝试地获取x个许可，如果获取不到则返回false。
有参方法tryAcquire(int long timeout,TimeUnit unit)的作用是在指定的时间内尝试获取1个许可，如果获取不到则返回false。
有参方法tryAcquire(long permits,long timeout,TimeUnit unit)的作用是在指定的时间内尝试地获取x个许可，如果获取不到则返回false。

案例如下：

public class Service {
	private Semaphore semaphore = new Semaphore(3);
	
	public void testMethod() {
		try {
			if (semaphore.tryAcquire(3, 3, TimeUnit.SECONDS)) {
				System.out.println("ThreadName="+Thread.currentThread().getName()+"首选进入！");
				for (int i = 0; i < Integer.MAX_VALUE; i++) {
					
				}
				semaphore.release();
			}else {
				System.out.println("ThreadName="+Thread.currentThread().getName()+"未成功进入!");
			}
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class Run {

	public static void main(String[] args) {
		Service service = new Service();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();
		
		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();
		
	}
}

结果如图所示：
在这里插入图片描述

2.6、公平和非公平信号量
所谓的公平信号量是获得锁的顺序与线程启动的顺序有关，但不代表100%地获得信号量，仅仅是在概率上能得到保证，而非公平信号量则与其无关。

案例如下：
非公平信号量：

public class MyService {
	private boolean isFair = false;
	private Semaphore semaphore = new Semaphore(1,isFair);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			System.out.println("ThreadName="+Thread.currentThread().getName());
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}finally {
			semaphore.release();
		}
	}

}

public class MyThread  extends Thread{

	private MyService myService;
	
	public MyThread(MyService myService) {
		super();
		this.myService = myService;
	}
	@Override
	public void run() {
		System.out.println("ThreadName="+this.getName()+"启动了！");
		myService.testMethod();
	}
}


public class Run {

	public static void main(String[] args) {
		MyService service = new MyService();
		MyThread firstThread = new MyThread(service);
		firstThread.start();
		
		MyThread[] threadArray = new MyThread[4];
		for (int i = 0; i < 4; i++) {
			threadArray[i] = new MyThread(service);
			threadArray[i].start();
		}
	}
}

结果如图：
在这里插入图片描述

非公平信号量是线程启动的顺序和调用semaphore.acquire()的顺序无关，也就是线程先启动了并不代表获得许可
修改MyService中的代码如下：
private boolean isFair = true;

运行结果如图：
在这里插入图片描述

此现象说明即使是公平信号量，也不能保证线程启动顺序和semaphore.acquire()强一致性

在此，Semaphore常用的API已经基本学习完成了，后续将继续学习Exchanger的使用，加油！！！
升仔聊编程
关注
专栏目录
Semaphore---信号量常用方法总结（4）--Semapore类动态添加permits许可数量
weixin_42163781的博客
10-14 460
package com.example.demo.ThreadTest.Semaphore; import java.util.concurrent.Semaphore; /** * @author muyou * @date 2020/10/14 10:44 * Semapore类中的acquire(int permits)参数作用以及动态添加permits许可数量 */ public class SemaphoreTest3 { /** * 有参方法acquire(int
【SYS/BIOS】4.2节同步模块之事件模块
后悔是人生中最让人扫兴的一种东西
03-13 993
TI官网文档，TI-RTOS Kernel (SYS/BIOS) User’s Guide文档翻译，内容是第4章同步模块的第4.2节事件模块的内容。
Semaphore使用以及原理
NotRepent的博客
05-08 2093
1. Semaphore的使用 1) Semaphore，俗称信号量 基于AbstractQueuedSynchronizer实现！AQS 2) Semaphore管理着一组许可permit，许可的初始数量通过构造函数设定。 3) 默认使用非公平的方式 sync = new NonfairSync(permits); 使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数 4) 当线程要访问共享资源时，需要先通过acquire()方法获取许可。获取到之后许可
Semaphore 详解
qq_58148854的博客
12-19 861
可以把它简单的理解成我们停车场入口立着的那个显示屏，每有一辆车进入停车场显示屏就会显示剩余车位减1，每有一辆车从停车场出去，显示屏上显示的剩余车辆就会加1，当显示屏上的剩余车位为0时，停车场入口的栏杆就不会再打开，车辆就无法进入停车场了，直到有一辆车从停车场出去为止。每个停车场入口都有一个提示牌，上面显示着停车场的剩余车位还有多少，当剩余车位为0时，不允许车辆进入停车场，直到停车场里面有车离开停车场，这时提示牌上会显示新的剩余车位数。3、每有一辆车驶出停车场后，显示牌的剩余车位数响应的加1。
Semaphore的使用及其方法的使用
12-18
Semaphore的使用及其方法的使用。
python线程信号量semaphore使用解析
01-20
这篇文章主要介绍了python线程信号量semaphore使用解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.semaphore信号量原理 多线程同时运行，能提高程序的...
semaphore完整搭建ansible部署方案
04-26
Semaphore 是一个强大的自动化部署工具，它使用 Ansible 来实现对多主机的配置管理。Ansible 是一个流行的 IT 自动化框架，它允许管理员通过编写 YAML 格式的 Playbook 来执行任务，如软件部署、配置管理和应用生命...
semaphore使用
最新发布
06-29
Semaphore（信号量）是一种同步原语，主要用于并发编程中控制对共享资源的访问。它在多线程环境中作为一种同步机制，帮助管理有限的资源数量，防止多个线程同时访问或修改同一资源。 1. **基本概念**：Semaphore...
C# 信号量semaphore使用
zxcvb036的博客
07-21 294
using System; using System.Threading; namespace SemaphoreSample { class Program { private static Semaphore _pool; private static int _padding; static void Main(string[] args) { // 初始值 设为 0 /
理解Semaphore及其用法详解
热门推荐
flyingdon的专栏
12-31 7万+
Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个。一般的用法是用于串行化对critical section代码的访问，保证这段代码不会被并行的运行。Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。对于N=1的情况，称为binary semaphore。一般的用法是，用于限制对于某一资源的同时访问。Binary sem
利用Semaphore模拟多线程处理业务实现动态修改线程数
Java_XiaoBei的博客
10-17 307
JAVA多线程处理业务动态修改线程数量
Semaphore(信号量)的工作原理及实例
li-zhang-yu的博客
12-27 2320
一：工作原理 Semaphore是一种在多线程环境下使用的设施，该设施负责协调各个线程，以保证它们能够正确、合理的使用公共资源的设施，也是操作系统中用于控制进程同步互斥的量。Semaphore是一种计数信号量，用于管理一组资源，内部是基于AQS的共享模式。它相当于给线程规定一个量从而控制允许活动的线程数。 synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个...
Semaphore的简介及应用场景
android开发笔记
06-25 2144
Semaphore是一个计数信号量，常用于限制可以访问某些资源（物理或逻辑的）线程数目。 常用函数： 信号量的构造函数 非公平： public Semaphore(int permits);//permits就是允许同时运行的线程数目 公平（获得锁的顺序与线程启动顺序有关）： public Semaphore(int permits,boolean fair);//permits就是允许...
并发编程 Semaphore的使用和详解
qq_25330791的博客
11-21 852
并发编程 Semaphore的使用和详解 类Semaphore的基本使用 Semaphore的作用：限制线程并发的数量 课外话题【多线程的同步概念】：其实就是排着队去执行一个任务，执行任务是一个一个的执行，这样的优点是有助于程序逻辑的正确性，不会出现非线程安全问题，保证人系统功能的运行稳定。 Semaphore类结构图： 1、类Semaphore的构造函数permits 是许可的意思，代表同一时间，最多允许permits执行acquire() 和release() 之间的代码。 例如：
Semaphore，动态增减信号量
一元钱计划
05-27 1287
【信号量】： 用于控制对某资源访问的同一时间的并发量。   【如何获取】： semaphore.tryAcquire()，尝试获取，不阻塞 semaphore.acquire()，没信号量可用时，将进行阻塞等   【如何释放】： semaphore.release(); 线程抛出各种异常，都别忘了在finally中释放信号量； 如果释放的比获取的信号量还多，例如获取...
Semaphore---信号量常用方法总结（1）--Semapore类常用方法--acquire()和acquire(int permits)
weixin_42163781的博客
10-14 2124
Semaphore此类的主要作用是限制线程的并发数量 Semaphore类发放许可的计算方式是“减法”操作 acquire(int permits)作用是每调用一次就使用permits个许可 acquire()作用是每调用一次就使用1个许可 package com.example.demo.ThreadTest.Semaphore; import java.util.concurrent.*; /** *@Description TODO *@Author muyou *@DATE 2020/10
大白话说java并发工具类-Semaphore，Exchanger
weixin_34074740的博客
05-06 276
1. 控制资源并发访问--Semaphore Semaphore可以理解为信号量，用于控制资源能够被并发访问的线程数量，以保证多个线程能够合理的使用特定资源。Semaphore就相当于一个许可证，线程需要先通过acquire方法获取该许可证，该线程才能继续往下执行，否则只能在该方法出阻塞等待。当执行完业务功能后，需要通过release()方法将许可证归还，以便其他线程能够获得许可证继续执行。 S...
并发类Semaphore的使用及常用API
weixin_40472874的博客
07-10 388
1.Semaphore类介绍 Semaphore类是java\util\concurrent包下用于限制线程并发数量的操作类，如果不限制并发线程的数量，CPU资源将会很快耗尽，每个线程的执行时间将会非常缓慢，因为CPU要把时间片分给不同的线程对象，而且上下文切换也需要消耗时间，最终导致系统运行效率的低下，因此限制线程的并发数量非常有必要。 2.Semaphore类实现线程的同步 2.1 多线程中的同步概念：其实就是排着队执行一个任务，执行任务是一个一个执行，并不能并行执行，这样的优点有助于业务逻辑的正确性，
多线程之Semaphore线程调度
weixin_46114677的博客
10-11 66
在大多数情况下服务器的提供的资源不是无限的.所以当并发访问线程最大时就需要针对所有的可用资源进行线程调度,这点类似于现实生活中的银行业务办理.业务窗口往往只有几个.但是办理业务的人很多.那么这些人将会通过一次叫号的功能获取业务办理资格.这样就可以实现有限资源的分配和调度.在JUC中Semaphore类就可以实现类似调度处理. public class SemaphoreDemo { public static void main(String[] args) { Semaphore
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

升仔聊编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值