6：生产者消费者问题
生产者与消费者问题
⽣产者与消费者问题⽣产者与消费者问题是Java多线程中⼀道⾮常经典的问题，问题如下： ⽣产者与消费者问题也称缓存问题，⽣产者与消费者即Java 中的线程，⽣产者与消费者问题即⽣产者⽣产⼀定数量的线程放⼊缓存区中，供消费者消费者消费，在消费和⽣产的过程中，如果⽣产者⽣产的产品超过了缓存区的上限则停⽌⽣产，等待消费者消费，如果缓存区的产品被消费完，消费者则停⽌消费，等待⽣产者⽣产 ⾸先，我们来看题⽬，从题⽬中我们⼀个可以抽取出⼏个实体类呢？答案是4个 Consumer（消费者），Producer（⽣产者），Product（产品），WareHouse（缓冲区，也叫仓库），于是项⽬结构如下，main 为测试类产品类package ProducersAndConsumers;//产品public class Product {//产品需要⼀个id 来表明产品的唯⼀性private Integer productId;//id直接由构造⽅法传⼊public Product(Integer productId) {this.productId = productId;}public Integer getProductId() {return productId;}@Overridepublic String toString() {return "Product{" +"productId=" + productId +'}';}}仓库package ProducersAndConsumers;import java.util.LinkedList;//仓库类public class WareHouse {//仓库容量，我们设置为10个private final int max = 10;//仓库基础的数量private final int base = 0;//我们设置⼀个集合来存放⽣产的产品，由于我们需要⼀个可以弹出最后⼀个产品的⽅法，所以我们在这⾥使⽤LinkedListprivate LinkedList<Product> products = new LinkedList<>();//⽣产⽅法public synchronized void push(Product product) {//判断是否有空间存放产品while(max==products.size()){try{System.out.println("仓库已满，消费者快来消费"+Thread.currentThread().getName()+"停⽌⽣产");//仓库满后停⽌当前线程this.wait();}catch (Exception ex){ex.printStackTrace();}}//⽣产商品products.addLast(product);System.out.println(Thread.currentThread().getName()+"⽣产了⼀个产品:"+product.getProductId()+"号");try{//等待1秒，⽅⾯我们观察Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}notifyAll();}//消费⽅法public synchronized void pop() {//判断是否有产品while (products.size()==base){try{System.out.println("仓库空了，⽣产者快点⽣产"+Thread.currentThread().getName()+"停⽌消费");//仓库空后停⽌当前线程this.wait();} catch (InterruptedException e) {e.printStackTrace();}}//消费商品System.out.println(Thread.currentThread().getName()+"消费了⼀个产品:"+products.getLast().getProductId()+"号"); products.removeLast();try{//等待1秒，⽅⾯我们观察Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}notifyAll();}}⽣产者package ProducersAndConsumers;//⽣产者public class Producer implements Runnable {//⽣产产品的idprivate int count = 0;//仓库private WareHouse wareHouse;//⽣产者和消费者都是⽤同⼀个仓库，所以我们只要声明⼀个仓库，在由构造⽅法传⼊即可public Producer(WareHouse wareHouse) {this.wareHouse = wareHouse;}//⽣产⽅法@Overridepublic void run() {while (true){Product product = new Product(count);wareHouse.push(product);// 产品id不可重复，所以我们使⽤⾃增策略count++;}}}消费者package ProducersAndConsumers;public class Consumer implements Runnable{//仓库private WareHouse wareHouse;//⽣产者和消费者都是⽤同⼀个仓库，所以我们只要声明⼀个仓库，在由构造⽅法传⼊即可public Consumer(WareHouse wareHouse) {this.wareHouse = wareHouse;}//消费⽅法@Overridepublic void run() {while (true){wareHouse.pop();}}}最后测试类package ProducersAndConsumers;//测试类public class Main {public static void main(String[] args) {WareHouse wareHouse = new WareHouse();Producer producer = new Producer(wareHouse);Consumer consumer = new Consumer(wareHouse); Thread producerT = new Thread(producer,"⽣产者"); Thread consumerT = new Thread(consumer,"消费者"); producerT.start();consumerT.start();}}。
关于生产者消费者问题
形象启发分层解剖——PV操作教学引导实践【摘要】PV操作及利用PV原语实现进程间的同步互斥是计算机操作系统中一个非常重要的学习内容。
本文详细介绍了形象启发，分层解剖的教学方法在教学中的应用，希望以此引出更优的教学方法。
【关键词】PV操作、形象启发、分层解剖、生产消费者问题、多媒体课件PV操作及同步互斥的实现是操作系统这门课中最抽象,也是学生难以理解的知识内容之一，其中生产消费者问题又是PV操作中最为经典的案例，学生要深刻理解这个知识点并不容易。
为了取得较好的教学效果，帮助学生深刻理解这个知识点，本人制作了多媒体课件《PV操作及实现同步互斥》，把抽象的内容具体化，由浅到深，化解难点，通过形象启发，分层解剖的科学教学方法，提高了学生学习积极性，在教学实践中取得非常显著的效果。
一、明确定义要理解生产消费者问题，首先应弄清PV操作的含义：PV操作是由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下：P（S）：①将信号量S的值减1，即S=S-1；②如果S≥0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。
V（S）：①将信号量S的值加1，即S=S+1；②如果S>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。
这只是书本的定义，对于这部分内容，老师先不要急于解释上面的程序流程，而是应该让学生首先知道P操作与V操作到底有什么作用。
P操作相当于申请资源，而V操作相当于释放资源。
所以要学生记住以下几个关键字：P操作-----→申请资源V操作----→释放资源二、形象启发为此举两个生活中的例子：例一：在公共电话厅打电话公共电话厅里有多个电话，如某人要打电话，首先要进行申请，看是否有电话空闲，若有，则可以使用电话，如果电话亭里所有电话都有人正在使用，那后来的人只有排队等候。
当某人用完电话后，则有空电话腾出，正在排队的第一个人就可以使用电话。
这就相当于PV操作：某人要打电话，首先要进行申请，相当于执行一次P操作，申请一个可用资源（电话）；某人用完电话，则有空电话腾出，相当于执行一次V操作，释放一个可用资源（电话）。
生产者消费者问题例题及详解
生产者消费者问题例题及详解生产者消费者问题是一个经典的并发问题，涉及到两个独立的线程：生产者和消费者。
生产者生产物品，消费者消费物品。
生产者、消费者共享一个公共的固定大小的缓冲区。
以下是一个简单的生产者消费者问题的例子：假设有一个固定大小的缓冲区，大小为N。
生产者负责生成数据放入缓冲区，而消费者负责从缓冲区取出数据并处理。
1. 当缓冲区为空时，消费者被阻塞，等待生产者生产数据。
2. 当缓冲区满时，生产者被阻塞，等待消费者消费数据。
3. 缓冲区的每个元素只能被消费一次。
4. 缓冲区是循环使用的，即当缓冲区的最后一个元素被消费后，下一个元素将是缓冲区的第一个元素。
问题：如何实现这个生产者消费者模型？解答：可以使用条件变量和互斥锁来实现这个模型。
首先，定义一个缓冲区数组和一个计数器变量来跟踪缓冲区的使用情况。
然后，定义两个条件变量：一个用于生产者等待缓冲区非空，另一个用于消费者等待缓冲区非空。
最后，使用互斥锁来保护对缓冲区和计数器的访问。
以下是使用C++实现的代码示例：```cppinclude <iostream>include <thread>include <mutex>include <condition_variable>const int N = 5; // 缓冲区大小int buffer[N]; // 缓冲区数组int count = 0; // 计数器变量，表示缓冲区的使用情况std::mutex mutex; // 互斥锁std::condition_variable cv_prod; // 生产者等待条件变量std::condition_variable cv_cons; // 消费者等待条件变量void producer() {for (int i = 0; i < N 2; i++) {std::unique_lock<std::mutex> lock(mutex);cv_(lock, []{ return count < N; }); // 等待缓冲区非空buffer[count] = i; // 生产数据放入缓冲区std::cout << "Producer produced " << i << std::endl;count++; // 更新计数器变量if (count == N) count = 0; // 循环使用缓冲区cv__one(); // 通知消费者消费数据}}void consumer() {for (int i = 0; i < N 2; i++) {std::unique_lock<std::mutex> lock(mutex);cv_(lock, []{ return count > 0; }); // 等待缓冲区非空int data = buffer[count]; // 从缓冲区取出数据并处理 std::cout << "Consumer consumed " << data << std::endl;count--; // 更新计数器变量if (count == -1) count = N - 1; // 循环使用缓冲区cv__one(); // 通知生产者生产数据}}int main() {std::thread prod(producer); // 创建生产者线程 std::thread cons(consumer); // 创建消费者线程 (); // 等待生产者线程结束(); // 等待消费者线程结束return 0;}```。
操作系统中的经典问题——生产者消费者问题（两种方式实现）
操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）1、问题引⼊：什么是⽣产者消费者问题？⽣产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是⼀个多线程同步问题的经典案例。
该问题描述了共享固定⼤⼩缓冲区的两个线程——即所谓的“⽣产者”和“消费者”——在实际运⾏时会发⽣的问题。
⽣产者的主要作⽤是⽣成⼀定量的数据放到缓冲区中，然后重复此过程。
与此同时，消费者也在缓冲区消耗这些数据。
该问题的关键就是要保证⽣产者不会在缓冲区满时加⼊数据，消费者也不会在缓冲区中空时消耗数据。
.要解决该问题，就必须让⽣产者在缓冲区满时休眠（要么⼲脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，⽣产者才能被唤醒，开始往缓冲区添加数据。
同样，也可以让消费者在缓冲区空时进⼊休眠，等到⽣产者往缓冲区添加数据之后，再唤醒消费者。
通常采⽤进程间通信的⽅法解决该问题。
如果解决⽅法不够完善，则容易出现死锁的情况。
出现死锁时，两个线程都会陷⼊休眠，等待对⽅唤醒⾃⼰。
该问题也能被推⼴到多个⽣产者和消费者的情形。
2、问题分析该问题需要注意的⼏点：1. 在缓冲区为空时，消费者不能再进⾏消费2. 在缓冲区为满时，⽣产者不能再进⾏⽣产3. 在⼀个线程进⾏⽣产或消费时，其余线程不能再进⾏⽣产或消费等操作，即保持线程间的同步4. 注意条件变量与互斥锁的顺序由于前两点原因，因此需要保持线程间的同步，即⼀个线程消费（或⽣产）完，其他线程才能进⾏竞争CPU，获得消费（或⽣产）的机会。
对于这⼀点，可以使⽤条件变量进⾏线程间的同步：⽣产者线程在product之前，需要wait直⾄获取⾃⼰所需的信号量之后，才会进⾏product的操作；同样，对于消费者线程，在consume之前需要wait直到没有线程在访问共享区（缓冲区），再进⾏consume的操作，之后再解锁并唤醒其他可⽤阻塞线程。
生产者消费者问题操作系统课程设计思路
//System.out.print(""+this.toString()+"is
waitting\n");//**
}catch(InterruptedException e){}
}
}
模拟操作系统的P操作
public synchronized void v(String ss){//V操作
Value++;
生产者消费者问题操作系统课程设计 思路
技术路线
生产者—消费者
多生产者多消费者
同步
互斥
并发
可视化
管程实现
P（）/ V（）
Java中的 wait()和notify()
多线程
Thread
Java Swing和awt
生产者消费者问题操作系统课程设计 思路
核心技术（1）
模拟P、V操 作： PS：用Java中的wait()和notify()模拟
public synchronized void p(String s){
//P操作（即申请资源）
Value--;
if(Value<0){//没有可用资源
try{
System.out.print(""+s+"进入阻塞队列\n");
frame.a1.append(""+s+"进入阻塞队列\n");
this.wait(); //因资源不足而阻塞自己
生产者消费者问题操作系统课程设计 思路
3rew
演讲完毕，谢谢听讲!
再见，see you again
2020/11/8
生产者—消费者问题
第一章、概述1.1 课题背景在多道程序环境下，进程同步问题十分重要，也是一个相当有趣的问题，因而吸引了不少学者对它进行研究，并由此而产生了一系列经典的进程同步问题。
其中比较有代表性的有“生产者—消费者问题” 、“读者—写者问题” 、“哲学家进餐问题”等等。
通过对这些问题的研究和学习，可以帮助我们更好地理解进程同步概念及实现方法。
1.2生产者—消费者问题生产者—消费者问题（Producer_consumer）是一个经典的进程同步问题。
它描述的是：有一群生产者进程在生产产品，并将此产品提供给消费者进程去消费。
为使生产者进程和消费者进程能并发执行，在它们之间设置有个缓冲区的缓冲池，生产者进程可将它所生产的产品放入一个缓冲区中，消费者进程可从一个缓冲区取得一个产品消费。
尽管所有的生产者进程和消费者进程都是以异步的方式运行的，但它们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装有消息尚未被取走产品的缓冲区投放产品。
如下图所示：1.3进程同步机制在中引入进程后，虽然提高了资源的利用率和系统的吞吐量，但由于进程的异步性，也会给系统造成混乱，尤其是在它们争用临界资源的时候。
例如，当多个进程去争用一台打印机时，有可能使多个进程的输出结果交织在一起，难于区分；而当多个进程去争用共享变量，表格，链表时，有可能使数据处理出错。
进程同步的主要任务就是使并发执行的诸进程之间能有效地共享资源和相互合作，从而使程序的执行具有可再现性。
1.4进程同步优点进程同步其优点在于能够让操作系统更加有效地对资源进行管理和调度，最大潜力地发挥处理机的性能。
让系统的执行更加畅通无阻，尽可能地让系统少出现一些由于系统资源分配不合理所带来的死锁、死机之类的事情的发生。
保持了处理机的高速运行之后从用户角度来说程序运行所花费的时间就会更短。
从而保证了处理机在相同的时间内有更大的吞吐量。
而把并发进程的同步和互斥问题一般化，就可以得到一个抽象的一般模型，即本次课程设计的任务：生产者—消费者问题。
生产者与消费者问题理解（转载+个人理解）
⽣产者与消费者问题理解（转载+个⼈理解）⼀、问题描述⼆、问题分析该问题中出现的主要的两种关系：①⽣产者—消费者之间的同步关系表现为：⼀旦缓冲池中所有缓冲区均装满产品时，⽣产者必须等待消费者提供空缓冲区；⼀旦缓冲池中所有缓冲区全为空时，消费者必须等待⽣产者提供满缓冲区。
②⽣产者—消费者之间还有互斥关系：由于缓冲池是临界资源，所以任何进程在对缓冲区进⾏存取操作时都必须和其他进程互斥进⾏。
PV操作题⽬分析的步骤：1.关系分析。
找出题⽬中描述的各个进程，分析它们之间的同步、互斥关系。
2.整理思路。
根据各进程的操作流程确定PV操作的⼤致顺序。
3.设置信号量。
设置需要的信号量，并根据题⽬条件确定信号量的初值。
（互斥信号量初值⼀般为1，同步信号量的初值需要看对应资源的初始值是多少）在这⾥：互斥的实现是在同⼀个进程中进⾏的⼀对PV操作。
同步的实现是在两个进程中进⾏的，在⼀个进程中执⾏P操作，在另⼀个进程中执⾏V操作。
semaphore mutex = 1; //互斥信号量semaphore empty = n; //同步信号量。
空闲缓冲区的数量semaphore full = 0; //同步信号量。
产品的数量，⾮空缓冲区的数量producer(){while(1){⽣成⼀个产品;P(empty); //消耗⼀个空闲缓冲区P(mutex);把产品放⼊缓冲区;V(mutex);V(full) //增加⼀个产品}}consumer(){while(1){P(full); //消耗⼀个产品P(mutex);从缓冲区取出⼀个产品;V(mutex);V(empty); //增加⼀个空闲缓冲区使⽤产品;}}实现互斥的P操作⼀定要放在实现同步的P操作之后！我们观察上⾯的代码，⽣产者⽣产产品和消费者使⽤产品这两个操作都是放在各⾃进程的PV操作之外的，那么能不能放在各⾃的PV操作之内呢？其实从逻辑上来说是可以的，⽐如从缓冲区取出⼀个产品之后⽴即使⽤这个产品，但是这样就会造成临界区的代码量变⼤，消费者进程访问临界区将会耗费更多的时间，若此时有别的进程想要访问临界区是会被阻塞的，若将这些不是很⾮代码也放⼊临界区，会造成进程的并发度降低。
经典同步互斥问题
经典同步互斥之生产者—消费者问题生产者—消费者同步问题其实际上就是生活中同步、互斥问题的一个抽象模型，如多个进程合作解决文件打印的问题，汽车行驶过程中司机与售票员的活动问题，理发师理发问题等等。
要解决同步互斥问题，最主要的是理清楚活动者之间的同步关系，还有某些问题中变量的互斥问题。
分析清楚之后就是设置信号量，设置几个，并且根据实际情况给出信号量的初值。
生产者—消费者问题就是生产者进程向消费者进程提供消息。
生产者生产商品存入空缓冲区内，而消费者从缓冲区内取出产品并消费。
1、一个生产者P和一个消费者Q（其中只有同步问题）其同步关系为：（1）P进程不能向“满”的缓存区内存放产品，即仅当有一个空缓存区时才能放产品，设置信号量empty,初值为0，用于指示空缓存区数目。
（2）Q进程不能从空的缓存区中取产品，设置信号量full，初值为0，用于指示满缓存区的数目。
注意：a）在P、V操作中，P、V操作必须成对出现；b）在互斥关系中P、V操作在同一进程内；【c）在同步关系中P、V操作在不同的进程内。
其同步问题解决如下：P: //生产者repeat生产一个产品;送产品到缓冲区;V(full);//释放一个满的缓冲区;P(empty); //申请一个空的缓冲区存放产品;until false;；Q: //消费者repeatP(full);//申请一个满的缓存区取产品从缓存区取产品;V(empty);//产品取完后释放掉该空的缓存区消费产品;until false;2、多个生产者和多个消费者多个生产者和消费者问题中，缓存区属于临界资源，它只允许一个生产者放入产品或者一个消费者从中取产品。
生产者之间、生产者与消费者之间、消费者之间都必须互斥的使用缓冲区。
其中既存在同步问题，又存在互斥问题。
其同步关系为：（1）>（2）至少有一个缓冲区已存入消息后，消费者才能从中提取消息，否则消费者必须等待。
设置信号量empty,初值为n，用于指示空缓冲区的数目；（3）至少有一个缓存区是空的，生产者才能将消息存入缓冲区，否则生产者必须等待。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
生产者消费者问题是一个著名的线程同步问题，该问题描述如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经放入产品的缓冲区中再次投放产品。
这个生产者消费者题目不仅常用于操作系统的课程设计，也常常在程序员和软件设计师考试中出现。
并且在计算机考研的专业课考试中也是一个非常热门的问题。
因此现在就针对这个问题进行详细深入的解答。
首先来简化问题，先假设生产者和消费者都只有一个，且缓冲区也只有一个。
这样情况就简便多了。
第一．从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。
可以用关键段和互斥量来完成。
第二．生产者要等待缓冲区为空，这样才可以投放产品，消费者要等待缓冲区不为空，这样才可以取出产品进行消费。
并且由于有二个等待过程，所以要用二个事件或信号量来控制。
//1生产者1消费者1缓冲区//使用二个事件，一个表示缓冲区空，一个表示缓冲区满。
//再使用一个关键段来控制缓冲区的访问#include<stdio.h>#include<process.h>#include<windows.h>//设置控制台输出颜色BOOL SetConsoleColor(WORD wAttributes){HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);if (hConsole == INVALID_HANDLE_VALUE)return FALSE;return SetConsoleTextAttribute(hConsole, wAttributes);}const int END_PRODUCE_NUMBER = 10; //生产产品个数int g_Buffer; //缓冲区//事件与关键段CRITICAL_SECTION g_cs;HANDLE g_hEventBufferEmpty, g_hEventBufferFull;//生产者线程函数unsigned int__stdcall ProducerThreadFun(PVOID pM){for (int i = 1; i <= END_PRODUCE_NUMBER; i++){//等待缓冲区为空WaitForSingleObject(g_hEventBufferEmpty, INFINITE);//互斥的访问缓冲区EnterCriticalSection(&g_cs);g_Buffer = i;printf("生产者将数据%d放入缓冲区\n", i);LeaveCriticalSection(&g_cs);//通知缓冲区有新数据了SetEvent(g_hEventBufferFull);}return 0;}//消费者线程函数unsigned int__stdcall ConsumerThreadFun(PVOID pM){volatile bool flag = true;while (flag){//等待缓冲区中有数据WaitForSingleObject(g_hEventBufferFull, INFINITE);//互斥的访问缓冲区EnterCriticalSection(&g_cs);SetConsoleColor(FOREGROUND_GREEN);printf(" 消费者从缓冲区中取数据%d\n", g_Buffer);SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);if (g_Buffer == END_PRODUCE_NUMBER)flag = false;LeaveCriticalSection(&g_cs);//通知缓冲区已为空SetEvent(g_hEventBufferEmpty);Sleep(10); //some other work should to do}return 0;}int main(){printf("生产者消费者问题 1生产者1消费者1缓冲区\n");InitializeCriticalSection(&g_cs);//创建二个自动复位事件，一个表示缓冲区是否为空，另一个表示缓冲区是否已经处理g_hEventBufferEmpty = CreateEvent(NULL, FALSE, TRUE, NULL);g_hEventBufferFull = CreateEvent(NULL, FALSE, FALSE, NULL);const int THREADNUM = 2;HANDLE hThread[THREADNUM];hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);CloseHandle(hThread[0]);CloseHandle(hThread[1]);//销毁事件和关键段CloseHandle(g_hEventBufferEmpty);CloseHandle(g_hEventBufferFull);DeleteCriticalSection(&g_cs);return 0;}运行结果：可以看出生产者与消费者已经是有序的工作了。
然后再对这个简单生产者消费者问题加大难度。
将消费者改成2个，缓冲池改成拥有4个缓冲区的大缓冲池。
如何来思考了这个问题了？首先根据上面分析的二点，可以知道生产者和消费者由一个变成多个的影响不大，唯一要注意的是缓冲池变大了，回顾一下《线程同步信号量Semaphore》中的信号量，不难得出用二个信号量就可以解决这种缓冲池有多个缓冲区的情况——用一个信号量A来记录为空的缓冲区个数，另一个信号量B记录非空的缓冲区个数，然后生产者等待信号量A，消费者等待信号量B就可以了。
因此可以仿照上面的代码来实现复杂生产者消费者问题，示例代码如下：//1生产者2消费者4缓冲区#include<stdio.h>#include<process.h>#include<windows.h>//设置控制台输出颜色BOOL SetConsoleColor(WORD wAttributes){HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);if (hConsole == INVALID_HANDLE_VALUE)return FALSE;return SetConsoleTextAttribute(hConsole, wAttributes);}const int END_PRODUCE_NUMBER = 8; //生产产品个数const int BUFFER_SIZE = 4; //缓冲区个数int g_Buffer[BUFFER_SIZE]; //缓冲池int g_i, g_j;//信号量与关键段CRITICAL_SECTION g_cs;HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;//生产者线程函数unsigned int__stdcall ProducerThreadFun(PVOID pM){for (int i = 1; i <= END_PRODUCE_NUMBER; i++){//等待有空的缓冲区出现WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);//互斥的访问缓冲区EnterCriticalSection(&g_cs);g_Buffer[g_i] = i;printf("生产者在缓冲池第%d个缓冲区中投放数据%d\n", g_i, g_Buffer[g_i]);g_i = (g_i + 1) % BUFFER_SIZE;LeaveCriticalSection(&g_cs);//通知消费者有新数据了ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);}printf("生产者完成任务，线程结束运行\n");return 0;}//消费者线程函数unsigned int__stdcall ConsumerThreadFun(PVOID pM){while (true){//等待非空的缓冲区出现WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);//互斥的访问缓冲区EnterCriticalSection(&g_cs);SetConsoleColor(FOREGROUND_GREEN);printf(" 编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志{LeaveCriticalSection(&g_cs);//通知其它消费者有新数据了(结束标志)ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);break;}g_j = (g_j + 1) % BUFFER_SIZE;LeaveCriticalSection(&g_cs);Sleep(50); //some other work to doReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);}SetConsoleColor(FOREGROUND_GREEN);printf(" 编号为%d的消费者收到通知，线程结束运行\n", GetCurrentThreadId());SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);return 0;}int main(){printf("生产者消费者问题 1生产者2消费者4缓冲区\n");InitializeCriticalSection(&g_cs);//初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);g_hSemaphoreBufferFull = CreateSemaphore(NULL, 0, 4, NULL);g_i = 0;g_j = 0;memset(g_Buffer, 0, sizeof(g_Buffer));const int THREADNUM = 3;HANDLE hThread[THREADNUM];//生产者线程hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);//消费者线程hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);for (int i = 0; i < THREADNUM; i++)CloseHandle(hThread[i]);//销毁信号量和关键段CloseHandle(g_hSemaphoreBufferEmpty);CloseHandle(g_hSemaphoreBufferFull);DeleteCriticalSection(&g_cs);return 0;}运行结果：输出结果证明各线程的同步和互斥已经完成了。