Java并发-类库新组件 - Semaphore 理解：计数信号量

最新推荐文章于 2024-05-30 01:13:43 发布
最新推荐文章于 2024-05-30 01:13:43 发布
阅读量512 收藏
点赞数
分类专栏： Java 文章标签： 并发 java semaphore
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happylaoxu/article/details/50754588
版权

Pool.java 类

package com.xyw.concurrent.blog;

import java.util.*;
import java.util.concurrent.*;


/*
 * 对象池概念.管理和回收对象，可以签出和签入对象的概念
 */
public class Pool<T> {
	private int size;
	private List<T> items = new ArrayList<T>();
	private volatile boolean[] checkedOut;
	private Semaphore available; // 计数信号量 允许n个任务同时访问这个资源
	public Pool(Class<T> classObject, int size){
		this.size = size;
		checkedOut = new boolean[size]; // 用来表示某个任务是否被签出的情况
		available = new Semaphore(size, true);
		for(int i = 0; i < size; ++i){
			try{
				items.add(classObject.newInstance()); // 现在向其中添加对象
			}catch(Exception e){
				throw new RuntimeException(e);
			}
		}
	}
	public T checkOut() throws InterruptedException{
		available.acquire();
		return getItem(); // 对象签出对象池，这个是重新获得一个可用的对象从对象池中获得
	}
	
	public void checkIn(T x){
		if(releaseItem(x)){
			available.release(); // 对象签入对象池，用于回收对象池
			// 而 semaphore 的真正起到的作用 ，只是 利用并发，进行技术信号量
		}
	}
	private synchronized T getItem(){
		for(int i =0; i< size; ++i){
			if(!checkedOut[i]){
				checkedOut[i] = true;
				return items.get(i); 
			}
		}
		return null;
	}
	private synchronized boolean releaseItem(T item){
		int index = items.indexOf(item);
		if (index == -1) return false;
		if (checkedOut[index]){
			checkedOut[index] = false;
			return true;
		}
		return false; // 这个表示，没有被签出的情况
	} 
}

Fat.java 类 

package com.xyw.concurrent.blog;

public class Fat {
	private volatile double  d;
	private static int counter = 0;
	private final int id = counter++;
	public Fat(){
		for(int i = 1; i < 10000; i++){
			d  += (Math.PI + Math.E) / (double) i;
		}
	}
	public void operation(){
		System.out.println(this);
	}
	public String toString(){
		return "Fat id:" + id;
	}
} // 这是个创建代价高昂的对象类型，其构造器运行起来很是费事

SemaphoreDemo.java 

package com.xyw.concurrent.blog;

import java.util.*;
import java.util.concurrent.*;

class CheckoutTask<T> implements Runnable{
	private static int counter = 0;
	private final int id = counter++;
	private Pool<T> pool;
	public CheckoutTask(Pool<T> pool){
		this.pool = pool; // 创建的对象池，用于回收线程和产生线程
	}
	public void run(){
		try{
			T item = pool.checkOut(); // 签出一个线程
			System.out.println(this +"checked out" + item); // 产生出一个线程
			TimeUnit.SECONDS.sleep(1); // 产生一个对象，并运行一段时间
			System.out.println(this + "checking in " + item);
			pool.checkIn(item); // 回收对象，到对象池里面
		}catch(InterruptedException e){
			
		}
	}
	public String toString(){
		return "CheckedOutTask" + id + " ";
	}
	
}

public class SemaphoreDemo {
	final static int SIZE = 25;
	public static void main(String[] args) throws Exception{
		final Pool<Fat> pool = new Pool<Fat>(Fat.class,SIZE); // 创建对象池对象
		ExecutorService exec = Executors.newCachedThreadPool();
		for(int i = 0; i < SIZE; i++){
			exec.execute(new CheckoutTask<Fat>(pool));
		}
		System.out.println("All CheckoutTasks created");
		List<Fat> list = new ArrayList<Fat>();
		for(int i = 0; i< SIZE; i++){
			Fat f = pool.checkOut();
			System.out.println(i + " main() thread checked out");
			f.operation();
			list.add(f);
		}
		Future<?> blocked = exec.submit(new Runnable(){
			public void run(){
				try{
					pool.checkOut();
				}catch(InterruptedException e){
					System.out.println("checkOut() Interrupted"); 
				}
			}
		}); // 一旦池中对象都被签出，Semaphore 将不再允许执行任何签出操作 block 的方法被Pool忽略。
		TimeUnit.SECONDS.sleep(2);
		blocked.cancel(true);
		System.out.println("checking in objects in" + list);
		for(Fat f : list)
			pool.checkIn(f);
		for(Fat f: list)
			pool.checkIn(f);
		exec.shutdown();
	}
}

