进程同步与互斥——信号量（实现锁、条件变量）

传送门：

进程同步与互斥——信号量（实现锁、条件变量）

进程同步与互斥——哲学家就餐问题源码实现（dining philosopher’s problem）

进程同步与互斥——读者/写者问题源码实现（reader-writer lock）

进程同步与互斥——生产者/消费者（有界缓冲区）问题源码实现

进程同步与互斥——吸烟者问题源码实现（cigarette smoker’s problem）

进程同步与互斥——理发师问题源码实现（sleeping barber problem）

进程同步与互斥——相关问题汇总（源码+伪代码）

摘自：操作系统导论

我们现在知道，需要锁和条件变量来解决各种相关的、有趣的并发问题。多年前，首先认识到这一点的人之中，有一个就是Edsger Dijkstra。他出名是因为图论中著名的“最短路径”算法，因为早期关于结构化编程的论战“Goto语句是有害的”，还因为他引入了名为信号量的同步原语，正是这里我们要学习的。事实上，Dijkstra及其同事发明了信号量，作为与同步有关的所有工作的唯一原语。你会看到，可以使用信号量作为锁和条件变量。

信号量的定义

信号量是有一个整数值的对象，可以用两个函数来操作它。在POSIX标准中，是sem_wait()和sem_post()。因为信号量的初始值能够决定其行为，所以首先要初始化信号量，才能调用其他函数与之交互。

 #include <semaphore.h>
 sem_t s;
 sem_init(&s, 0, 1); 

其中申明了一个信号量s，通过第三个参数，将它的值初始化为1。sem_init()的第二个参数，在我们看到的所有例子中都设置为0，表示信号量是在同一进程的多个线程共享的。读者可以参考手册，了解信号量的其他用法（即如何用于跨不同进程的同步访问），这要求第二个参数用不同的值。

信号量初始化之后，我们可以调用sem_wait()或sem_post()与之交互。我们暂时不关注这两个函数的实现，这显然是需要注意的。多个线程会调用sem_wait()和sem_post()，显然需要管理这些临界区。我们首先关注如何使用这些原语，稍后再讨论如何实现。

int sem_wait(sem_t* s)    //请求一个单位的资源
{
	decrement the value of semaphore s by one
	wait if value of semaphore s is negative
}

int sem_post(sem_t* s)   //释放一个单位的资源
{
	increment the value of semaphore s by one
	if there are one or more threads waiting, take one
}

在计算机操作系统（第四版）书中，记录型信号量的实现为：

typedef struct 
{
	int value;
	struct process_control_block *list;
}semaphore;

wait(semaphore* S)    //sem_wait(sem_t* s)
{
	S->value--;
	if(S->value < 0)
	{
		block(S->list);
	}
}

signal(semaphore* S)   //sem_post(sem_t* s)
{
	S->value++;
	if(S->value <= 0)
	{
		wakeup(S->list);
	}
}

S->value 的初值表示系统中某类资源的数目，因而又称为资源信号量，对它的每次wait操作，
意味着进程请求一个单位的该类资源，使系统中可供分配的该类资源数减小一个，因此描述为S->value--。

当S->value < 0时，表示该类资源已分配完毕，因此进程应调用block原语进行自我阻塞，放弃处理机，
并插入信号量链表S->list中，可见该机制遵循了让权等待准则。

此时S->value的绝对值表示在该信号量链表中已阻塞进程的数目。

对信号量的每次signal操作表示执行进程释放一个单位资源，使系统中可供分配的该资源数加1。
若加1后仍是S->value <= 0，则表示在该信号量链表中仍有等待该资源的进程被阻塞，
故还应调用wakeup原语，将S->list链表中的第一个等待进程唤醒。

如果S->value的初值为1,表示只允许一个进程访问临界资源，此时的信号量转换为互斥量，用于进程互斥。

我们应该讨论这些接口的几个突出方面。首先，sem_wait()要么立刻返回（调用sem_wait()时，信号量的值大于等于1），要么会让调用线程挂起，直到之后的一个post操作。当然，也可能多个调用线程都调用sem_wait()，因此都在队列中等待被唤醒。

其次，sem_post()并没有等待某些条件满足。它直接增加信号量的值，如果有等待线程，唤醒其中一个。

