操作系统——进程同步与互斥、信号量机制

进程同步、进程互斥

进程同步

• 
• 读进程和写进程并发地运行，由于并发必然导致异步性，因此“写数据”和“读数据”两个操作执行的先后顺序是不确定的。而实际应用中，又必须按照**“写数据→读数据”**的顺序来执行的。如何解决这种异步问题，就是“进程同步”所讨论的内容。
• 同步亦称直接制约关系，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们的工作次序而产生的制约关系。进程间的直接制约关系就是源于它们之间的相互合作。

进程互斥

• 我们把一个时间段内只允许一个进程使用的资源称为临界资源。许多物理设备（比如摄像头、打印机）都属于临界资源。此外还有许多变量、数据、内存缓冲区等都属于临界资源。
• 对临界资源的访问，必须互斥地进行。互斥，亦称间接制约关系。进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源之后，另一个进程才能去访问临界资源。

do {
    entry section;//进入区（负责检查是否可进入临界区，若能进入，则应该设置正在访问临界资源的标志，阻止其他进程进入）
    
    critical section;//临界区（访问临界资源的代码）
    
    exit section;//退出区（负责接触正在访问临界资源的标志）
    
    remainder section;//剩余区（做其他处理）
}

• 临界区是进程中访问临界资源的代码段。
• 进入区和退出区是负责实现互斥的代码段。
• 临界区也可称为“临界段”。
• 为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则:
  • 1．空闲让进。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区;
  • 2．忙则等待。当已有进程进入临界区时，其他试图进入临界区的进程必须等待;
  • 3．有限等待。对请求访问的进程，应保证能在有限时间内进入临界区（保证不会饥饿）;
  • 4． 让权等待。当进程不能进入临界区时，应立即释放处理机，防止进程忙等待。

进程互斥的软件实现方法

单标志法

• 算法思想:两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予

• turn表示当前允许进入临界区的进程号，而只有当前允许进入临界区的进程在访问了临界区之后，会修改turn的值。也就是说，对于临界区的访问，一定是按PO→P1→PO→P1→…这样轮流访戊这种必须“轮流访问”带来的问题是，如果此时允许进入临界区的进程是Po，而PO一直不访问临区，那么虽然此时临界区空闲，但是并不允许P1访问。
• 因此，单标志法存在的主要问题是:违背“空闲让进”原则。

双标志先检查法

• 算法思想:设置一个布尔型数组flag[]，数组中各个元素用来标记各进程想进入临界区的意愿，比如“flag[0] =ture”意味着0号进程PO现在想要进入临界区。每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区，如果没有，则把自身对应的标志 flag[i]设为true，之后开始访问临界区。
• 
• 若按照①⑤②⑥3⑦…的顺序执行，PO和P1将会同时访问临界区。
• 因此，双标志先检查法的主要问题是:违反“忙则等待”原则。
  原因在于，进入区的“检查”和“上锁”两个处理不是一气呵成的。“检查”后，“上锁”前可能发生进程切换。

双标志后检查法

• 若按照①⑤②⑥…的顺序执行，PO和P1将都无法进入临界区
• 因此，双标志后检查法虽然解决了“忙则等待”的问题，但是又违背了“空闲让进”和“有限等待”原则，会因各进程都长期无法访问临界资源而产生“饥饿”现象。
• 两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区

Peterson算法

• 算法思想:双标志后检查法中，两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区。Gary L.Peterson想到了一种方法，如果双方都争着想进入临界区，那可以让进程尝试“孔融让梨”，主动让对方先使用临界区。
• Peterson算法用软件方法解决了进程互斥问题，遵循了空闲让进、忙则等待、有限等待三个原则，但是依然未遵循让权等待的原则。

总结

进程互斥的硬件实现方法

中断屏蔽方法

• 利用**“开/关中断指令”**实现（与原语的实现思想相同，即在某进程开始访问临界区到结束访问为止都不允许被中断，也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况)
• 优点:简单、高效
• 缺点:
  • 不适用于多处理机;
  • 只适用于操作系统内核进程，不适用于用户进程（因为开/关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很危险)

TestAndSet指令

• 简称TS指令，也有地方称为TestAndSetLock指令，或TSL指令
• TSL指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。

C语言描述的逻辑：

//lock表示当前临界区是否被加锁
bool TestAndSet(bool *lock)
{
    bool old;
    old = *lock;//old用来存放lock原来的值
    *lock = true;//无论之前是否加锁，都将lock设为true
    return old;//返回lock原来的值
}

//以下是使用TSL指令实现互斥的算法逻辑
while (TestAndSet(&lock));
临界区代码段
lock = false; //解锁
剩余区代码段

