使用信号量(Semaphore)实现生产者与消费者模型

最新推荐文章于 2021-03-18 14:54:08 发布
最新推荐文章于 2021-03-18 14:54:08 发布
阅读量1.9k 收藏 9
点赞数 1
分类专栏： Java中的并发与多线程 文章标签： Semaphore 多线程 生产者与消费者 线程状态 LockSupport
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/limenghua9112/article/details/108150224
版权

什么是生产者与消费者模型？

生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。

打个比方

好比去肯德基吃汉堡，货架上有做好的汉堡。
消费者花钱来消费汉堡，而肯德基的厨师则不停地做汉堡放在货架上。
当货架满了，却没有消费者再来买汉堡时，厨师就不做了，生产者阻塞。
当餐点来了，消费者买的太快，厨师做不过来了，货架一直空着。
则消费者排队等着，消费者阻塞。
在这里插入图片描述

图：生产者-消费者模型

为何需要生产者-消费者模型？

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

源码实现

假设货架上最多可以放10个汉堡，那么如果生产者已经生产了10个汉堡，却没有消费者来消费，则生产者等待。
如果消费者过多，货架上一个汉堡都没有了，则消费者等待。
消费者等待过程中，如果生产者又生产了汉堡放在货架上，则消费者马上消费掉这个汉堡。

需要一个生产者类:class Producer，用来往货架上放汉堡。
一个消费者类：class Consumer，用来购买（消费）货架上的汉堡。
一个肯德基货架类：class KfcShelf，包含一个put(int hamburgerId)方法，一个take()方法。 还有一个main方法作为程序入口。
一个汉堡实体类，包含：汉堡条码（id）字段和汉堡名称字段。
同时，为了控制货架上最多只能放10个汉堡，我们采用了许可证数量为10的信号量。 使用LinkedList作为汉堡的容器，当往货架放汉堡时，生产者用掉一个许可证，同时给消费者发放一个许可证。
当从货架取走汉堡时，消费者用掉一个许可证，同时给生产者发放一个许可证，相当于告诉厨师：货架上空出了一个位置，赶紧补货吧。

完整源码如下：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.stream.Collectors;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * <pre>
 * 程序目的：使用Semapore实现生产者消费者模型
 * 肯德基货架的例子
 * 假设货架上最多可以放10个汉堡，那么如果生产者已经生产了10个汉堡，却没有消费者来消费，则生产者等待。
 * 如果消费者过多，货架上一个汉堡都没有了，则消费者等待。
 * 消费者等待过程中，如果生产者又生产了汉堡放在货架上，则消费者马上消费掉这个汉堡。
 * </pre>
 * created at 2020/8/18 09:35
 * @author lerry
 */
@Slf4j
public class KfcShelf {
	/**
	 * 消费者许可
	 */
	Semaphore consumerPermitCount = new Semaphore(0);

	/**
	 * 生产者最多可以获取10个许可
	 */
	Semaphore producerPermitCount = new Semaphore(10);

	/**
	 * 许可证数量为1、相当于普通的锁
	 */
	Semaphore isUse = new Semaphore(1);

	/**
	 * 充当货架角色。注意：LinkedList是线程不安全的
	 */
	LinkedList<Integer> shelfList = new LinkedList<>();

