用多进程同步方法演示“生产者-消费者”问题
while(1)
{ pthread_testcancel();
//设置取消点
pthread_cleanup_push(pthread_mutex_unlock, (void *) &mutex);
//线程清理处理函数
pthread_mutex_lock(&mutex);
//对临界资源加锁
while(size >= BUFFER_LENGTH)
三、 系统分析与设计
1、系统分析 1.1 功能需求：生产者与消费者需要对缓冲池互斥操作，其中生产者和消费者的数目可
以任意改变。生产者和消费者的速度也要随机的进行修改。可以查看当前生产者和消费者以 及有界缓冲区的状态。
1.2 数据需求：本次试验生产者和消费者的数量要动态的增加、减少，还有缓冲区的产 品数，以及生产、消费产品的指针。
指 导 教 师:
王**
2013—2014 年度 第 2 学期 完成日期: 2014 年 7 月 18 日
一、 课程设计目的
本次操作系统课程设计的主要任务是通过研究 Linux 的进程机制和信号量，实现生产者 消费者问题的并发控制。实验中需要设置多个生产者和多个消费者，生产者和消费者对同一 个缓冲区进行操作，互斥的访问缓冲区。本次课程设计的目的就是加深对多进程如何正确访 问临界资源的理解，同时掌握条件变量在互斥访问时应该如何正确有效地使用。掌握生产者 消费者问题的解决流程和方法，能够在此基础上解决现实中的具体问题。
//创建线程函数调用 //将线程添加到线程列表
} 创建消费者线程：
int create_pthread_consumer()
{
char pthread_id[20]="";
pthread_t consumer_id; pthread_create(&consumer_id,NULL,consumer,NULL); //创建线程函数调用
apt-get install devhelp #安装 devhelp GTK 文档查看程序 apt-get install libglib2.0-doc libgtk2.0-doc #安装 gtk/glib 的 API 参考手册及其它帮助文 档 apt-get install glade libglade2-dev #安装基于 GTK 的界面 GTK 是开发 Gnome 窗口的 c/ c++语言图形库 apt-get install libgtk2.0*,#gtk+2.0 所需的所有文件统通下载安装完毕。 2、操作步骤：
sprintf(pthread_id,"%lu",consumer_id); add_to_list(list_consumers, pthread_id);
//将线程添加到线程列表
return 0;
} 生产者函数：
void *producer(void *arg)
{ pthread_detach(pthread_self());
五、用户手册
1、使用平台是 linux 下 gcc 安装 gcc、Gtk 命令： apt-get install build-essential #安装 gcc/g++/gdb/make 等基本编程工具 apt-get install gnome-core-devel #安装 libgtk2.0-dev libglib2.0-dev 等开发相关库文件 apt-get install pkg-config #用于在编译 GTK 程序时自动找出头文件及库文件位置
**理工大学
操作系统课程设计报告
院（系）：
计算机工程学院
专业： 计算机科学与技术 班级： 计算 111
学 生 姓 名 ： **
学号： 201107015
题目：用多进程同步方法演示“生产者-消费者”问题
起迄日期: 2014.07.07-2014.07.18
设计地点: 现代教育中心 101-103、主教学楼 B505
第一步：添加生产者
第二步：添加消费者
第三步：显示缓冲池信息
第四步：删除生产者 第五步：删除消费者
第六步：设置生产者和消费者的速度
六、程序清单
创建生产者线程： int create_pthread_producer() {
char pthread_id[20]=""; pthread_t producer_id; pthread_create(&producer_id,NULL,producer,NULL); sprintf(pthread_id,"%lu",producer_id); add_to_list(list_producers, pthread_id); return 0;
二、 课程设计内容
课程设计内容： 1) 生产者和消费者进程的数目不固定，可在程序界面上设置 2) 生产者和消费者进程的数目在程序界面上可调，在运行时可随时单个增加与减少生 产者与消费者 3) 生产者的生产速度与消费者的消费速度均可在程序界面调节，在运行中，该值调整 后立即生效 4) 生产者生产的产品由随机函数决定 5) 多个生产者或多个消费者之间必须有共享对缓冲区进行操作的函数代码 6) 每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容、 当前生产者与消费者的指针位置，以及生产者和消费者线程标识符 7) 采用可视化界面，可在运行过程中随时暂停，查看当前生产者、消费者以及有界缓 冲区的状态
consumer_wait = 1; pthread_cond_wait(&empty_cond,&mutex);
开始 申请空缓冲区
信
号
量
size>=BUFFER_LENGT
H
否
buffer[rear] = rand()%BUFFER_LENGTH;
rear = rear+1
打印缓冲区状态
size = size+1 释放缓冲区结束来自是 缓冲区已满，线程阻塞
消费者流程图：
开始 申请空缓冲区
信
号
量
size>=BUFFER_LENGT
//线程分离
char info[50]="Pool is full, producer ";
char *value=(char *)malloc(30);
sprintf(value,"%lu",pthread_self());
strcat(info,value);
strcat(info,"is waiting!");
（3）测试生产者和消费者的速度是否可以调节 测 测试名称 用多进程同步方法演示“生产者-消费者”问题 试 测试目的 调节生产者和消费者的速度 说 测试技术 单元测试 明 测试方法 黑盒测试法 测 测试内容 调节生产者和消费者速度 试 测试数据 默认是 1s，生产者速度 2s，消费者速度 3s 用 预期结果 生产者和消费者的速度改变 例 测试结果 与预期相符
//设置取消点 //对缓冲池操作 //解锁 //唤醒消费者 //线程清理处理函数 //设置取消点
usleep(10);
}
} 消费者函数：
void *consumer(void *arg)
{ pthread_detach(pthread_self());
//线程分离
char info[50]="Pool is empty, consumer ";
rear：生产者指针； front：消费者指针； size：产品数； CONSUME_TIME：消费者速度; PRODUCE_TIME ：生产者速度; mutex：对缓冲区互斥操作的锁； empty_cond：缓冲区空的条件变量； full_cond：缓冲区满的条件变量。
2、系统设计： 主程序
3、模块设计： 函数调用关系：
char *value=(char *)malloc(30);
sprintf(value,"%lu",pthread_self());
strcat(info,value);
strcat(info,"is waiting!");
while(1)
{ pthread_testcancel();
//设置取消点
H
否
buffer[rear] = rand()%BUFFER_LENGTH;
rear = rear+1
打印缓冲区状态
是 缓冲区已满，线程阻塞
size = size+1 释放缓冲区
结束
四、系统测试与调试分析
1、系统测试
（1）因为当生产者在缓冲区满了以后自动阻塞，所以生产者阻塞是否正常。
测 测试名称 试 测试目的 说 测试技术 明 测试方法 测 测试内容 试 测试数据 用 预期结果 例 测试结果
用多进程同步方法演示“生产者-消费者”问题 验证生产者阻塞 单元测试 黑盒测试法 添加生产者，当生产者生产满缓冲区后，消费者阻塞。 添加 5 个生产者 缓冲区开始增加产品，产品数达到 20 后 5 个消费者阻塞 与预期相符
（2）因为当生产者在缓冲区满了以后自动阻塞，需要消费者唤醒，所以需要测试 唤醒的实现是否正常。 测 测试名称 用多进程同步方法演示“生产者-消费者”问题 试 测试目的 消费者唤醒生产者 说 测试技术 单元测试 明 测试方法 黑盒测试法 测 测试内容 消费者阻塞时，开始增加消费者,唤醒生产者 试 测试数据 添加 5 个生产者 用 预期结果 消费者消费缓冲区中的产品，从而唤醒生产者 例 测试结果 与预期相符
main()
添加生产者 添加消费者 缓冲池信息 删除生产者 删除消费者 设置生产速度 设置消费速度
操作系统实验三 生产者——消费者问题
操作系统实验三：生产者——消费者问题一、基本信息xxx 711103xx 2012年4月29日二、实验目的通过实验，掌握Windows和Linux环境下互斥锁和信号量的实现方法，加深对临界区问题和进程同步机制的理解，同时巩固利用Windows API和Pthread API进行多线程编程的方法。
三、实验内容1. 在Windows操作系统上，利用Win32 API提供的信号量机制，编写应用程序实现生产者——消费者问题。
2. 在Linux操作系统上，利用Pthread API提供的信号量机制，编写应用程序实现生产者——消费者问题。
3. 两种环境下，生产者和消费者均作为独立线程，并通过empty、full、mutex 三个信号量实现对缓冲进行插入与删除。
4. 通过打印缓冲区中的内容至屏幕，来验证应用程序的正确性。
四、实验步骤1. 创建3个信号量：Mutex、Full、Empty2. 主程序创建10个生产者线程和10个消费者线程，之后休眠一段时间3. 生产者线程中，休息一段2s后，生产一个0~10的随机数放入缓冲区里。
利用信号量Mutex产生对缓冲区使用的互斥功能，利用Empty和Full信号量来对缓冲区进行增加项4. 消费者线程中，休息4s时间后，消费一个缓冲区的数据。
利用信号量Mutex产生对缓冲区使用的互斥功能，利用Empty和Full信号量来对缓冲区进行增加项5. 主程序执行一段时间后，结束整个程序五、主要数据结构及其说明产品数量最大值const int MAX_SIZE = 10;缓冲区：int buffer[BUFFER_SIZE];int front; int rear; bool full;三个互斥信号量：HANDLE Mutex; HANDLE Full; HANDLE Empty;有关操作：用WaitForSingleSignal函数可以获得一个Mutex的所有权，类似于P 操作，而ReleaseMutex函数可以释放一个Mutex的所有权，类似于V 操作。
实验、进程的同步与互斥——生产者消费者
实验、进程的同步与互斥——⽣产者消费者1. 1. 实验⽬的两个或两个以上的进程,不能同时进⼊关于同⼀组共享变量的临界区域,否则可能发⽣与时间有关的错误,这种现象被称作进程互斥。
对CPU的速度和数⽬不做出任何假设的前提下，并发进程互斥访问临界资源，是⼀个较好的解决⽅案。
另外，还需要解决异步环境下的进程同步问题。
所谓异步环境是指：相互合作的⼀组并发进程，其中每⼀个进程都以各⾃独⽴的、不可预知的速度向前推进；但它们⼜需要密切合作，以实现⼀个共同的任务，即彼此“知道”相互的存在和作⽤。
实验⽬的：分析进程争⽤资源的现象，学习解决进程同步与互斥的⽅法。
本实验属于设计型实验，实验者可根据⾃⾝情况选⽤合适的开发环境和程序架构。
1. 2. 实验原理信号量的PV操作与处理相关，P表⽰通过的意思，V表⽰释放的意思。
1962年，狄克斯特拉离开数学中⼼进⼊位于荷兰南部的艾恩德霍芬技术⼤学(Eindhoven Technical University)任数学教授。
在这⾥，他参加了X8计算机的开发，设计与实现了具有多道程序运⾏能⼒的操作系统——THE Multiprogramming System。
THE是艾恩德霍芬技术⼤学的荷兰⽂Tchnische Hoogeschool Eindhov –en的词头缩写。
狄克斯特拉在THE这个系统中所提出的⼀系统⽅法和技术奠定了计算机现代操作系统的基础，尤其是关于多层体系结构，顺序进程之间的同步和互斥机制这样⼀些重要的思想和概念都是狄克斯特拉在THE中⾸先提出并为以后的操作系统如UNIX等所采⽤的。
为了在单处理机的情况下确定进程(process)能否占有处理机，狄克斯特拉将每个进程分为“就绪”(ready)、“运⾏”(running)和“阻塞”(blocking)三个⼯作状态。
由于在任⼀时刻最多只有⼀个进程可以使⽤处理机，正占⽤着处理机的进程称为“运⾏”进程。
当某进程已具备了使⽤处理机的条件，⽽当前⼜没有处理机供其使⽤，则使该进程处于“就绪”状态。
生产者--消费者同步问题的算法实现
{ while(1) { p(pool); p(mutex); pdt.push(*((char*)argv)); cout<<"生产者产生一个数据:"<<*((char*)argv)<<endl; v(mutex); v(iterms); } } //消费者线程 void* coms(void*argv) { char tem; while(1) { p(iterms); p(mutex); tem=pdt.front(); pdt.pop(); cout<<"消费者消耗一个数据："<<tem<<endl;
放消息 取消息
P
经典进程同步问题
一、利用记录型信号量
解决哲学家进餐问题
假设每一位哲学家拿筷子的方法都是：先 拿起左边的筷子，再拿起右边的筷子，则第i 位哲学家的活动可描述为：
20
第i位哲学家的活动可描述为： repeat wait(chopstick[i]); wait(chopstick[i+1] mod 5); …. eat; …. signal(chopstick[i]); signal(chopstick[i+1] mod 5); …. think; until false;
full:=full - 1; if full <0 then block; mutex:=mutex-1; if mutex<0 then block; mutex:=mutex+1; if mutex<=0 then wakeup; empty:=empty+1; if empty<=0 then wakeup;
9
Wait操作不能颠倒！！ P：wait(empty) wait(mutex)
C：wait(full) wait(mutex)
如果颠倒 P：wait(mutex) mutexl.value=0 wait(empty) 如果此时缓冲池满empty=－1，P阻塞 C：wait(mutex) mutex.value=－1， C阻塞 wait(full) P阻塞在empty队列中，等待一个空缓冲 C阻塞在mutex队列中，等待公共缓冲池访问权
6
consumer：//消费者进程 begin repeat wait(full); wait(mutex); nextc:=buffer[out]; out∶=(out+1) mod n; signal(mutex); signal(empty); 消费这件产品; until false; end
操作系统课程设计——生产者消费者问题
计算机与信息学院《操作系统与编译原理联合课程设计报告》专题：操作系统部分学生姓名：学号：专业班级：指导教师：2014 年 7 月一、设计目标多进程/线程编程：生产者-消费者问题。
设置两类进程/线程，一类为生产者，一类为消费者；建立缓冲区的数据结构；随机启动生产者或消费者；显示缓冲区状况；随着进程/线程每次操作缓冲区，更新显示。
二、设计思路1.开发平台：Visual C++6.02.设计思路：若干个生产者和若干个消费者共享一个有界缓冲区，生产者生产产品，消费者消费产品。
消费者进程与生产者进程随机切换。
生产者将产品生产出来后，存放到缓冲区中的空闲位置并将此缓冲区的标识置为满，若此时无空缓冲区，则进行等待。
消费者将标识为满的缓冲区中的产品取出，进行消费并将该缓冲区的标志位置为空，若此时无满的缓冲区，则进行等待。
由于消费者与生产者共享缓冲区资源，且缓冲区资源属于互斥资源，所以生产者和消费者需要按照一定的规则访问缓冲区，访问规则如下：（1）当一个消费者访问缓冲区时其他消费者不允许访问缓冲区，同样的，当一个生产者访问缓冲区时其他生产者也不能访问缓冲区。
（2）当消费者访问缓冲区资源时生产者不能访问，反之，当生产者访问缓冲区资源时消费者不能访问。
（3）当缓冲区中无产品时，消费者不能访问；当缓冲区已满时，生产者不能访问缓冲区。
生产者与消费者问题伪代码如下：VAR mutex, empty, full: semaphore := 1, n, 0 ;in,out: integer := 0, 0 ;Buffer: array [0..n-1] of item ;ParbeginProducer:beginrepeatproduce an item in nextp;wait(empty);wait(mutex);Buffer(in) := nextp;in := (in + 1) mod n;signal(mutex);signal(full);until falseendConsumer:beginrepeatwait(full);wait(mutex);nextc = Buffer(out);out := (out + 1) mod n;signal(mutex);signal(empty);consume the item nextc;until falseendParend程序框架如下图所示：本程序在具体实现方面与MFC结合，将生产者-消费者问题的具体过程动态展示了出来。
操作系统中的经典问题——生产者消费者问题（两种方式实现）
操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）1、问题引⼊：什么是⽣产者消费者问题？⽣产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是⼀个多线程同步问题的经典案例。
该问题描述了共享固定⼤⼩缓冲区的两个线程——即所谓的“⽣产者”和“消费者”——在实际运⾏时会发⽣的问题。
⽣产者的主要作⽤是⽣成⼀定量的数据放到缓冲区中，然后重复此过程。
与此同时，消费者也在缓冲区消耗这些数据。
该问题的关键就是要保证⽣产者不会在缓冲区满时加⼊数据，消费者也不会在缓冲区中空时消耗数据。
.要解决该问题，就必须让⽣产者在缓冲区满时休眠（要么⼲脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，⽣产者才能被唤醒，开始往缓冲区添加数据。
同样，也可以让消费者在缓冲区空时进⼊休眠，等到⽣产者往缓冲区添加数据之后，再唤醒消费者。
通常采⽤进程间通信的⽅法解决该问题。
如果解决⽅法不够完善，则容易出现死锁的情况。
出现死锁时，两个线程都会陷⼊休眠，等待对⽅唤醒⾃⼰。
该问题也能被推⼴到多个⽣产者和消费者的情形。
2、问题分析该问题需要注意的⼏点：1. 在缓冲区为空时，消费者不能再进⾏消费2. 在缓冲区为满时，⽣产者不能再进⾏⽣产3. 在⼀个线程进⾏⽣产或消费时，其余线程不能再进⾏⽣产或消费等操作，即保持线程间的同步4. 注意条件变量与互斥锁的顺序由于前两点原因，因此需要保持线程间的同步，即⼀个线程消费（或⽣产）完，其他线程才能进⾏竞争CPU，获得消费（或⽣产）的机会。
对于这⼀点，可以使⽤条件变量进⾏线程间的同步：⽣产者线程在product之前，需要wait直⾄获取⾃⼰所需的信号量之后，才会进⾏product的操作；同样，对于消费者线程，在consume之前需要wait直到没有线程在访问共享区（缓冲区），再进⾏consume的操作，之后再解锁并唤醒其他可⽤阻塞线程。
生产者—消费者之间设置一个具有n个缓存区的缓冲池,生产者进程将他所生产的产品放
生产者—消费者之间设置一个具有n个缓存区的缓冲池,生产者进程将他所生产的产品
放
生产者到消费者问题是一个著名的进程同步问题。
它描述的是：有一群生产者进程在生产产品，并将这些产品提供给消费者进程去消费。
为使生产者进程与消费者进程能并发执行，在两者之间设置了一个具有n个缓冲区的缓冲池，生产者进程将它所生产的产品放入一个缓冲区中。
消费者进程可从一个缓冲区中取走产品去消费。
尽管所有的生产者进程和消费者进程都是以异步方式运行的，但它们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品且尚未被取走的缓冲区中投放产品。
操作系统之进程(生产者---消费者)实验报告
操作系统实验报告——生产者和消费者问题姓名：学号：班级：一、实验内容1、模拟操作系统中进程同步和互斥；2、实现生产者和消费者问题的算法实现；二、实验目的1、熟悉临界资源、信号量及PV操作的定义与物理意义；2、了解进程通信的方法；3、掌握进程互斥与进程同步的相关知识；4、掌握用信号量机制解决进程之间的同步与互斥问题；5、实现生产者－消费者问题，深刻理解进程同步问题；三、实验题目在Windows操作系统下用C语言实现经典同步问题：生产者—消费者，具体要求如下：(1)一个大小为10的缓冲区，初始状态为空。
(2)2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。
页脚内容1(3)2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。
四、思想本实验的主要目的是模拟操作系统中进程同步和互斥。
在系统进程并发执行异步推进的过程中，由于资源共享和进程间合作而造成进程间相互制约。
进程间的相互制约有两种不同的方式。
（1）间接制约。
这是由于多个进程共享同一资源（如CPU、共享输入/输出设备）而引起的，即共享资源的多个进程因系统协调使用资源而相互制约。
（2）直接制约。
只是由于进程合作中各个进程为完成同一任务而造成的，即并发进程各自的执行结果互为对方的执行条件，从而限制各个进程的执行速度。
生产者和消费者是经典的进程同步问题，在这个问题中，生产者不断的向缓冲区中写入数据，而消费者则从缓冲区中读取数据。
生产者进程和消费者对缓冲区的操作是互斥，即当前只能有一个进程对这个缓冲区进行操作，生产者进入操作缓冲区之前，先要看缓冲区是否已满，如果缓冲区已满，则它必须等待消费者进程将数据取出才能写入数据，同样的，消费者进程从缓冲区读取数据之前，也要判断缓冲区是否为空，如果为空，则必须等待生产者进程写入数据才能读取数据。
在本实验中，进程之间要进行通信来操作同一缓冲区。
操作系统课程设计“生产者-消费者”问题
《操作系统》课程设计题目：“生产者-消费者”问题学院：信息工程学院专业：计算机科学与技术班级：计科1302*名：***指导老师：***2016年1月 15日目录一、课程设计目标 (2)二、课题内容 (2)1．实验目的 (2)2、实验环境 (2)3、实验要求 (2)三、设计思路 (3)1.信号量的设置 (3)2.系统结构 (4)3.程序流程图 (5)4.P V操作代码 (6)四、源代码 (7)五、运行与测试 (10)六、心得体会 (12)一、课程设计目标学习System V的进程间通信机制，使用信号量和共享内存实现经典进程同步问题“生产者-消费者”问题。
具体要求：1.创建信号量集，实现同步互斥信号量。
2.创建共享内存，模拟存放产品的公共缓冲池。
3.创建并发进程，实现进程对共享缓冲池的并发操作。
二、课题内容1．实验目的（1）掌握基本的同步互斥算法，理解生产者和消费者同步的问题模型。
（2）了解linux中多线程的并发执行机制，线程间的同步和互斥。
2、实验环境：C/C++语言编译器3、实验要求（1）创建生产者和消费者线程在linux环境下，创建一个控制台进程，在此进程中创建n个线程来模拟生产者或者消费者。
这些线程的信息由本程序定义的“测试用例文件”中予以指定。
（2）生产和消费的规则在按照上述要求创建线程进行相应的读写操作时，还需要符合以下要求：①共享缓冲区存在空闲空间时，生产者即可使用共享缓冲区。
②从上边的测试数据文件例子可以看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。
此时，只有当所有的消费需求都被满足以后，该产品所在的共享缓冲区才可以被释放，并作为空闲空间允许新的生产者使用。
③每个消费者线程的各个消费需求之间存在先后顺序。
例上述测试用例文件包含一行信息“5 C 3 l 2 4”，可知这代表一个消费者线程，该线程请求消费1，2，4号生产者线程生产的产品。
而这种消费是有严格顺序的，消费1号线程产品的请求得到满足后才能继续往下请求2号生产者线程的产品。
生产者和消费者问题
关于linux中多进程（线程）同步和互斥Linux设备驱动中必须解决的一个问题是多个进程对共享资源的并发访问，并发访问会导致竞态，linux提供了多种解决竞态问题的方式，这些方式适合不同的应用场景。
Linux内核是多进程、多线程的操作系统，它提供了相当完整的内核同步方法。
内核同步方法列表如下：中断屏蔽原子操作自旋锁读写自旋锁顺序锁信号量读写信号量BKL（大内核锁）Seq锁一、并发与竞态：定义：并发（concurrency）指的是多个执行单元同时、并行被执行，而并发的执行单元对共享资源（硬件资源和软件上的全局变量、静态变量等）的访问则很容易导致竞态（race conditions）。
在linux中，主要的竞态发生在如下几种情况：1、对称多处理器（SMP）多个CPU特点是多个CPU使用共同的系统总线，因此可访问共同的外设和存储器。
2、单CPU内进程与抢占它的进程3、中断（硬中断、软中断、Tasklet、底半部）与进程之间只要并发的多个执行单元存在对共享资源的访问，竞态就有可能发生。
如果中断处理程序访问进程正在访问的资源，则竞态也会会发生。
多个中断之间本身也可能引起并发而导致竞态（中断被更高优先级的中断打断）。
解决竞态问题的途径是保证对共享资源的互斥访问，所谓互斥访问就是指一个执行单元在访问共享资源的时候，其他的执行单元都被禁止访问。
访问共享资源的代码区域被称为临界区，临界区需要以某种互斥机制加以保护，中断屏蔽，原子操作，自旋锁，和信号量都是linux设备驱动中可采用的互斥途径。
临界区和竞争条件：所谓临界区（critical regions）就是访问和操作共享数据的代码段，为了避免在临界区中并发访问，编程者必须保证这些代码原子地执行——也就是说，代码在执行结束前不可被打断，就如同整个临界区是一个不可分割的指令一样，如果两个执行线程有可能处于同一个临界区中，那么就是程序包含一个bug，如果这种情况发生了，我们就称之为竞争条件（race conditions），避免并发和防止竞争条件被称为同步。