运行结果：

CheckedOutTask0 checked outFat id:0

CheckedOutTask2 checked outFat id:2

CheckedOutTask1 checked outFat id:1

CheckedOutTask3 checked outFat id:3

CheckedOutTask4 checked outFat id:4

CheckedOutTask5 checked outFat id:5

CheckedOutTask6 checked outFat id:6

CheckedOutTask7 checked outFat id:7

CheckedOutTask8 checked outFat id:8

CheckedOutTask9 checked outFat id:9

CheckedOutTask10 checked outFat id:10

CheckedOutTask11 checked outFat id:11

CheckedOutTask12 checked outFat id:12

CheckedOutTask13 checked outFat id:13

CheckedOutTask14 checked outFat id:14

CheckedOutTask15 checked outFat id:15

CheckedOutTask16 checked outFat id:16

CheckedOutTask17 checked outFat id:17

CheckedOutTask18 checked outFat id:18

CheckedOutTask19 checked outFat id:19

CheckedOutTask20 checked outFat id:20

CheckedOutTask21 checked outFat id:21

CheckedOutTask22 checked outFat id:22

All CheckoutTasks created

CheckedOutTask23 checked outFat id:23

0 main() thread checked out

Fat id:24

CheckedOutTask2 checking in Fat id:2

CheckedOutTask5 checking in Fat id:5

CheckedOutTask24 checked outFat id:2

CheckedOutTask4 checking in Fat id:4

CheckedOutTask7 checking in Fat id:7

CheckedOutTask3 checking in Fat id:3

CheckedOutTask1 checking in Fat id:1

CheckedOutTask0 checking in Fat id:0

CheckedOutTask9 checking in Fat id:9

CheckedOutTask8 checking in Fat id:8

1 main() thread checked out

Fat id:5

CheckedOutTask11 checking in Fat id:11

CheckedOutTask6 checking in Fat id:6

2 main() thread checked out

Fat id:0

CheckedOutTask10 checking in Fat id:10

3 main() thread checked out

CheckedOutTask13 checking in Fat id:13

CheckedOutTask12 checking in Fat id:12

CheckedOutTask14 checking in Fat id:14

Fat id:1

4 main() thread checked out

Fat id:3

5 main() thread checked out

Fat id:4

6 main() thread checked out

Fat id:6

7 main() thread checked out

Fat id:7

8 main() thread checked out

Fat id:8

CheckedOutTask15 checking in Fat id:15

CheckedOutTask16 checking in Fat id:16

CheckedOutTask21 checking in Fat id:21

CheckedOutTask20 checking in Fat id:20

CheckedOutTask19 checking in Fat id:19

CheckedOutTask22 checking in Fat id:22

CheckedOutTask18 checking in Fat id:18

CheckedOutTask17 checking in Fat id:17

9 main() thread checked out

CheckedOutTask23 checking in Fat id:23

Fat id:9

10 main() thread checked out

Fat id:10

11 main() thread checked out

Fat id:11

12 main() thread checked out

Fat id:12

13 main() thread checked out

Fat id:13

14 main() thread checked out

Fat id:14

15 main() thread checked out

Fat id:15

16 main() thread checked out

Fat id:16

17 main() thread checked out

Fat id:17

18 main() thread checked out

Fat id:18

19 main() thread checked out

Fat id:19

20 main() thread checked out

Fat id:20

21 main() thread checked out

Fat id:21

22 main() thread checked out

Fat id:22

23 main() thread checked out

Fat id:23

CheckedOutTask24 checking in Fat id:2

24 main() thread checked out

Fat id:2

checkOut() Interrupted