	public static void main(String[] args) {
		KfcShelf kfcShelf = new KfcShelf();
		// 生产者生产11个汉堡，前10个汉堡可以放在货架上，第11个生产者需要等待
		List<Thread> producerThreadList = new ArrayList<>();
		for (int i = 0; i < 11; i++) {
			Thread producer = new Thread(new Producer(kfcShelf));
			producer.start();
			producerThreadList.add(producer);
		}

		try {
			Thread.sleep(1_000);
			// 等待消费者前来消费
			log.info("生产10个汉堡，第11个生产者WAITING。等待消费者前来消费");
			log.info("生产者线程状态打印：\n{}", producerThreadList.stream().map(thread -> String.format("%s:%s\n", thread.getName(), thread.getState())).collect(Collectors.joining()));
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}

		List<Thread> consumerThreadList = new ArrayList<>();
		// 消费者消费掉12个汉堡，第12个等待
		for (int i = 0; i < 12; i++) {
			Thread consumer = new Thread(new Consumer(kfcShelf));
			consumer.start();
			consumerThreadList.add(consumer);
		}

		try {
			Thread.sleep(1_000);
			// 等待消费者前来消费
			log.info("消费者购买汉堡");
			log.info("消费者线程状态打印：\n{}", consumerThreadList.stream().map(thread -> String.format("%s:%s\n", thread.getName(), thread.getState())).collect(Collectors.joining()));
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}


		try {
			Thread.sleep(1_000);
			// 等待生产者生产
			log.info("等待生产者生产第12个汉堡");
			log.info("======================");
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
		// 生产者再生产一个汉堡，则消费者马上会消费掉
		Thread producer12 = new Thread(new Producer(kfcShelf));
		producer12.start();
	}

	/**
	 * 往货架上放汉堡
	 * @param hamburgerId
	 */
	public void put(int hamburgerId) {
		try {
			// 生产者获取一个许可证
			producerPermitCount.acquire();
			isUse.acquire();
			shelfList.add(hamburgerId);
			log.info("生产:[汉堡-{}] 货架上的汉堡数量:[{}]", hamburgerId, shelfList.size());
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
		finally {
			isUse.release();
			consumerPermitCount.release();
		}
		try {
			Thread.sleep(1000);
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}

	}// end method

	/**
	 * 从货架上取一个汉堡
	 * @return
	 */
	public Integer take() {
		Integer hamburgerId = 0;
		try {
			consumerPermitCount.acquire();
			isUse.acquire();
			hamburgerId = shelfList.remove(0);
			log.info("消费:[汉堡-{}] 货架上的汉堡数量:[{}]", hamburgerId, shelfList.size());
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
		finally {
			isUse.release();
			producerPermitCount.release();
		} return hamburgerId;
	}// end method
}// end class 

class Producer implements Runnable {
	private KfcShelf kfcShelf;

	public Producer(KfcShelf KfcShelf) {
		this.kfcShelf = KfcShelf;
	}

	@Override
	public void run() {
		// 生成6位长度的随机数，当做条码编号
		int barCodeId = new Random().nextInt(100_000) + 100_000;
		kfcShelf.put(barCodeId);
	}
}// end class

class Consumer implements Runnable {
	private KfcShelf kfcShelf;

	public Consumer(KfcShelf KfcShelf) {
		this.kfcShelf = KfcShelf;
	}

	@Override
	public void run() {
		kfcShelf.take();
	}
}

/**
 * 汉堡实体
 */
@Data
class Hamburger {
	private Integer id;

	private Integer name;
}
输出结果
2020-08-21 16:21:39.577 [Thread-2] INFO  KfcShelf.java:109 - 生产:[汉堡-196280] 货架上的汉堡数量:[1]
2020-08-21 16:21:39.582 [Thread-3] INFO  KfcShelf.java:109 - 生产:[汉堡-186974] 货架上的汉堡数量:[2]
2020-08-21 16:21:39.582 [Thread-4] INFO  KfcShelf.java:109 - 生产:[汉堡-143871] 货架上的汉堡数量:[3]
2020-08-21 16:21:39.583 [Thread-0] INFO  KfcShelf.java:109 - 生产:[汉堡-157386] 货架上的汉堡数量:[4]
2020-08-21 16:21:39.583 [Thread-6] INFO  KfcShelf.java:109 - 生产:[汉堡-123033] 货架上的汉堡数量:[5]
2020-08-21 16:21:39.583 [Thread-5] INFO  KfcShelf.java:109 - 生产:[汉堡-151965] 货架上的汉堡数量:[6]
2020-08-21 16:21:39.583 [Thread-1] INFO  KfcShelf.java:109 - 生产:[汉堡-146100] 货架上的汉堡数量:[7]
2020-08-21 16:21:39.583 [Thread-7] INFO  KfcShelf.java:109 - 生产:[汉堡-108609] 货架上的汉堡数量:[8]
2020-08-21 16:21:39.584 [Thread-8] INFO  KfcShelf.java:109 - 生产:[汉堡-172889] 货架上的汉堡数量:[9]
2020-08-21 16:21:39.584 [Thread-9] INFO  KfcShelf.java:109 - 生产:[汉堡-157386] 货架上的汉堡数量:[10]
2020-08-21 16:21:40.581 [main    ] INFO  KfcShelf.java:59 - 生产10个汉堡，第11个生产者WAITING。等待消费者前来消费
2020-08-21 16:21:40.644 [main    ] INFO  KfcShelf.java:60 - 生产者线程状态打印：
Thread-0:TERMINATED
Thread-1:TERMINATED
Thread-2:TERMINATED
Thread-3:TERMINATED
Thread-4:TERMINATED
Thread-5:TERMINATED
Thread-6:TERMINATED
Thread-7:TERMINATED
Thread-8:TERMINATED
Thread-9:TERMINATED
Thread-10:WAITING

2020-08-21 16:21:40.647 [Thread-11] INFO  KfcShelf.java:137 - 消费:[汉堡-196280] 货架上的汉堡数量:[9]
2020-08-21 16:21:40.648 [Thread-16] INFO  KfcShelf.java:137 - 消费:[汉堡-186974] 货架上的汉堡数量:[8]
2020-08-21 16:21:40.648 [Thread-12] INFO  KfcShelf.java:137 - 消费:[汉堡-143871] 货架上的汉堡数量:[7]
2020-08-21 16:21:40.648 [Thread-13] INFO  KfcShelf.java:137 - 消费:[汉堡-157386] 货架上的汉堡数量:[6]
2020-08-21 16:21:40.648 [Thread-14] INFO  KfcShelf.java:137 - 消费:[汉堡-123033] 货架上的汉堡数量:[5]
2020-08-21 16:21:40.649 [Thread-15] INFO  KfcShelf.java:137 - 消费:[汉堡-151965] 货架上的汉堡数量:[4]
2020-08-21 16:21:40.649 [Thread-10] INFO  KfcShelf.java:109 - 生产:[汉堡-147206] 货架上的汉堡数量:[5]
2020-08-21 16:21:40.649 [Thread-17] INFO  KfcShelf.java:137 - 消费:[汉堡-146100] 货架上的汉堡数量:[4]
2020-08-21 16:21:40.649 [Thread-18] INFO  KfcShelf.java:137 - 消费:[汉堡-108609] 货架上的汉堡数量:[3]
2020-08-21 16:21:40.649 [Thread-19] INFO  KfcShelf.java:137 - 消费:[汉堡-172889] 货架上的汉堡数量:[2]
2020-08-21 16:21:40.650 [Thread-20] INFO  KfcShelf.java:137 - 消费:[汉堡-157386] 货架上的汉堡数量:[1]
2020-08-21 16:21:40.650 [Thread-21] INFO  KfcShelf.java:137 - 消费:[汉堡-147206] 货架上的汉堡数量:[0]
2020-08-21 16:21:41.652 [main    ] INFO  KfcShelf.java:77 - 消费者购买汉堡
2020-08-21 16:21:41.655 [main    ] INFO  KfcShelf.java:78 - 消费者线程状态打印：
Thread-11:TERMINATED
Thread-12:TERMINATED
Thread-13:TERMINATED
Thread-14:TERMINATED
Thread-15:TERMINATED
Thread-16:TERMINATED
Thread-17:TERMINATED
Thread-18:TERMINATED
Thread-19:TERMINATED
Thread-20:TERMINATED
Thread-21:TERMINATED
Thread-22:WAITING

2020-08-21 16:21:42.659 [main    ] INFO  KfcShelf.java:88 - 等待生产者生产第12个汉堡
2020-08-21 16:21:42.659 [main    ] INFO  KfcShelf.java:89 - ======================
2020-08-21 16:21:42.660 [Thread-23] INFO  KfcShelf.java:109 - 生产:[汉堡-100422] 货架上的汉堡数量:[1]
2020-08-21 16:21:42.660 [Thread-22] INFO  KfcShelf.java:137 - 消费:[汉堡-100422] 货架上的汉堡数量:[0]
结果分析

刚开始，货架为空。 这时，创建了11个生产者线程，往货架上放汉堡。

for (int i = 0; i < 11; i++) {
	Thread producer = new Thread(new Producer(kfcShelf));
	producer.start();
	producerThreadList.add(producer);
}

可是，生产者的许可证数量为10，第11个生产者获取不到许可证，怎么办？ 线程等待。

Thread-10:WAITING

生产者的线程状态都打印出来后，可以看到，第11个生产者线程状态为WAITING。
查看AQS源码，可以发现，当线程获取不到许可证时，会：

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

调用LockSupport.park方法。然后线程进入WAITING状态。

然后，来了12个消费者：

for (int i = 0; i < 12; i++) {
	Thread consumer = new Thread(new Consumer(kfcShelf));
	consumer.start();
	consumerThreadList.add(consumer);
}

货架上的10个汉堡，被取了之后，等待中的那个生产者线程会被激活：

2020-08-21 16:21:40.649 [Thread-10] INFO  KfcShelf.java:109 - 生产:[汉堡-147206] 货架上的汉堡数量:[5]

它生产了编号为147206的汉堡。随后，被消费者线程Thread-21消费掉。

2020-08-21 16:21:40.650 [Thread-21] INFO  KfcShelf.java:137 - 消费:[汉堡-147206] 货架上的汉堡数量:[0]

这时，生产的11个汉堡，都被消费掉了。第12个消费者没有汉堡买了，怎么办呢？ 等待。

Thread-22:WAITING

然后，我们启动第12个生产者线程：

// 生产者再生产一个汉堡，则消费者马上会消费掉
Thread producer12 = new Thread(new Producer(kfcShelf));
producer12.start();

看日志可以发现，生产出来的编号100422的汉堡，马上被第12个消费者消费掉了。

2020-08-21 16:21:42.660 [Thread-23] INFO  KfcShelf.java:109 - 生产:[汉堡-100422] 货架上的汉堡数量:[1]
2020-08-21 16:21:42.660 [Thread-22] INFO  KfcShelf.java:137 - 消费:[汉堡-100422] 货架上的汉堡数量:[0]

参考资料

生产者与消费者模型
Java实现生产者和消费者的5种方式
经典并发同步模式：生产者-消费者设计模式 - 知乎

环境说明

  • java -version
java version "1.8.0_251"
Java(TM) SE Runtime Environment (build 1.8.0_251-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.251-b08, mixed mode)
  • OS：macOS High Sierra 10.13.4
  • 日志：logback
快乐柠檬
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【操作系统】Semaphore处理生产者-消费者问题
星拱北辰的博客
01-29 716
Semaphore处理生产者-消费者问题
Semaphore 的介绍与实现生产者消费者模式案例
Esy_Hong
12-26 249
一、介绍     Semaphore是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore，将其作为一种类似互斥锁的机制，这也叫二元信号量，表示两种互斥状态。它的用法如下：   public...
Semaphore---信号量常用方法总结（3）--Semapore类实现生产者和消费者
weixin_42163781的博客
10-14 213
Semaphore目的是为了限制同一时间线程并发数 生产者和消费者调用类： package com.example.demo.ThreadTest.Semaphore.productAndConsumer; import java.util.LinkedList; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.T
Qt中使用QSemaphore，单生产者—多消费者模型
03-15
Qt中QSemaphore信号量与QMutexLocker、QMutex的使用，单生产者-多消费者模型；界面可设置消费者线程数量；
Linux IPC 信号量：PV原语，PV操作，函数semget，函数semop、函数semctl、生产者和消费者模型
CLZHIT的博客
03-15 1427
Linux IPC 信号量什么是信号量信号量的分类原语信号量PV操作的原语描述P原语（申请资源）操作V原语（释放资源）操作PV原语的执行顺序PV原语如何实现互斥访问System V IPC：信号量函数 semget()函数semop()函数semctl()生产者和消费者模型 什么是信号量 信号量是一种用于提供不同进程间或一个给定进程的不同线程间同步手段的原语。信号量是进程/线程同步的一种方式。 有...
Java 信号量 (Semaphore) 实现生产者与消费者模型
aiyijava的博客
03-18 958
import java.util.concurrent.Semaphore; /** * 使用semaphore信号量实现生产者消费者问题。 * 生产者消费者问题的本质，其实就是同步和互斥的问题。 * 同步问题，其实就是一前一后的问题，某个进程或者程序，必须在另一个的前面或者后面执行，他俩不能同时执行，就是这个意思。 * 互斥问题，即某个资源不能同时被两个进程占用 */ public class Test { //比如这是苹果的数量。 private static Integer.
Semaphore实现生产者与消费者问题
生命中有太多不确定
10-28 553
Semaphore实现生产者与消费者问题，通俗易懂 一、分析 生产者与消费者中需要关注的核心问题有两个： 生产者不能同时放 消费者不能同时消费 对象抽象 消费者、生产者、仓库 二、源码： 仓库 import java.util.ArrayList; import java.util.List; import java.util.concurrent.Semaphore; /** * @author VernHe */ public class Buffer { //同时进入核心
java 使用信号量Semaphore实现生产者-消费者模式
whueratsjtuer的博客
04-03 3047
这是继许上一篇java 使用synchronized, wait(), notifyAll() 实现生产者-消费者模式。 信号量Semaphore，跟交通信号等非常类似（Semaphore翻译过来就是信号灯的意思），以下面这幅图为例 如果两条铁轨都是空的，那么此时信号灯是绿色（信号量为2），允许火车通行。如果有列车请求通行则放行，同时信号灯变为黄色（信号量减一）： 当两条铁轨都有列车...
python实现生产者消费者并发模型
11-22
多线程实现生产者消费者模型：锁（Lock）、信号量（Semaphore、BoundedSemaphore）、条件（Condition）、队列（Queue）、事件（Event） 多进程程实现生产者消费者模型：信号量（Semaphore）、条件（Condition）、...
Python semaphore evevt生产者消费者模型原理解析
12-20
线程锁相当于同时只能有一个线程申请锁，有的场景无数据修改互斥要求可以同时让多个线程同时运行，且需要限制并发线程数量时可以使用信号量 import threading, time, queue def test(name): semaphore.acquire() ...
【操作系统】实现生产者消费者模型
12-20
最近在复习操作系统，随手写两种Java实现生产者消费者模型的方式 一、信号量 import java.util.Queue; import java.util.Random; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent....
VC6实现的生产者－消费者模型
10-08
有两个版本，第一个用原子操作来解决(A版本)，第二个用信号量实现(B版本)，新建一个文件夹，直接双击打开cpp文件调用VC6 IDE，直接编译运行即可 主要用到了windows的信号量semaphore、interLock等工具
操作系统课内实习，模拟生产者、消费者模型
07-19
内容概要：基于QT Creator环境的多线程编程验证互斥的原理，通过使用semaphore，mutex等控制变量，实现对生产者消费者模型的真实模拟。 适合人群：初学操作系统的学生 能学到什么：调用了Qt多线程类库QThread进行...
LongAdder和AtomicLong哪个性能更好，为什么？
阿呆的专栏
08-12 2544
概述 AtomicLong是作者Doug Lea在jdk1.5版本发布于java.util.concurrent.atomic并发包下的类。 而LongAdder是道格·利（Doug Lea的中文名）在java8中发布的类。 有了AtomicLong为何还需要LongAdder？ 在这里，就不得不分析一下AtomicLong的缺点了。 先来看一下AtomicLong.incrementAndGet()方法的源码 /** * Atomically increments by one the current
我手写了AQS实现、画了3张流程图，就是为了让你彻底搞明白AQS原理
阿呆的专栏
07-02 1312
什么是AQS 字面上来看，AQS是jdk1.5加入的java.util.concurrent.locks.AbstractQueuedSynchronizer类，类名翻译成中文就是抽象的队列同步器。由大名鼎鼎的Doug Lea李大爷来操刀设计并开发实现。 它提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架，ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等并发类均是基于AQS来实现的，具体用法是通过继承AQS实现其模板方法，然后将子类作为
synchronized如何保证线程同步？
阿呆的专栏
07-16 1125
什么是synchronized？ synchronized是Java提供的一个并发控制的关键字。可以用来修饰方法和代码块。被synchronized修饰的代码块及方法，在同一时间，只能被单个线程访问。 synchronized有什么作用？ 使用该关键字修饰的方法，在同一时刻最多只有一个线程可以进入。如果第一个线程获取锁进入了synchronized修饰的区域，在其释放锁之前，需要进入该实例中synchronized修饰的方法或者代码块的其他线程就需要等待，直到第一个线程释放锁之后，其他线程中才会有一个线
详解Java线程状态及状态转换
阿呆的专栏
06-26 988
为何要了解Java线程状态 线程是 JVM 执行任务的最小单元，理解线程的状态转换是理解后续多线程问题的基础。 Java线程状态转换图 图：线程间的相互转换 Java线程有哪些状态？ 在 JVM 运行中，线程一共有 NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED 六种状态，这些状态对应 Thread.State 枚举类中的状态。 Thread.State枚举源码： 为方便阅读，在此去掉了文档注释 public enum State {
手把手教你使用ThreadLocal
阿呆的专栏
07-22 655
什么是ThreadLocal？ 首先我们来看javadoc： This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable.
C语言 实现信号量版本的生产者与消费者模型
最新发布
06-08
好的，下面是一个简单的C语言实现信号量版本的生产者与消费者模型的代码： ```c #include #include #include #include <semaphore.h> #define BUFFER_SIZE 5 // 缓冲区大小 #define PRODUCER_NUM 3 // 生产者...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值