信号量

信号量机制可用来解决互斥与同步的问题，它只能被两个标准的原语wait(S)和signal(S)来访问，也可以记为“P操作”和“V操作”。

原语是指完成某种功能且不被分割不被中断执行的操作序列，通常可由硬件来实现完成。原语之所以不能被中断执行，是因为原语对变量的操作过程如果被打断，可能会去运行另一个对同一变量的操作过程，从而出现临界段问题。

整型信号量

整型信号量被定义为一个用于表示资源数目的整型量S，wait和signal操作可描述为：

1. wait(S){
2. while (S<=0);
3. S=S-1;
4. }
5. signal(S){
6. S=S+1;
7. }

wait操作中，只要信号量S<=0，就会不断地测试。

记录型信号量

记录型信号量除了需要一个用于代表资源数目的整型变量value外，再增加一个进程链表L，用于链接所有等待该资源的进程，记录型信号量是由于釆用了记录型的数据结构得名。记录型信号量可描述为：

1. typedef struct{
2. int value;
3. struct process *L;
4. } semaphore;

相应的wait(S)和signal(S)的操作如下：

1. void wait (semaphore S) { //相当于申请资源
2. S.value--;
3. if(S.value<0) {
4. add this process to S.L;
5. block(S.L);
6. }
7. }

wait操作，S.value--，表示进程请求一个该类资源，当S.value<0时，表示该类资源已分配完毕，因此进程应调用block原语，进行自我阻塞，放弃处理机，并插入到该类资源的等待队列S.L中，可见该机制遵循了“让权等待”的准则。

1. void signal (semaphore S) { //相当于释放资源
2. S.value++;
3. if(S.value<=0){
4. remove a process P from S.L;
5. wakeup(P);
6. }
7. }

signal操作，表示进程释放一个资源，使系统中可供分配的该类资源数增1，故S.value++。若加1后仍是S.value<=0，则表示在S.L中仍有等待该资源的进程被阻塞，故还应调用wakeup原语，将S.L中的第一个等待进程唤醒。

利用信号量实现同步

信号量机制能用于解决进程间各种同步问题。设S为实现进程P1、P2同步的公共信号量，初值为0。进程P2中的语句y要使用进程P1中语句x的运行结果，所以只有当语句x执行完成之后语句y才可以执行。其实现进程同步的算法如下：

1. semaphore S = 0; //初始化信号量
2. P1 ( ) {
3. // …
4. x; //语句x
5. V(S); //告诉进程P2,语句乂已经完成
6. }
7. P2()）{
8. // …
9. P(S) ; //检查语句x是否运行完成
10. y; // 检查无误，运行y语句
11. // …
12. }

利用信号量实现进程互斥

信号量机制也能很方便地解决进程互斥问题。设S为实现进程P1、P2互斥的信号量，由于每次只允许一个进程进入临界区，所以S的初值应为1（即可用资源数为1)。只需把临界区置于P(S)和V(S)之间，即可实现两进程对临界资源的互斥访问。其算法如下：

1. semaphore S = 1; //初化信号量
2. P1 ( ) {
3. // …
4. P(S); // 准备开始访问临界资源，加锁
5. // 进程P1的临界区
6. V(S); // 访问结束，解锁
7. // …
8. }
9. P2() {
10. // …
11. P(S); //准备开始访问临界资源，加锁
12. // 进程P2的临界区；
13. V(S); // 访问结束，解锁
14. // …
15. }

互斥的实现是不同进程对同一信号量进行P、V操作，一个进程在成功地对信号量执行了P操作后进入临界区，并在退出临界区后，由该进程本身对该信号量执行V操作,表示当前没有进程进入临界区，可以让其他进程进入。