---

🐌个人主页： 🐌 叶落闲庭
💨我的专栏：💨
c语言
数据结构
javaEE
操作系统
Redis

石可破也，而不可夺坚；丹可磨也，而不可夺赤。

---

一、信号量机制

用户进程可以通过使用操作系统提供的一对原语来对信号量进行操作，从而很方便的实现了进程互斥、进程同步。
信号量其实就是一个变量（可以是一个整数，也可以是更复杂的记录型变量），可以用一个信号量来表示系统中某种资源的数量，比如：系统中只有一台打印机，就可以设置一个初值为1的信号量。
原语是一种特殊的程序段，其执行只能一气呵成，不可被中断。原语是由关中断/开中断指令实现的。软件解决方案的主要问题是由“进入区的各种操作无法一气呵成”，因此如果能把进入区、退出区的操作都用“原语”实现，使这些操作能“一气呵成”就能避免问题。
一对原语：wait(S)原语和signal(S)原语，可以把原语理解为我们自己写的函数，函数名分别为wait和signal,.括号里的信号量S其实就是函数调用时传入的一个参数。
wait、signal原语常简称为P、V操作（来自荷兰语proberen和verhogen)。因此，做题的时候常把wait(S)、signal(s)两个操作分别写为P(S)、V(S)【这是狄克斯特拉用荷兰文定义的，因为在荷兰文中，通过叫passeren，释放叫vrijgeven，PV操作因此得名。这是在计算机术语中不是用英语表达的极少数的例子之一。】

1.1 整型信号量

用一个整数型的变量作为信号量，用来表示系统中某种资源的数量（与普通整数变量的区别：对信号量的操作只有三种，即初始化、P操作、V操作）
Eg:某计算机系统中有一台打印机.…

int S = 1;			//初始化整型信号量$，表示当前系统中可用的打印机资源数

void wait(int S) {	//wait原语，相当于“进入区”
	while(S <= 0);	//如果资源数不够，就一直循环等待
	S = S - 1;		//如果资源数够，就占用一个资源
}

void signal (int S) {	//signal原语，相当于“退出区”
	S = S + 1;			//使用完资源后，在退出区释放资源
}

进程P0：
...
wait(S);	//进入区，申请资源
使用资源		//临界区，访问资源
sinal(S);	//退出区，释放资源
...

进程P0在使用资源之前，必须要先进行一个wait原语，对信号量S进行操作，如果当前资源已不够用，整型信号量S就是小于0的，此时P0就需要一直循环等待，若是P0进程执行wait时S大于0，就说明资源够用，此时资源的数量就要减一，此时P0就可以访问资源，在P0访问资源的同时，若是发生了进程切换，其他进程则需要等待P0释放资源才能访问，P0访问资源结束后，会进行signal原语，将整型信号量的值进行加一，也就是释放资源。

---

“检查”和“上锁”一气呵成避免了并发、异步导致的问题
【存在的问题：不满足“让权等待”原则，会发生“忙等】

1.2 记录型信号量

整型信号量的缺陷是存在“忙等”问题，因此人们又提出了“记录型信号量”，即用记录型数据结构表示的信号量。

/*记录型信号量的定义*/
typedef struct {
	int value;			//剩余资源数
	struct process *L;	//等待队列
}semaphore;

/*某进程需要使用资源时，通过wait原语申请*/
void wait(semaphore S) {
	S.value--;
	if (S.value < 0) {
		block(S.L);
	}
}

如果剩余资源数不够使用block原语使进程从运行态进入阻塞态，并把挂到信号量S的等待队列（即阻塞队列）中。

/*进程使用完资源后，通过signal原语释放*/
void signal (semaphore S) {
	s.value++;
	if (S.value <= 0) {
		weakup(S.L);
	}
}

释放资源后，若还有别的进程在等待这种资源，则使用wakeup原语唤醒等待队列中的一个进程，该进程从阻塞态变为就绪态。

---

