进程并发编程基础
前言：看了操作系统并发编程的基础，做个笔记并用 C 实现常见的一种并发编程的模型——消费者、生产者模型
进程之间的关系
第一种是竞争关系
系统中的多个进程之间彼此无关，它们并不知道其他进程的存在，并且也不受其他进程执行的影响。因而， 必然要出现多个进程竞争资源的问题。当多个进程竞争共享硬设备、存储器、处理器 和文件等资源时，操作系统必须协调好进程对资源的争用。
进程的互斥（mutual exclusion ）是解决进程间竞争关系（间接制约关系）的手段。 进程互斥指若干个进程要使用同一共享资源时，任何时刻最多允许一个进程去使用，其他要使用该资源的进程必须等待，直到占有资源的进程释放该资源。
第二种是协作关系
某些进程为完成同一任务需要分工协作，由于合作的每一个进程都是独立地以不可预知的速度推进，这就需要相互协作的进程在某些协调点上协 调各自的工作。
进程的同步（Synchronization）是解决进程间协作关系（直接制约关系）的手段。进程同步指两个以上进程基于某个条件来协调它们的活动。一个进程的执行依赖于另一个协作进程的消息或信号，当一个进程没有得到来自于另一个进程的消息或信号时则需等待，直到消息或信号到达才被唤醒。
不难看出，进程互斥关系是一种特殊的进程同步关系，即逐次使用互斥共享资源，也是对进程使用资源次序上的一种协调。
如何实现互斥
无论是竞争还是协作，都必须实现互斥。
而实现互斥的关键在于：进程 A 正在使用的临界资源，哪怕在使用的过程中被中断了，其他进程的临界区都不能动进程 A 的资源。
硬件方式实现互斥
用硬件的方式增加一条汇编指令，比如 TestAndSet
伪代码如下
// 主程序
global lock = false
repeate {nothing} until TestAndSet(&lock)
// 临界区代码
// do someting
// 临界区结束
lock = false
这里的 TestAndSet 使用汇编指令实现的，也就是他不能被中断。lock 是全局变量，所有的进程都能访问到
实现的功能就是：检查 lock 是否是 false，如果是 false 就把 lock 设为 true。如果 lock 是 false。就不会执行repeate {nothing}。
有的进程执行的时候，lock 是 true。就会一直执行 repeate {nothing}，直到 CPU 时间片结束，结束调用。这样就实现了互斥。
但是，这样有一个很大的缺点就是忙等，我们不想要忙等，我们想要 lock = true 的时候进程被阻塞，然后等待调用
用信号量（semaphore）实现互斥 重点！
semaphore 最重要的是两个函数：
-
wait(semaphore* s)
-
signal(semaphore* s)
这是系统给的原语。原语和其他函数最大的区别就是：它虽然也是一系列指令构成，但是在执行的过程中不可中断
wait 和 signal 的伪代码如下：
wait(semaphore* s) {
if(s.count-- < 0) {
// 阻塞
}
}
signal(semaphore* s) {
if(s.count++ <= 0) {
// 调用某个被阻塞的进程
call();
}
}
那怎么用这两个函数实现互斥呢？我们在访问临界资源的时候会先执行 wait 函数如果 (s.count-- < 0)。则被阻塞，而不是忙等。否则就执行临界区代码（资源够用，不需要阻塞）。
而执行完临界区以后，会执行 signal 函数。如果 (s.count++ <= 0) 。则去唤醒一个被阻塞的函数，否则啥也不做，仅仅加一（没有被阻塞的进程）。
通过一个实例来理解这一个过程
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <unistd.h>
sem_t s;
int main(int argc, char const *argv[])
{
int value = 0;
sem_init(&s, 0, 10);
sem_getvalue(&s, &value);
printf("initialization s.count = %d\n", value);
// wait
sem_wait(&s);
sem_getvalue(&s, &value);
printf("after wait s.count = %d\n", value);
// signal
sem_post(&s);
sem_getvalue(&s, &value);
printf("after signal s.count = %d\n", value);
sem_destroy(&s);
return 0;
}
输出：
initialization s.count = 10
after wait s.count = 9
after signal s.count = 10
C 实例
我们通过两个经典模型，来深入理解进程并发编程
消费者、生产者模型
该问题描述了共享固定大小缓冲区的两个进程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <unistd.h>
#define SIZE 1 /*buffer size*/
sem_t empty;
sem_t full;
sem_t mutex;
int buffer[SIZE] = {0};
void producer(int idx, int value) {
sem_wait(&full);
sem_wait(&mutex);
buffer[idx] = value;
sem_post(&mutex);
sem_post(&empty);
}
void consumer(int idx) {
sem_wait(&empty);
sem_wait(&mutex);
printf("从 buffer[%d] 取出 %d \n", idx, buffer[idx]);
buffer[idx] = -1;
sem_post(&mutex);
sem_post(&full);
}
int main(int argc, char const *argv[]) {
int value;
// 多个生产者和消费者，只有一个进程能够拥有 buffer，这是所有进程的互斥
sem_init(&mutex, 0, 1);
// 生产者在满的时候不能生产
sem_init(&full, 0, SIZE);
// 消费者不能在空的时候消费
sem_init(&empty, 0, 0);
// 假设有四个进程
for(int i = 0; i < 4; i++) {
int p = fork();
if(p == 0) {
switch (i)
{
case 0:
producer(0, 10);
break;
case 1:
producer(0, 100);
break;
case 2:
consumer(0);
break;
case 3:
consumer(0);
break;
default :
// producer(0, 10);
break;
}
} else {
printf("我是主进程：%d \n", p);
}
}
sem_destroy(&mutex);
sem_destroy(&empty);
sem_destroy(&full);
return 0;
}