• 若刚开始lock是false，则TSL返回的old值为false，while循环条件不满足，直接跳过循环，进入临界区。若刚开始lock是true，则执行TLS后old返回的值为true，while循环条件满足，会一直循环，直到当前访问临界区的进程在退出区进行“解锁”。
• 相比软件实现方法，TSL指令把“上锁”和“检查”操作用硬件的方式变成了一气呵成的原子操作。
• 优点:实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞;适用于多处理机环境
• 缺点:不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPu并循环执行TSL指令，从而导致“忙等”。

Swap指令

• 有的地方也叫Exchange指令，或简称XCHG指令。
• Swap指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。

C语言描述的逻辑：

Swap(bool *a,bool *b)
{
    bool temp;
    temp *a;
    *a = *b;
    *b = temp;
}

bool old = true;
while(old == true)
    Swap(&lock,&old);
临界区代码段
lock = false;
剩余区代码段

• 逻辑上来看Swap和TSL并无太大区别，都是先记录下此时临界区是否已经被上锁(记录在 old变量上），再将上锁标记lock设置为true，最后检查old，如果old为 false则说明之前没有别的进程对临界区上锁，则可跳出循环，进入临界区。
• 优点:实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞;适用于多处理机环境
• 缺点:不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。

总结

信号量机制

信号量机制

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

整型信号量

• 用一个整数型的变量作为信号量，用来表示系统中某种资源的数量.
  • 与普通整数变量的区别:对信号量的操作只有三种,即初始化、P操作、V操作

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

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


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

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

记录型信号量

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

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

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

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

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

总结

• 
• 注:若考试中出现P(S)、V(S)的操作，除非特别说明，否则默认S为记录型信号量。

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

信号量机制实现进程互斥

• 分析并发进程的关键活动，划定临界区（如:对临界资源打印机的访问就应放在临界区)
• 设置互斥信号量mutex，初值为1
• 在临界区之前执行P(mutex)
• 在临界区之后执行V(mutex)
• 注意:对不同的临界资源需要设置不同的互斥信号量。

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

信号量机制实现进程同步

• 进程同步:要让各并发进程按要求有序地推进。
• 用信号量实现进程同步:
  • 1．分析什么地方需要实现“同步关系”，即必须保证“一前一后”执行的两个操作（或两句代码)
  • 2．设置同步信号量s,初始为0
  • 3．在“前操作”之后执行v(S)
  • 4．在“后操作”之前执行P(S)
• 
• 若先执行到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了

信号量机制实现前驱关系

总结

生产者-消费者问题

用P、V操作解决问题

• 系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用。(注:这里的“产品”理解为某种数据)
  • 生产者、消费者共享一个初始为空、大小为n的缓冲区。
  • 只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待。（同步关系）
  • 只有缓冲区不空时，消费者才能从中取出产品，否则必须等待。（同步关系）
  • 缓冲区是临界资源，各进程必须互斥地访问。（互斥关系）

能否改变相邻的P、V操作的顺序？

• 若此时缓冲区内已经放满产品，则empty=o，full=n。
• 则生产者进程执行①使mutex变为0，再执行②，由于已没有空闲缓冲区，因此生产者被阻塞。由于生产者阻塞，因此切换回消费者进程。消费者进程执行③，由于mutex为o，即生产者还没释放对临界资源的“锁”，因此消费者也被阻塞。
• 这就造成了生产者等待消费者释放空闲缓冲区，而消费者又等待生产者释放临界区的情况，生产者和消费者循环等待被对方唤醒，出现“死锁”。
• 同样的，若缓冲区中没有产品，即full=0，empty=n。按③④①的顺序执行就会发生死锁。
• 因此，实现互斥的P操作一定要在实现同步的P操作之后。
• V操作不会导致进程阻塞，因此两个v操作顺序可以交换。

总结

• PV操作题目的解题思路:
  • 1．关系分析。找出题目中描述的各个进程，分析它们之间的同步、互斥关系。
  • 2．整理思路。根据各进程的操作流程确定P、V操作的大致顺序。
  • 3．设置信号量。设置需要的信号量，并根据题目条件确定信号量初值。(互斥信号量初值一般为1，同步信号量的初始值要看对应资源的初始值是多少)

多生产者-多消费者问题

问题描述

• 桌子上有一只盘子，每次只能向其中放入一个水果。
• 爸爸专向盘子中放苹果，妈妈专向盘子中放橘子
• 儿子专等着吃盘子中的橘子，女儿专等着吃盘子中的苹果。
• 只有盘子空时，爸爸或妈妈才可向盘子中放一个水果。
• 仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出水果。
• 用PV操作实现上述过程。

• 互斥关系:
  • 对缓冲区（盘子)的访问要互斥地进行
• 同步关系（一前一后）:
  • 1.父亲将苹果放入盘子后，女儿才能取苹果
  • 2.母亲将橘子放入盘子后，儿子才能取橘子
  • 3.只有盘子为空时，父亲或母亲才能放入水果

2.3.10 学家进餐问题

问题描述