S.value的初值表示系统中某种资源的数目。
对信号量S的一次P操作意味着进程请求一个单位的该类资源，因此需要执行S.vaue-,表示资源数减1，当S.value<0时表示该类资源己分配完毕，因此进程应调用bock原语进行自我阻塞（当前运行的进程从运行态→阻塞态)，主动放弃处理机，并插入该类资源的等待队列SL中。可见，该机制遵循了“让权等待”原则，不会出现“忙等”现象。
对信号量S的一次V操作意味着进程释放一个单位的该类资源，因此需要执行S.vaue++,表示资源数加1，若加1后仍是S.value<=0,表示依然有进程在等待该类资源，因此应调用wakeup原语唤醒等待队列中的第个进程（被唤醒进程从阻塞态→就绪态）

二、用信号量实现进程互斥、同步、前驱关系

2.1 实现进程互斥

/*记录型信号量的定义*/
typedef struct {
	int value;			//剩余资源数
	struct process *L;	//等待队列
}semaphore;

/*信号量机制实现互斥*/
semaphore mutex = 1;	//初始化信号量
P1() {
	...
	P(mutex);			//使用临界资源前需要加锁
	临界区代码段
	V(mutex);			//使用临界资源后需要解锁
}

P2() {
	...
	P(mutex);			//使用临界资源前需要加锁
	临界区代码段
	V(mutex);			//使用临界资源后需要解锁
}

• 分析并发进程的关键活动，划定临界区（如：对临界资源打印机的访问就应放在临界区)

• 设置互斥信号量mutex,初值为1（理解：信号量mutex表示进入临界区的名额）

• 在进入区P(mutex)一一申请资源

• 在退出区V(mutex)一一释放资源

• 注意：对不同的临界资源需要设置不同的互斥信号量。

• P、V操作必须成对出现。缺少P(mutex)就不能保证临界资源的互斥访问。缺少V(mutex)会导致资源永不被释放，等待进程永不被唤醒。

2.2 实现进程同步

进程同步：要让各并发进程按要求有序地推进。
比如，P1、P2并发执行，由于存在异步性，因此二者交替推进的次序是不确定的。
若P2的“代码4”要基于P1的“代码1”和“代码2”的运行结果才能执行，那么我们就必须保证“代码4”一定是在“代码2”之后才会执行。
这就是进程同步问题，让本来异步并发的进程互相配合，有序推进。

/*信号量机制实现同步*/
semaphore S = 0;	//初始化同步信号量，初始值为0

P1() {
	代码1;
	代码2;
	V(S);
	代码3;
}

P2() {
	P(S);
	代码4;
	代码5;
	代码6;
}

若先执行到V(S)操作，则S++后S=1。之后当执行到P(S)操作时，由于S=1,表示有可用资源，会执行S-,S的值变回0，P2进程不会执行block原语，而是继续往下执行代码4。

---

若先执行到P(S)操作，由于S=0,S-后S=-1,表示此时没有可用资源，因此P操作中会执行block原语，主动请求阻塞之后当执行完代码2，继而执行V(S)操作，S+,使S变回0，由于此时有进程在该信号量对应的阻塞队列中，因此会在V操作中执行wakeup原语，唤醒P2进程。这样P2就可以继续执行代码4了（理解：信号量S代表“某种资源”，刚开始是没有这种资源的。P2需要使用这种资源，而又只能由P1产生这种资源）

2.3 实现进程的前驱关系

进程P1中有句代码S1,P2中有句代码S2,P3中有句代码S3.P6中有句代码S6。这些代码要求按如下前驱图所示的顺序来执行：

---

---

其实每一对前驱关系都是一个进程同步问题（需要保证一前一后的操作)
因此:

• 要为每一对前驱关系各设置一个同步信号量
• 在“前操作”之后对相应的同步信号量执行 V 操作
• 在“后操作”之前对相应的同步信号量执行 P 操作

P1() {
	...
	S1;
	V(a);
	V(b);
	...
}

P2() {
	...
	P(a);
	S2;
	V(c);
	V(d);
	...
}

P3() {
	...
	P(b);
	S3;
	V(g);
	...
}

P4() {
	...
	P(c);
	S4;
	V(e);
	...
}

P5() {
	...
	P(d);
	S5;
	V(f);
	...
}

P4() {
	...
	P(e);
	P(f);
	P(g);
	S6;
	...
}

---