最后，当信号量的值为负数时，这个值就是等待线程的个数。虽然这个值通常不会暴露给信号量的使用者，但这个恒定的关系值得了解，可能有助于记住信号量的工作原理。先（暂时）不用考虑信号量内的竞争条件，假设这些操作都是原子的。我们很快就会用锁和条件变量来实现。

二值信号量（锁）

现在我们要使用信号量了。信号量的第一种用法是我们已经熟悉的：用信号量作为锁。在下图所示的代码片段里，我们直接把临界区用一对sem_wait()/sem_post()环绕。但是，为了使这段代码正常工作，信号量m的初始值（图中初始化为X）是至关重要的。X应该是多少呢？

sem_t m; 
sem_init(&m, 0, X); // initialize semaphore to X; what should X be? 
sem_wait(&m);
// critical section here    
sem_post(&m);

回顾sem_wait()和sem_post()函数的定义，我们发现初值应该是1。

为了说明清楚，我们假设有两个线程的场景。

第一个线程（线程0）调用了sem_wait()，它把信号量的值减为0。然后，它只会在值小于0时等待。因为值是0，调用线程从函数返回并继续，线程0现在可以自由进入临界区。

线程0在临界区中，如果没有其他线程尝试获取锁，当它调用sem_post()时，会将信号量重置为1（因为没有等待线程，不会唤醒其他线程）。

如果线程0持有锁（即调用了sem_wait()之后，调用sem_post()之前），另一个线程（线程1）调用sem_wait()尝试进入临界区，那么更有趣的情况就发生了。这种情况下，线程1把信号量减为−1，然后等待（自己睡眠，放弃处理器）。线程0再次运行，它最终调用sem_post()，将信号量的值增加到0，唤醒等待的线程（线程1），然后线程1就可以获取锁。线程1执行结束时，再次增加信号量的值，将它恢复为1。

我们可以用信号量来实现锁了。因为锁只有两个状态（持有和没持有），所以这种用法有时也叫作二值信号量（binary semaphore）。事实上这种信号量也有一些更简单的实现，我们这里使用了更为通用的信号量作为锁。

信号量用作条件变量

信号量也可以用在一个线程暂停执行，等待某一条件成立的场景。例如，一个线程要等待一个链表非空，然后才能删除一个元素。在这种场景下，通常一个线程等待条件成立，另外一个线程修改条件并发信号给等待线程，从而唤醒等待线程。因为等待线程在等待某些条件（condition）发生变化，所以我们将信号量作为条件变量（condition variable）。
下面是一个简单例子。假设一个线程创建另外一线程，并且等待它结束。

sem_t s;

void* child(void* arg)
{
	printf("child\n");
	sem_post(&s);        // signal here: child is done
	return nullptr;
}

int main()
{
	sem_init(&s, 0, X);   //what should be ?
	printf("parent begin\n");
	pthread_t c;
	pthread_create(&c, nullptr, child, nullptr);
	sem_wait(&s);         //wait here for child
	printf("parent end\n");
	return 0;
}

该程序运行时，我们希望能看到这样的输出：
parent: begin
child
parent: end

然后问题就是如何用信号量来实现这种效果。结果表明，答案也很容易理解。从代码中可知，父线程调用sem_wait()，子线程调用sem_post()，父线程等待子线程执行完成。但是，问题来了：信号量的初始值应该是多少？

当然，答案是信号量初始值应该是0。有两种情况需要考虑。

第一种，父线程创建了子线程，但是子线程并没有运行。这种情况下，父线程调用sem_wait()会先于子线程调用sem_post()。我们希望父线程等待子线程运行。为此，唯一的办法是让信号量的值不大于0。因此，0为初值。父线程运行，将信号量减为−1，然后睡眠等待；子线程运行的时候，调用sem_post()，信号量增加为0，唤醒父线程，父线程然后从sem_wait()返回，完成该程序。

第二种情况是子线程在父线程调用sem_wait()之前就运行结束。在这种情况下，子线程会先调用sem_post()，将信号量从0增加到1。然后当父线程有机会运行时，会调用sem_wait()，发现信号量的值为1。于是父线程将信号量从1减为0，没有等待，直接从sem_wait()返回，也达到了预期效果。