• 一张圆桌上坐着5名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子（一根一根地拿起)。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。

如何防止死锁

• 1、可以对哲学家进程施加一些限制条件，比如最多允许四个哲学家同时进餐。这样可以保证至少有一个哲学家是可以拿到左右两只筷子的

semaphore count = 4;//最大同时吃饭人数
semaphore chopstick[5] = {1,1,1,1,1};

Pi()//i号哲学家
{
    while(1)
    {
        P(count);//占据一个吃饭人数
        P(chopstick[i]);//拿左手筷子
        P(chopstick[(i+1)%5]);//拿右手筷子
        吃饭
        V(chopstick[i]);//放左手筷子
        V(chopstick[(i+1)%5]);//放右手筷子
        V(count);//释放一个吃饭人数
    }
}

• 2、要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数号哲学家刚好相反。用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一只筷子，另一个会直接阻塞。这就避免了占有一支后再等待另一只的情况。

semaphore chopstick[5] = {1,1,1,1,1};

Pi()
{
    while(1)
    {
        if(i%2 == 0)
        {
            P(chopstick[i]);//拿左手筷子
        	P(chopstick[(i+1)%5]);//拿右手筷子
            吃饭
            V(chopstick[i]);//放左手筷子
        	V(chopstick[(i+1)%5]);//放右手筷子
        }
        else if(i%2 == 1)
        {
        	P(chopstick[(i+1)%5]);//拿右手筷子
            P(chopstick[i]);//拿左手筷子
            吃饭
        	V(chopstick[(i+1)%5]);//放右手筷子
            V(chopstick[i]);//放左手筷子
        }
    }
}

• 3、各哲学家拿筷子这件事必须互斥的执行。这就保证了即使一个哲学家在拿筷子拿到一半时被阻塞，也不会有别的哲学家会继续尝试拿筷子。这样的话，当前正在吃饭的哲学家放下筷子后，被阻塞
  的哲学家就可以获得等待的筷子了。

semaphore chopstick[5] = {1,1,1,1,1};
semaphore mutex = 1;

Pi()//i号哲学家
{
    while(1)
    {
    	P(mutex);
        P(chopstick[i]);//拿左手筷子
        P(chopstick[(i+1)%5]);//拿右手筷子
        V(mutex);
        吃饭
        V(chopstick[i]);//放左手筷子
        V(chopstick[(i+1)%5]);//放右手筷子
    }
}

总结

• 哲学家进餐问题的关键在于解决进程死锁。
• 这些进程之间只存在互斥关系，但是与之前接触到的互斥关系不同的是，每个进程都需要同时持有两个临界资源，因此就有“死锁”问题的隐患。
• 如果在考试中遇到了一个进程需要同时持有多个临界资源的情况，应该参考哲学家问题的思想，分析题中给出的进程之间是否会发生循环等待，是否会发生死锁。
• 可以参考哲学家就餐问题解决死锁的三种思路。

管程

管程的定义和基本特征

• 管程是一种特殊的软件模块，有这些部分组成:（管程可以类比与面向对象的类）
  • 1．局部于管程的共享数据结构说明;
  • 2．对该数据结构进行操作的一组过程;（过程相当于函数）
  • 3．对局部于管程的共享数据设置初始值的语句;
  • 4．管程有一个名字。
• 管程的基本特征:
  • 1．局部于管程的数据只能被局部于管程的过程所访问;
  • 2．一个进程只有通过调用管程内的过程才能进入管程访问共享数据;
  • 3．每次仅允许一个进程在管程内执行某个内部过程。

用管程处理生产者消费者问题

• 引入管程的目的无非就是要更方便地实现进程互斥和同步。
  • 1．需要在管程中定义共享数据（如生产者消费者问题的缓冲区)
  • 2．需要在管程中定义用于访问这些共享数据的“入口”―—其实就是一些函数（如生产者消费者问题中，可以定义一个函数用于将产品放入缓冲区，再定义一个函数用于从缓冲区取出产品)
  • 3．只有通过这些特定的“入口”才能访问共享数据
  • 4．管程中有很多“入口”，但是每次只能开放其中一个“入口”，并且只能让一个进程或线程进入(如生产者消费者问题中，各进程需要互斥地访问共享缓冲区。管程的这种特性即可保证一个时间段内最多只会有一个进程在访问缓冲区。注意:这种互斥特性是由编译器负责实现的，程序员不用关心)
  • 5．可在管程中设置条件变量及等待/唤醒操作以解决同步问题。可以让一个进程或线程在条件变量上等待（此时，该进程应先释放管程的使用权，也就是让出“入口”);可以通过唤醒操作将等待在条件变量上的进程或线程唤醒。
  • 程序员可以用某种特殊的语法定义一个管程（比如: monitor ProducerConsumer …end monitor;) ,之后其他程序员就可以使用这个管程提供的特定“入口”很方便地使用实现进程同步/互斥了。