checking in objects in[Fat id:24, Fat id:5, Fat id:0, Fat id:1, Fat id:3, Fat id:4, Fat id:6, Fat id:7, Fat id:8, Fat id:9, Fat id:10, Fat id:11, Fat id:12, Fat id:13, Fat id:14, Fat id:15, Fat id:16, Fat id:17, Fat id:18, Fat id:19, Fat id:20, Fat id:21, Fat id:22, Fat id:23, Fat id:2]



奔跑的Q
关注
专栏目录
Java并发编程（24）—— JUC并发编程类库详解
shangjg3的博客
09-03 203
CyclicBarrier 是一个同步辅助类，用于让一组线程到达一个屏障（barrier）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。这意味着在修改操作发生时，会创建一个新的数组，并将现有的所有元素复制到新数组中，然后在新数组上进行修改。这意味着在修改操作发生时，会创建一个新的数组，然后将现有的所有元素复制到新数组中，并在新数组上进行修改。当一个线程到达交换点时，它会调用 exchange() 方法，该方法会尝试将该线程的数据与另一个线程的数据交换。
2023Java 并发编程面试题
喜欢猪猪
03-10 526
BlockingQueue 接口是 Queue 的子接口，它的主要用途并不是作为容器，而是作为线程同步的的工具，因此他具有一个很明显的特性，当生产者线程试图向 BlockingQueue 放入元素时，如果队列已满，则线程被阻塞，当消费者线程试图从中取出一个元素时，如果队列为空，则该线程会被阻塞，正是因为它所具有这个特性，所以在程序中多个线程交替向BlockingQueue 中放入元素，取出元素，它可以很好的控制线程之间的通信。因此，当所有的非后台线程结束时，程序也就终止了，同时会杀死进程中的所有后台线程。
AQS组件之Semaphore
striveb的博客
02-05 207
在前两篇说了AQS和CountDownLatch，现在我们来看看Semaphore。 synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。 ​ 用于保证同一时间并发访问线程的数目。信号量在操作系统中是很重要的概念，Java并发库里的Semaphore就可以很轻松的完成类似操作系统信号量的控制...
AQS同步组件-Semaphore（信号量）解析和案例
write less , do more
12-11 1万+
基本概念 Semaphore也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制并发访问资源的线程个数。 例如排队买票的情况，如果只有三个窗口，那么同一时间最多也只能有三个人买票。第四个人来了之后就必须在后面等着，只有其他人买好了，才可以去相应的窗口进行买票 。 作用和使用场景 用于保证同一时间并发访问线程的数目。 信号量在操作系统中是很重要的概念，Java并发库里的Semaphore就可以很轻松的完成类似操作系统信号量的控制。Semaphore可以
java中锁 - 总结
Longtermevolution的博客
10-23 161
参考文章：java中的锁 目录 公平锁 / 非公平锁 可重入锁 / 不可重入锁 独享锁 / 共享锁 互斥锁 / 读写锁 乐观锁 / 悲观锁 分段锁 偏向锁 / 轻量级锁 / 重量级锁 自旋锁 公平锁 / 非公平锁 公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁。 非公平锁 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。 对于Java ReentrantLock而言，通过构造函数指定该锁是
java之并发工具类信号量（Semaphore）
感冒石头的博客
12-21 266
java并发工具类 1、CountDownLatch ：能够使一个或多个线程等待其他线程完成各自的工作后再执行2、CyclicBarrier ： 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。3、Semaphore ： 用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理地使用公共资源4、Exchange...
Java 信号量 Semaphore
爱科学，爱生活
06-08 225
final Semaphore semp = new Semaphore(5); // 获取许可 semp.acquire(); // 访问完后，释放 semp.release();
Java后端技术面试汇总-2019
01-23
- **Semaphore原理**：信号量用于控制对共享资源的访问数量。 - **Exchanger原理**：使两个线程交换数据。 - **ThreadLocal原理分析**：通过ThreadLocalMap实现线程局部变量的隔离。 - **线程池的实现原理**：...
Java 并发编程面试一
最新发布
孤云博客
05-30 695
在 Java 中可以有很多方法来保证线程安全——同步，使用原子类(atomic concurrent classes)，实现并发锁，使用 volatile 关键字，使用不变类和线程安全类。ServerSocket.accept()方法，或者调用了 DatagramSocket.receive()方法时，都。步技术来做到这一点。(tryLock 方法)、定时的(tryLock 带参方法)、可中断的(lockInterruptibly)、可多。程 one 的 CAS 操作成功，但可能存在潜藏的问题。
[Java并发包学习六]Semaphore介绍
hechurui的专栏
10-30 2682
概述 emaphore字面意思是信号量。他主要用于控制有限的资源的访问数量。我们看一个生活中常常出现的场景： 一个厕所只有3个坑位，但是有10个人来上厕所，那怎么办？假设10的人的编号分别为1-10，并且1号先到厕所，10号最后到厕所。那么1-3号来的时候必然有可用坑位，顺利如厕，4号来的时候需要看看前面3人是否有人出来了，如果有人出来，进去，否则等待。同样的道理，4-10号也需要
双击jar运行main主函数实现-fatJAR
weixin_33979745的博客
10-28 157
本人接到公司任务，开发一个小工具，双击之后，生成制定模版的word，word中是一个table，表格内容需要填写为各个文件的路径以及文件行数,代码见附件java,rar。下面主要说说如何进行导出可双击的jar执行文件。1、下载，net.sf.fjep.fatjar_0.0.31.jar 包，拷贝到eclipse安装目录/plugins下，重启eclipse，2、选中要打包的工...
20、Semaphore信号量
weixin_34203832的博客
10-03 62
2019独角兽企业重金招聘Python工程师标准>>> ...
Java多线程-新特征-信号量Semaphore
weixin_34362991的博客
07-25 347
简介信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。 概念Semaphore分为单值和多值两种，前者只能被一个线程获得，后者可以被若干个线程获得。 以一个停车场运作为例。为了简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆不受阻碍的进入，然后放下车...
我靠！Semaphore里面居然有这么一个大坑！
qq_27243343的博客
08-02 1020
这是why的第 59 篇原创文章 荒腔走板 大家好，我是why哥 ，欢迎来到我连续周更优质原创文章的第 59 篇。 上周写了一篇文章，一不小心戳到了大家的爽点，其中一个转载我文章的大号，阅读量居然突破了 10w+，我也是受宠若惊。 但是其实我是一个技术博主来的，偶尔写点生活相关的。所以这篇还是回到技术上。 但是我的技术文章有个特点是第一张图片都是我自己拍的。然后我会围绕这个图片进行一个简短的描述，我称之为荒腔走板环节。 目的是给冰冷的技术文注入一丝色彩。 我这样做已经坚持了很多篇 ，有的读者给我说：看完荒
eclipse 之中出现了 Resource leak: 'in' is never closed
热门推荐
奔跑的Q
05-10 1万+
这是输入流出现的问题。解决方法是，如 Scanner  in  =  new Scanner(System.in); 使用 在使用的后面 加上 in.close(); 但事实上这会关闭，整个类的输入流；  建议，在一开始就在类中声明： private Scanner scan = new Scanner(System.in); 使用这样的变量在以后的过程中并不会，抛出异常；
Java 并发 使用 ScheduledThreadPoolExecutor进行温室参数变化仿真
奔跑的Q
02-26 1347
package com.xyw.concurrent.blog; import java.util.concurrent.*; import java.util.*; /* * 通过模拟温室之中的温度变化的情况，进行仿真的操作，体现出Java 并发的知识 */ public class GreenhouseScheduler { private volatile boolean ligh
java 学习实例，实现空对象，和重写了，Comparator 的类实现了对于容器的比较！
奔跑的Q
05-11 909
少说废话，上代码：这是我学习的代码，如果有用，希望能帮助到大家！争取每个例子都是涉及的到新的技术，新的知识点！ 喜欢就关注我的博客：http://blog.csdn.net/happylaoxu 少说废话，上代码： package com.xuyaowen.student; import java.util.*; //利用空对象的方式实现RTTI 的形式； interface Nul
Java 利接口来实现多态的情况， 和利用接口实现多重继承！
奔跑的Q
04-28 845
其中是利用， 正方形， 长方形， 圆形；来继承接口All 接口， 来实现All的情况。 少说废话，上代码： import java.util.*; interface S { void s(); } interface C { void c(); } interface All extends S,C { //这是实现接口的多重的继承 } class Square imple
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值