生产者-消费者问题
从一个实际的问题：生产者和消费者出发，谈一谈为什么需要信号量？信号量用来做什么？
问题描述：现在存在一个文件"buffer.txt"作为一个共享缓存区，缓冲区同时最多只能保存10个数。现在一个生产者进程，依次向缓冲区写入整数0,1,2，....，M, M>=500;有N个消费者进程，消费者进程从缓冲区读数，每次读一个，并将读出的数从缓冲区删除。
为什么需要信号量？
对于生产者来说，当缓冲区满，也就是空闲缓冲区个数为0时，此时生产者不能继续向缓冲区写数，必须等待，直到有消费者从满缓冲区取走数后，再次有了空闲缓冲区，生产者才能向缓冲区写数。
对于消费者来说，当缓冲区空时，此时没有数可以被取走，消费者必须等待，直到有生产者向缓冲区写数后，消费者才能取走。并且如果当缓冲区空时，先后有多个消费者均想从缓冲区取数，那么它们均需要等待，此时需要记录下等待的消费者个数，以便缓冲区有数可取后，能将所有等待的消费者唤醒，确保请求取数的消费者最终都能取的数。
也就是说，当多个进程需要协同合作时，需要根据某个信号，判断当前进程是否需要停下来等待；同时，其他进程需要根据这个信息判断是否有进程在等待，或者有几个进程在等待，以决定是否需要唤醒等待的进程。而这个信息，就是信号量。
信号量来做什么？
设有一整形变量sem，作为一个信号量。此时缓冲区为空，sem=0。
1，消费者C1请求从缓冲区取数，不能取到，睡眠等待。sem=-1<0，表示有一个进程因缺资源而等待。
2，消费者C2也请求缓冲区取数，睡眠等待。sem=-2<0，表示有两个进程因缺资源而等待。
3，生产者P往缓冲区写入一个数，sem=sem+1=-1<=0，并唤醒等待队列的头进程C1，C1处于就绪，C2仍处于睡眠等待。
4，生产者P继续往缓冲区写入一个数，sem=0<=0，并唤醒C2，C1，C2就处于就绪状态。
由此可见，通过判断sem的值以及改变sem的值，就保证了多进程合作的合理有序的推进，这就是信号量的作用。
实现信号量
信号量有什么组成？
1，需要有一个整形变量value，用作进程同步
2，需要有一个PCB指针，指向睡眠的进程队列
3，需要有个名字来表示这个结构的信号量。
同时，由于该value的值是所有进程都可以看到和访问的共享变量，所以必须在内核中定义；同时，这个名字的信号量也是可供所有进程访问的，必须在内核中定义；同时，又要操作内核中的数据结构；进程控制块PCB，所以信号量一定要在内核中定义，而且必须是全局变量。由于信号量要定义在内核中，所以和信号量相关的操作函数必须做成系统调用，还是那句话：系统调用是应用程序访问内核的唯一方法。
和信号量相关的函数？
Linux在0.11版还没有实现信号量，我们可以先弄一套缩水版的类POSIX信号量，它的函数原型和标准并不完全相同，而且只包含如下系统调用：
sem_t *sem_open(const char *name, unsigned int value);
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);
int sem_unlink(const char *name);
sem_t是信号量类型，根据实现的需要自己定义。信号量保护？
使用信号量还需要注意一个问题，这个问题是由于多进程的调用引起的。当一个进程正在修改信号量的值时，由于时间片耗完，引发调度，该修改信号量的进程被切换出去，而得到CPU使用权的新进程也开始修改此信号量，那么该信号量的值很有可能发生错误，如果信号量的值发错了，那么进程的同步也会出错。所以在执行修改信号量的代码时，必须加以保护，保证正在修改过程中其他进程不能修改同一个信号量的值。也就是说，当一个进程在修改信号量时，由于某种原因引发调度，该进程被切换出去，新的进程如果也想修改信号量，是不能操作的，必须等待，直到原来修改该信号量的进程完成修改，其他进程才能修改此信号量。信号量的代码一次只允许一个进程执行，这样的代码称为临界区，所以信号量的保护，又称临界区的保护。
实现临界区的保护有几种不同的方法，在Linux 0.11上比较简单的方法是通过开，关中断来阻止时钟中断，从而避免时间片耗完引发的调度，来实现信号量的保护。但是开关中断的方法，只适合单CPU的情况，对于多CPU的情况，不适合。Linux 0.11就是单CPU，可以使用这种方法。
对信号量的保护
//生产者
Producer(item)
{
P(empty);//生产者先判断 缓存区个数 empty是否满了，empty == 0，阻塞
...
}
//生产者P1
register = empty;
register = register - 1;
empty = register;
//生产者P2
register = empty;
register = register - 1;
empty = register;
//初始情况
empty = -1; //空闲缓冲区的个数，-1表示有一个进程在睡眠
//一个可能的执行（调度）
P1.register = empty; // P1.register = -1
P1.register = P1.register - 1; // P1.register = -2
P2.register = empty; // P2.register = -1;
P2.register = P2.register - 1; // P2.register = -2
empty = P1.register; // empty = -2
empty = P2.register; // empty = -2如果正确执行，empty初始值为-1，P1执行完，empty=-2，P2执行完，empty=-3
上边的例子，empty=-2，所以信号量empty需要保护。
竞争条件：和调度有关的共享数据语义错误，错误是有多个进程并发操作共享数据引起的，错误和调度顺序有关，很难发现和调试，需要加保护，保证调度的正确执行，有的程序会增加空循环，减少调度的错误概率，但是不会根本解决调度问题。
解决竞争：在写共享变量empty时，给empty上锁，阻止其他进程访问empty，受保护的代码段一次只允许一个进程进入，不能被分割的代码段称为原子操作。
//仍然是上边出错的执行序列
P1.register = empty;
P1.register = P1.register - 1;
P2.register = empty;
P2.register = P2.register - 1;
empty = P1.register;
empty = P2.register;
//执行过程
//P1检查并给empty上锁
P1.register = empty;
P1.register = P1.register - 1;
//P2 检查empty的锁，P2不能执行
//P1继续执行
empty = P1.register;
//P1给empty开锁
//P2检查并给empty上锁，下边三句是原子操作，不能分割
P2.register = empty;
P2.register = P2.register - 1;
empty = P2.register;
//给empty开锁临界区
临界区：一次只允许一个进程进入的那一段代码（修改信号量的代码就是临界区），P1，P2中修改empty的代码，就是临界区。
//进程的代码结构
剩余区
进入区
临界区
退出区
剩余区临界区代码的保护原则：
基本原则：
互斥进入：如果一个进程在临界区中执行，其他进程不允许进入。进程间是互斥关系
有空让进：若干进程要求进入空闲临界区时，要尽快使一个进程进入临界区
有限等待：从进程发出进入请求到允许，不能无限等待
进入临界区的尝试：
轮换法：
//进程P0
//turn !=0,P0空转
while(turn != 0)
;
//turn = 0，P0进入临界区
临界区
turn = 1;//处理完临界区，置turn = 1
剩余区
//进程P1
//turn != 1,P1 空转
while(turn != 1)
;
//turn = 1，P1进入临界区
临界区
turn = 0;//执行完临界区，置turn = 0
剩余区互斥：
P0进入临界区的条件turn=0
P1进入临界区的条件turn=1
问题：turn=1，P1可以进入临界区，但是P1被阻塞了，P1没操作临界区，P0不能执行临界区
进入临界区的尝试（例子）：
冰箱是共享资源，目的是冰箱中一个牛奶
上边的轮换法类似于值日，1天中丈夫和妻子只有1个人买牛奶，要防止重复购买，丈夫和妻子要交流，谁去买牛奶，留一个便条
if(noMilk)
{
if(noNote)
{
leave Note;
buy milk;
remove note;
}
}设置临界区
//进程P0
//P0要进临界区，打个标记，flag[0] = true
flag[0] = true;
//判断P1的flag，如果flag[1] = true,说明P1在操作临界区，P0空转等待
while(flag[1])
;
操作临界区; //flag[1] = false,P0可以操作进阶区
flag[0] = false; //操作完，将flag[0]置为false
剩余区
//进程P1
//P1要进临界区，打标记 置flag[1] = true
flag[1] = true;
while(flag[0])//判断P0的标记，flag[0] = true,说明P0在操作临界区，P1空转等待
;
操作临界区; // flag[0] = false,P1可以操作临界区
flag[1] = false;//操作完，置flag[1] = false
剩余区问题：
P0进入临界区的条件是flag[0] = true, flag[1] = false
P1进入临界区的条件是flag[0] = false, flag[1] = true
满足互斥要求，但是能不能保证临界区空闲时，可以有进程来执行呢？
// 进程P0
flag[0] = true;
//进程P1
flag[1] = true;
//进程P0，空转
while(flag[1])
;
//进程P1，空转
while(flag[0])
;flag[0] = true, flag[1] = true，临界区空闲，P0，P1的请求无限等待
买牛奶的例子：
丈夫要买牛奶，看到 妻子留了便条；
妻子要买牛奶，看到 丈夫留了便条；
最后谁都没买，冰箱中没有牛奶
非对称标记法：
带名字的便条+让一个人更加勤劳
关键：选择一个进程进入，另一个进程循环等待
//丈夫（A）
leave note A;
while(note B)
{
do nothing;
}
if(noMilk)
{
buy milk;
}
remove note A;
//妻子（B）
leave note B;
if(noNote A)
{
if(noMilk)
{
buy milk;
}
}
remove note B;进入临界区的尝试——Peterson算法
结合了 标记 和 轮转 两种思想
//进程P0
//P0执行，只 flag[0] = true,turn = 1
flag[0] = true;
turn = 1;
//判断flag[1] 和 turn，如果flag[1] = true && turn == 1,空转
while(flag[1] && turn == 1)
;
临界区; //如果flag[1] = false || turn == 0,进入临界区执行
flag[0] = false;//执行完，置flag[0] = false
剩余区;
//进程P1
//P1执行，置flag[1] = true,turn = 0
flag[1] = true;
turn = 0;
// 如果 flag[0] == true,turn == 0,P1空转
while(flag[0] && turn == 0)
;
临界区;// 如果 flag[0] == flase || turn == 1,P1进入临界区执行
flag[1] = false;// 执行完，置flag[1] = false
剩余区;Peterson算法的正确性
满足互斥条件：
P0进入临界区的条件：flag[0] = true, flag[1] = false || turn == 0
P1进入临界区的条件：flag[1] = true, flag[0] = false || turn == 1
P0 P1同时进入临界区，flag[0] = flag[1] = true, turn == 0 == 1
满足有空让进：
比如临界区空闲，P1阻塞，且不在临界区，则flag[1] == false || turn == 0 ,P0是可以执行的
满足有限等待：
比如P0要进入临界区，P0执行while阻塞了，此时flag[0] = true，只要P1执行一次，turn = 0， P0就可以进入临界区了
面包店算法（解决多进程情况）
仍是 标记 和 轮转 的结合
如何轮转：每个进程都有一个序号，序号最小的进入
如何标记：进程离开时序号为0，不为0的序号即标记
面包店：每个进入商店的客户都获得一个号码，号码最小的先得到服务，号码相同时，名字靠前的先服务
//每个进程有一个号（num[i]）一个标记（choosing[i]），num[i]!=0表示要进入临界区，取号最小的进入
//进程i执行
choosing[i] = true; // 保证只有一个进程在选号
num[i] = max(num[0], ..., num[n-1]) + 1; // num[i]是已有号码的最大值 + 1
choosing[i] = false; //取号结束，置 choosing[i] = false
// 遍历所有进程
for(j = 0; j < n; j++)
{
//别的进程在选号，空转
while(choosing[j])
;
// num[j] != 0表示进程j要进入临界区，j < i，进程i空转等待
while((num[j] != 0) && (num[j], j) < (num[i], i))
;
}
临界区
num[i] = 0;
剩余区正确性分析：
互斥进入：
设Pi在临界区，Pk试图进入，一定要(num[i],i)<(num[k],k) Pk循环等待
有空让进：
如果没有进程在临界区，最小序号的进程可以进入
有限等待：
离开临界区的进程 想再次进入 一定排在最后(FIFO)，所以一个进程最多等n个进程
弊端：实现很复杂，一直往后取号，可能会溢出
硬件原子指令法
软件实现很复杂，希望通过硬件解决
一个进程在操作临界区，另一个进程请求进入临界区，一定发生了调度，能不能阻止这种调度
调度一定有中断，调度时 会调用schedule
//进程Pi
cli(); //关中断
临界区
sti();//开中断
剩余区该方法适用于单CPU情况，Linux 0.11是单核的；多CPU是不适合
单CPU情况：
中断是在CPU上有一个中断寄存器INTR，发生中断，寄存器打个1，CPU每执行完一个指令(指令是汇编指令，C语言的是语句)，看INTR是否是1，如果是1，就进入中断处理程序
一旦设置了cli()，指令执行完，就不判断INTR了
多CPU时不适用：
多CPU时，执行中断，每个CPU对应的INTR都置1
假设临界区在CPU1上，P1在执行，设置了cli()，CPU1上再有中断，就不调度了，CPU1上的临界区可以一直执行，设CPU2在执行P2，设置了cli()，就不判断中断，P2也执行
此时P1 P2就都在执行临界区了
临界区保护的硬件指令原子指令法：
我们的想法是 执行临界区之前上锁，然后执行临界区，执行完开锁
计算机中的锁是一个变量，上锁 开锁 就是给变量赋值
比如用 信号量 mutex 表示锁，metux = 1 表示有1个资源，0 表示没有资源
锁不能用信号量实现 用信号量表示锁，信号量是一个锁，修改信号量需要保护 即 修改信号量这个锁 还需要个锁
锁由硬件实现保护，临界区不能被打断 是原子指令，硬件原子指令 使锁 上锁 开锁 不被打断
// TestAndSet是操作锁的，不能被打断
boolean TestAndSet(boolean &x)
{
//该函数代码 一次执行完毕
boolean rv = x;
x = true;
return rv;
}
//进程Pi
// lock = true 表示上锁，TestAndSet返回true，如果锁上了，Pi就空转
while(TestAndSet(&lock))
;
临界区; // 没上锁，进入临界区执行
lock = false; // 执行完临界区，解锁
剩余区满足互斥要求：当lock=false，进程1判断TestAndSet返回false，执行临界区，其他进程此时申请临界区，判断TestAndSet返回true 不能执行，进程1执行完 临界区，释放锁。