实现生产者消费者问题
生产者消费者问题例题及详解
生产者消费者问题例题及详解生产者消费者问题是一个经典的并发问题，涉及到两个独立的线程：生产者和消费者。
生产者生产物品，消费者消费物品。
生产者、消费者共享一个公共的固定大小的缓冲区。
以下是一个简单的生产者消费者问题的例子：假设有一个固定大小的缓冲区，大小为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）概述设计目的:通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制。
说明:有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1-20这20个整型数。
设计要求:(1)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费者县城的标识符。
(2)生产者和消费者各有两个以上。
(3)多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码。
（2）设计原理通过一个有界缓冲区把生产者和消费者联系起来。
假定生产者和消费者的优先级是相同的，只要缓冲区未满，生产者就可以生产产品并将产品送入缓冲区。
类似地，只要缓冲区未空，消费者就可以从缓冲区中取走产品。
应该禁止生产者向满的缓冲区送入产品，同时也应该禁止消费者从空的缓冲区中取出产品，这一机制有生产者线程和消费者线程之间的互斥关系来实现。
与计算打印两进程同步关系相同，生产者和消费者两进程P和C之间应满足下列两个同步条件：①只有在缓冲池中至少有一个缓冲区已存入消息后，消费者才能从中提取信息，否则消费者必须等待。
②只有缓冲池中至少有一个缓冲区是空时，生产者才能把消息放入缓冲区，否则生产者必须等待。
为了满足第一个同步条件，设置一个同步信号量full，它代表的资源是缓冲区满，它的初始值为0，它的值为n时整个缓冲池满。
这个资源是消费者类进程C所有，C进程可以申请该资源，对它施加P操作，而C进程的合作进程生产者进程P对它施加V操作。
同样为了满足第二个同步条件，设置另一个同步信号量empty，它代表的资源是缓冲空区，它的初始值为n，表示缓冲池中所有缓冲区空。
信号量full表示可用缓冲区数量，信号量empty表示缓冲区数量，设置整型变量：存入指针in和取出指针out。
操作系统中的经典问题——生产者消费者问题（两种方式实现）
操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）1、问题引⼊：什么是⽣产者消费者问题？⽣产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是⼀个多线程同步问题的经典案例。
该问题描述了共享固定⼤⼩缓冲区的两个线程——即所谓的“⽣产者”和“消费者”——在实际运⾏时会发⽣的问题。
⽣产者的主要作⽤是⽣成⼀定量的数据放到缓冲区中，然后重复此过程。
与此同时，消费者也在缓冲区消耗这些数据。
该问题的关键就是要保证⽣产者不会在缓冲区满时加⼊数据，消费者也不会在缓冲区中空时消耗数据。
.要解决该问题，就必须让⽣产者在缓冲区满时休眠（要么⼲脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，⽣产者才能被唤醒，开始往缓冲区添加数据。
同样，也可以让消费者在缓冲区空时进⼊休眠，等到⽣产者往缓冲区添加数据之后，再唤醒消费者。
通常采⽤进程间通信的⽅法解决该问题。
如果解决⽅法不够完善，则容易出现死锁的情况。
出现死锁时，两个线程都会陷⼊休眠，等待对⽅唤醒⾃⼰。
该问题也能被推⼴到多个⽣产者和消费者的情形。
2、问题分析该问题需要注意的⼏点：1. 在缓冲区为空时，消费者不能再进⾏消费2. 在缓冲区为满时，⽣产者不能再进⾏⽣产3. 在⼀个线程进⾏⽣产或消费时，其余线程不能再进⾏⽣产或消费等操作，即保持线程间的同步4. 注意条件变量与互斥锁的顺序由于前两点原因，因此需要保持线程间的同步，即⼀个线程消费（或⽣产）完，其他线程才能进⾏竞争CPU，获得消费（或⽣产）的机会。
对于这⼀点，可以使⽤条件变量进⾏线程间的同步：⽣产者线程在product之前，需要wait直⾄获取⾃⼰所需的信号量之后，才会进⾏product的操作；同样，对于消费者线程，在consume之前需要wait直到没有线程在访问共享区（缓冲区），再进⾏consume的操作，之后再解锁并唤醒其他可⽤阻塞线程。
生产者消费者问题实验报告
操作系统课程设计实验报告实验名称: 生产者消费者问题姓名/学号:一、实验目的以生产者和消费者问题为例, 学习Linux和Windows下进程通信、同步机制的具体实现方法, 主要是信号量和共享内存。
熟悉相关系统API的用法。
二、实验内容使用共享内存和信号量机制来实现多个生产者/消费者进程间的通信和同步。
要求在Linux和Windows下分别实现。
缓冲区大小为3, 初始为空。
2个生产者, 随机等待一段时间, 往缓冲区添加数据, 重复6次。
3个消费者, 重复4次。
三、实验环境Ubuntu 10.10 , GCC; Windows 7, VC 6.0;四、程序设计与实现1.Linux下:(1) 数据结构:a.共享内存定义为一个结构, 使得其数据成员更清晰且操作变得简单。
b.共享缓冲区采用循环队列的数据结构，由上面的结构struct buf { int start; int end; int info[BUF_NUM]; }维护。
其中start为队头指针, end为队尾指针, info为数据区域。
(2) 算法:a.大致由三个模块组成:i.主程序(main):ii.创建信号量、共享内存并进行初始化iii.创建生产者、消费者进程, 生产者执行pro_fun(), 消费者执行con_fun()iv.等待所有子进程的结束v.删除信号量、共享内存i.生产者进程(pro_fun):ii.通过key获得信号量、共享内存的ID, 将内存添加到自己的地址空间iii.P(empty), P(mutex), Add(data), V(mutex), V(full)iv.解除和共享内存的关联i.消费者进程(con_fun):ii.通过key获得信号量、共享内存的ID, 将内存添加到自己的地址空间iii.P(full), P(mutex), Add(data), V(mutex), V(empty)iv.解除和共享内存的关联循环队列部分:加入数据: info[end] = value; end = (end + 1) % 3;取出数据: temp = info[start]; info[start] = 0; (start = start + 1)%3; return temp;(3) 程序流程图:a.主函数：b.生产者进程:c.消费者进程和生产者类似4.Windows 下:(1) 数据结构:和Linux大致相同(2) 算法:a.创建的子进程调用正在执行的文件本身, 通过main函数的参数区分主进程和生产者、消费者进程。
操作系统之生产者消费者问题(c++实现)
{
std::cout<<"* - - - - - - - - - - - - - - - - - - - - - - - *"<<std::endl;
std::cout<<"|课程设计课题:生产者-消费者问题的模拟实现|"<<std::endl;
std::cout<<"|指导老师:李先锋|"<<std::endl;
bool g_continue = 1;//控制程序运行：1表示继续运行?0表示停止运行
HANDLE g_hMutex;//线程间的互斥信号量
HANDLE g_hFullSemaphore;//资源信号量：缓冲区满
HANDLE g_hEmptySemaphore;//资源信号量：缓冲区空
DWORD WINAPI Producer(LPVOID);//生产者线程
std::cout<<"|学生:丁可|"<<std::endl;
std::cout<<"|班级: B计123班|"<<std::endl;
std::cout<<"* - - - - - - - - - - - - - - - - - - - - - - - *"<<std::endl;
std::cout<<" ==》按回车开始该程序"<<std::endl;
getchar();
}
/*----------------------------程序提示信息结束------------------------------*/
生产者消费者问题实验报告
生产者消费者问题实验报告生产者消费者问题实验报告一、引言生产者消费者问题是计算机科学中一个经典的并发问题，主要涉及到多个线程之间的协作和资源的共享。
在本实验中，我们通过编写一个简单的程序来模拟生产者和消费者之间的交互过程，以深入理解该问题的本质和解决方案。
二、问题描述在生产者消费者问题中，有两类线程：生产者和消费者。
生产者线程负责生产一定数量的产品，而消费者线程则负责消费这些产品。
两类线程需要共享一个有限的缓冲区，生产者将产品放入缓冲区，而消费者从缓冲区中取出产品。
然而，缓冲区的容量是有限的，当缓冲区已满时，生产者需要等待，直到有空间可用。
同样地，当缓冲区为空时，消费者需要等待，直到有产品可用。
三、实验设计为了解决生产者消费者问题，我们采用了经典的解决方案——使用互斥锁和条件变量。
互斥锁用于保护共享资源的访问，保证同一时间只有一个线程可以访问共享资源。
而条件变量用于线程之间的通信，当某个条件不满足时，线程可以通过条件变量进入等待状态，直到条件满足时再被唤醒。
在我们的程序中，我们使用了一个有界缓冲区来模拟生产者消费者之间的交互。
缓冲区的大小可以通过参数进行设置。
我们创建了两个线程分别代表生产者和消费者，它们通过互斥锁和条件变量来实现同步。
生产者线程在缓冲区未满时将产品放入缓冲区，并通知消费者线程有产品可用；消费者线程在缓冲区非空时从缓冲区取出产品，并通知生产者线程有空间可用。
通过这种方式，我们保证了生产者和消费者之间的协作和资源的共享。
四、实验结果经过多次运行实验，我们观察到了以下现象：当生产者线程的生产速度大于消费者线程的消费速度时，缓冲区会被生产者填满，消费者需要等待；当消费者线程的消费速度大于生产者线程的生产速度时，缓冲区会被消费者清空，生产者需要等待。
只有当生产者和消费者的速度相等时，才能实现平衡的生产和消费。
此外，我们还发现在某些情况下，生产者和消费者线程可能出现死锁或饥饿现象。
死锁是指两个或多个线程相互等待对方释放资源，导致程序无法继续执行的情况。
信号量实现生产者消费者问题
生产者——消费者问题一、实验目的通过实验，掌握Windows和Linux环境下互斥锁和信号量的实现方法，加深对临界区问题和进程同步机制的理解，同时巩固利用Windows API和Pthread API进行多线程编程的方法。
二、实验内容1. 在Windows操作系统上，利用Win32 API提供的信号量机制，编写应用程序实现生产者——消费者问题。
2. 在Linux操作系统上，利用Pthread API提供的信号量机制，编写应用程序实现生产者——消费者问题。
3. 两种环境下，生产者和消费者均作为独立线程，并通过empty、full、mutex三个信号量实现对缓冲进行插入与删除。
4. 通过打印缓冲区中的内容至屏幕，来验证应用程序的正确性。
三、实验步骤㈠设计思路①声明三个信号量，互斥信号量mutex，计数信号量empty初始化值100，技术信号量full初始化值0，并声明一个缓冲区char类型的buffer数组，大小为10，初始值为N。
②produce利用信号量形成对buffer临界生产，添加一个元素进去，赋值为A。
consume利用信号量形成对buffer临界消费，从buffer 中拿出来一个元素，并将buffer中原来元素赋为B。
每访问一次临界区，就输出buffer值。
③创建多线程，其中5个生产者，和5个消费者，每个线程最多操作缓冲区10次。
㈡流程图四、主要数据结构及其说明声明一个char类型的数组buffer，大小为10，用来做生产者和消费者共同访问的共享变量，可视做临界区。
五、程序运行时的初值和运行结果Win32下Linux下六、实验体会本实验总体感觉不是很难，就是将用信号量解决生产者消费者问题用具体的代码实现。
主要的工作就是分别在Win32和Pthread下用不同的函数名来实现P操作和V操作。
还有就是如何验证程序的正确性，就是通过没执行一次操作就输出缓冲区buffer值来判断是否符合要求。
七、源程序并附上注释Win32下#include <IOSTREAM.h>#include <STDIO.H>#include <windows.h>HANDLE Empty,full,mutex;//声明3个信号量，互斥信号量mutex，计数信号量full和Emptyint x=0;int y=0;char *buffer;//缓冲区buffer//输出buffervoid output(){for (int i=0;i<10;i++){cout<<buffer[i]<<" ";}cout<<"\n";}DWORD WINAPI produce(LPVOID param){int j=0;do{WaitForSingleObject(Empty,INFINITE);//buffer空余量减一WaitForSingleObject(mutex,INFINITE);//形成互斥，只能一个线程去生产cout<<GetCurrentThreadId()<<"^^^^^"<<j<<"^^^^^";//输出当前线程的id号，和执行的次数buffer[(y++%10)]='A';//生产赋值为Aoutput();//输出bufferj++;ReleaseSemaphore(mutex,1, NULL);//取消互斥，允许其他线程生产ReleaseSemaphore(full,1, NULL);//可以消费量加1 } while (j!=10);//每个线程生产10次return 0;}DWORD WINAPI consume(LPVOID param){int j=0;do{WaitForSingleObject(full,INFINITE);//将可以消费量减1WaitForSingleObject(mutex,INFINITE);//形成互斥访问，自能一个线程可以访问。
生产者与消费者的问题-----操作系统课程设计
闽江学院计算机系网络操作系统课程设计设计内容：进程机制与并发程序设计——linux下生产者与消费者的问题实现目录：一、设计内容 (3)二、设计思想 (4)三、系统结构 (5)四、PV操作代码 (5)五、C++程序代码 (6)六、运行结果截图 (9)七、参考文献 (11)八、实验总结 (11)一、设计内容进程机制与并发程序设计————linux下生产者与消费者的问题实现1．实验目的（1）掌握基本的同步互斥算法，理解生产者和消费者同步的问题模型。
（2）了解linux中多线程的并发执行机制，线程间的同步和互斥。
2、实验环境：C/C++语言编译器3、实验要求（1）创建生产者和消费者线程在linux环境下，创建一个控制台进程，在此进程中创建n个线程来模拟生产者或者消费者。
这些线程的信息由本程序定义的“测试用例文件”中予以指定。
该文件的格式和含义如下：31 P 32 P 43 C4 14 P 25 C 3 1 2 4第一行说明程序中设置几个临界区，其余每行分别描述了一个生产者或者消费者线程的信息。
每一行的各字段间用Tab键隔开。
不管是消费者还是生产者，都有一个对应的线程号，即每一行开始字段那个整数。
第二个字段用字母P或者C区分是生产者还是消费者。
第三个字段表示在进入相应线程后，在进行生产和消费动作前的休眠时间，以秒计时；这样做的目的是可以通过调整这一列参数，控制开始进行生产和消费动作的时间。
如果是代表生产者，则该行只有三个字段。
如果代表消费者，则该行后边还有若干字段，代表要求消费的产品所对应的生产者的线程号。
所以务必确认这些对应的线程号存在并且该线程代表一个生产者。
（2）生产和消费的规则在按照上述要求创建线程进行相应的读写操作时，还需要符合以下要求：①共享缓冲区存在空闲空间时，生产者即可使用共享缓冲区。
②从上边的测试数据文件例子可以看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录目录 (1)1.设计题目与要求 (2)1.1题目: 实现生产者消费者(Bounded-Buffer Problem) 问题 (2)1.2要求 (2)1.2.1初始条件 (2)1.2.2技术要求 (2)2.问题简介 (2)2.1问题背景 (2)2.2问题分类 (3)2.3基本解决方案 (3)3.设计思想及原理 (3)4.系统平台、语言及工具 (5)5. 数据结构与模块说明（功能与流程图） (5)5.1数据结构 (5)5.2模块说明 (5)6.程序源码及运行结果 (6)6.1程序源代码 (6)6.2运行结果 (10)7.总结 (10)8.参考文献 (11)实现生产者消费者(Bounded-Buffer Problem) 问题1.设计题目与要求1.1题目: 实现生产者消费者(Bounded-Buffer Problem) 问题1.2要求1.2.1初始条件1.操作系统：Linux2.程序设计语言：C语言3.有界缓冲区内设有20个存储单元，其初值为0。
放入/取出的数据项按增序设定为1－20这20个整型数。
1.2.2技术要求1）为每个生产者/消费者产生一个线程，设计正确的同步算法2）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部内容、当前指针位置和生产者/消费者线程的自定义标识符。
3）生产者和消费者各有两个以上。
4）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。
2.问题简介2.1问题背景生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。
在同一个进程地址空间内执行的两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。
2.2问题分类根据缓冲区的个数、大小以及生产者消费者的个数可以分为以下几类：1.单缓冲区(适合单或多生产消费者);2.环行多缓冲区（或无穷缓冲区）单生产消费者;3.环行多缓冲区多生产消费者;2.3基本解决方案1.用进程通信(信箱通信)的方法解决;2.进程消息缓冲通信;3.进程信箱通信;3.设计思想及原理在操作系统原理课程中，我们已经了解到了可以采用信号量来解决n个进程的临界区问题，这n个进程共享一个信号量mutex(mutual exclusion)，并初始化的组织结构如下图。
为1。
每个进程Pi由于本系统我们研究的是有限缓冲区（Bounded-Buffer）的生产者消费者问题。
而且根据初始条件可知，该缓冲区内有20个缓冲项，每个缓冲项存储一个整形数。
信号量mutex提供了对缓冲池访问的互斥要求，并初始化为1。
信号量empty和full分别用来表示空缓冲项和满缓冲项的数量。
信号量empty初始化为20，而信号量full初始化为0；生产者进程和消费者进程的代码如图。
注意生产者和消费者之间的对称性可以这样来理解代码：生产者为消费者生产满缓冲项，或消费者为生产者生产空缓冲项。
4.系统平台、语言及工具此实验在操作系统Ubuntu9.10下实现，主要用到的工具为vi和gedit(用于源代码的编辑)，以及GCC工具（用于源代码的编译链接等）。
具体版本： Vi(7.2.245)gcc(4.4.1)5. 数据结构与模块说明（功能与流程图）5.1数据结构该系统用到的有限缓冲区采用数组实现5.2模块说明该实验主要分为三大模块:1.主程序，控制程序的流程，其中控制线程的活动以及信号量的操作。
2.生产者模块：生产者对缓冲区的操作3.消费者模块：消费者对缓冲区的操作5.3 程序相关模块的流程图(生产者线程流程图)(消费者线程流程图) 6.程序源码及运行结果6.1程序源代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<pthread.h>#include<semaphore.h>#include<signal.h>#define num_producer 3#define num_consumer 3 //由于题目要求生产者和消费者各有两个以上，故此处均定为3个#define BUFFER_SIZE 20 //定义缓冲区的大小，按题目要求为20int NUM=1; //题目要求放入/取出的数据项按增序设定为1-20，因此定义此全局变量int buffer[BUFFER_SIZE];int nextp=0,nextc=0;sem_t empty,full,mutex;//主函数int main(){int i;signal(SIGALRM,handler);sem_init(&empty,0,BUFFER_SIZE);sem_init(&full,0,0);sem_init(&mutex,0,1);for(i=0;i<BUFFER_SIZE;i++) buffer[i]=0;for(i=0;i<num_producer;i++)pthread_create(&threads_p[i],NULL,(void*)producer_thread,(void*)(i+1));for(i=0;i<num_consumer;i++)pthread_create(&threads_c[i],NULL,(void*)consumer_thread,(void *)(i+1));for(i=0;i<num_producer;i++) pthread_join(threads_p[i],NULL);for(i=0;i<num_consumer;i++) pthread_join(threads_c[i],NULL);sem_destroy(&empty);sem_destroy(&full);sem_destroy(&mutex);return 0;//消费者代码void *consumer_thread(void *tid){int i;pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL); while(1){sem_wait(&full);srand((int)time(NULL)*(int)tid);sem_wait(&mutex);printf("消费者标识:%d\t指针位置:%d\t\n",(int)tid,nextc); buffer[nextc]=0;nextc=(nextc+1)%20;printf("缓冲区:");for(i=0;i<BUFFER_SIZE;i++){printf("%3d",buffer[i]);}printf("\n");sem_post(&mutex);sem_post(&empty);srand((int)time(NULL)*(int)tid);sleep(1);}return ((void*)0);}//生产者代码void *producer_thread(void *tid)int i;pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL); while(1){sem_wait(&empty);srand((int)time(NULL)*(int)tid);sleep(1);while((nextp+1)%20==nextc);sem_wait(&mutex);if(NUM>20) NUM=1;//如果大于20，NUM重新为1buffer[nextp]=(NUM++);nextp=(nextp+1)%20;if(nextp==0){printf("生产者标识:%d\t指针位置:19\t\n",(int)tid);}else{printf("生产者标识:%d\t指针位置:%d\t\n",(int)tid,nextp-1); }printf("缓冲区:");for(i=0;i<BUFFER_SIZE;i++){printf("%3d",buffer[i]);}printf("\n");sem_post(&mutex);sem_post(&full);srand((int)time(NULL)*(int)tid);}return ((void*)0);}6.2运行结果程序按Ctrl+Z终止运行，即进程挂起，可使用fg %id 继续运行查看结果7.总结进程的同步与互斥是操作系统课程中非常重要的一部分内容。
通过本次课程设计，我不仅学会了使用信号量机制解决有限缓冲区的生产者消费者问题，而且对Linux系统下多线程编程有了更深入的了解。
武汉理工大学《操作系统》课程设计论文虽然实验以前我已经对信号量机制解决进程间同步问题的原理有了很清楚的认识，但是此次课程设计中仍然遇到了很多问题，如Linux系统下各种系统调用以及函数的各种参数，都花费了我很多时间去网上看各种资料——虽然Linux 系统中可以很方便的阅读源代码以及使用man命令进行相应指令的查看，但是全英文的资料让人看了不免有些发怵，看来还要多多加强计算机专业英语的学习，以后便可以在Linux系统中查看各种帮助文件。
另一个问题就是在编译的时候遇到的，刚开始用gcc –o main main.c 进行编译的时候总是提示出错，后来查了相关资料才知道pthread 库不是Linux 系统默认的库，连接时需要使用静态库libpthread.a，所以在使用pthread_create()等函数时，需要链接该库才能编译通过。
以前再用Windows IDE进行编程的时候基本上不会遇到这样的问题，看来的确IDE为我们做了很多工作，隐藏了一些技术细节，有时候隐藏这些细节虽然可以方便我们，却让我们离真相越来越远。
最近使用Linux进行相关的编程操作，感悟还是挺多的。
Windows下的层层封装的确让我们感到很方便，但同时也让我们编程变得越来越不灵活。
因为我们不用再去了解底层的东西因此一遇到问题就会束手无策。