16.进程同步与死锁——进程同步与信号量

1.进程合作：多进程共同完成一个任务

1.1 司机与售票员

// 司机
while(true)
{
//等待售票员关门的信号
启动车辆;
正常运行;
到站停车;
}

//售票员
while(true)
{
关门;
售票;
//等待司机到站停车的信号
开门;
}

1.2 打印机

打印机按照打印队列执行打印，当打印队列中有 6个打印任务，2个进程同时添加打印任务，打印队列的第7个任务是哪个，需要协调

小结

进程有自己的执行条件，有时执行 有时等待，执行完 可能也要 发出信号，让等待该信号的其他进程执行

进程同步 就是 进程有序的执行

1.3 生产者—消费者实例

//共享数据
#define BUFFER_SIZE 10 //缓存空间
typedef struct{...} item;
item buffer[BUFFER_SIZE];
int in = out = counter = 0;

//生产者进程
while(true){
//当产品 counter == BUFFER_SIZE 就不再生产了,缓存区满，生产者停
while(counter == BUFFER_SIZE)
;
//产品没达到 BUFFER_SIZE，继续生产
buffer[in] = item;
in = (in + 1) % BUFFER_SIZE;
counter++;//生产者不断生产，发信号让消费者走
}

//消费者进程
while(true){
//缓冲区空，消费者停
while(counter == 0)
;
item = buffer[out];
out = (out + 1) % BUFFER_SIZE;
counter--;//消费者不断消耗，发信号让生产者走
}

多进程配合，需要等待 阻塞

通过 进程的走走停停 来保证 多进程合作的 合理有序

等待是进程同步的核心

1.3.1 发信号存在的问题

//生产者
while(true){
//当 counter == BUFFER_SIZE，生产者 sleep，不再生产
if(counter == BUFFER_SIZE)
sleep();
...
counter++;
//当生产者发现 counter == 1，又有产品了，唤醒消费者
if(counter == 1)
wakeup(消费者);
}

//消费者
while(true){
//当消费者发现 counter == 0，进入sleep，不再消费
if(counter == 0)
sleep();
...
counter--;
//当消费者发现 counter == BUFFER_SIZE - 1，就可以生产了，唤醒生产者
if(counter == BUFFER_SIZE - 1)
wakeup(生产者);
}

问题：

有多个生产者，P1生产一个item，放入缓冲区，缓冲区满了，P1 sleep

这时，P1 生产一个item，发现缓冲区已经满了，P1 sleep

消费者消耗了一个产品，counter == BUFFER_SIZE - 1，给消费者发信号，唤醒P1，P1 wakeup

消费者再消耗一个产品，counter == BUFFER_SIZE - 2，P2 不能被唤醒了

解决：

单纯依靠counter判断缓冲区的个数是不够的，还要知道有多少进程睡眠了

2.信号量

2.1 引出信号量

根据信号量 判断是否等待，是否执行

信号量 int sem：

0 或者 负数，说明需要等待，让其他进程执行

0 ：没有资源了

负数：欠资源了

正数：资源个数

举例：一种资源的数量是8

信号量 = 2：有2个资源可以使用

信号量 = -2，有2个进程在等待资源

上边生产者消费者的例子：

1.缓冲区满，P1执行，P1 sleep，sem = -1，表示一个进程睡眠了

2.P2执行，发现缓冲区满，P2 sleep，sem = -2，表示2个进程睡眠了

3.消费者C执行，wakeup P1，sem = -1

4.消费者C再执行一次，wakeup P2，sem = 0

5.消费者C再执行一次，sem = 1，消费者进程睡眠

6.P3执行，sem = 0，表示没有资源了

2.2 信号量的定义

信号量： 1965年，荷兰学者Dijkstra提出用一种特殊整型变量用来记录，信号用来sleep和wakeup

// semaphore ['seməfɔː] n. 信号
struct semaphore
{
int value;//资源个数
PCB *queue;//等待该信号量的进程
}

//消费资源,P来自荷兰语 proberen，即test
P(semaphore s);

//生产资源，V来自荷兰语 verhogen，即increment
V(semaphore s);

P(semaphore s)
{
s.value--;
if(s.value < 0){
sleep(s.queue);
}
}

V(semaphore s)
{
s.value++;
if(s.value <= 0)
{
wakeup(s.queue);
}
}

2.3 用信号量解决生产者-消费者问题

缓存文件 buffer.txt，操作该缓存文件

同时只能有一个进程在写该文件，定义互斥信号量mutex（互斥量）

当有进程在操作缓冲区内容时，P(mutex)，造成进程等待

使用完 缓冲区文件，调用V(mutex)，释放该文件资源，其他进程可以操作缓冲文件了

//用文件定义 共享缓冲区
int fd = open("buffer.txt");
write(fd, 0, sizeof(int));//写in
write(fd, 0, sizeof(int));//写out

//信号量的定义和初始化
semaphore full = 0;//生产的产品的个数
semaphore empty = BUFFER_SIZE;//空闲缓冲区的个数
semaphore mutex = 1;//互斥信号量

//生产者
Producer(item)
{
P(empty);//生产者先判断 缓存区个数 empty是否满了，empty == 0，阻塞
P(mutex);//操作文件前，用mutex防止其他进程操作该文件
读入in，将item写到in的位置上
V(mutex);//使用完文件，释放文件资源
V(full);//生产者生产产品，增加full，消费者就可以消费了
}

//消费者
Consumer()
{
P(full);//当full == 0,缓冲区空了，阻塞
P(mutex);
读入out，从文件中的out位置读出到item，打印item;
V(mutex);
V(empty);//消费者消耗产品，增加缓冲区个数，增加empty，生产者就可以继续生产了
}