Operating System： Semaphore

17 Nov 2019

本文主要参考《计算机操作系统（第四版）》（西安电子科技大学出版社）以及清华大学操作系统公开课（向勇、陈渝），整理操作系统的基本概念，供自己复习查阅。

信号量机制

进程控制中最重要的一部分便是协调好进程的并发，控制进程同步，最具体的体现就是处理临界资源。信号量机制便广泛应用在临界资源处理方面。

信号量的分类与发展

信号量最初的定义是表示资源的数目。

整型信号量

顾名思义，这种信号量就是用一个整型量s表示某临界资源的数目。在初始化时，把s初始化为资源的数目，并限制只能通过原子操作wait(s)和signal(s)来访问，这两个操作通常也被称为P、V操作。可代码表示如下：

wait(s) {
    while(s <= 0);
    --s;
}

signal(s) {
    ++s;
}

记录型信号量

可以看到，在整型信号量中，只要申请不到资源，就会不断调试，并不符合“让权等待”原则（即让进程处于“忙等”状态），而记录型信号量就可以解决这个问题。

在记录型信号量中，简单的整型量s被扩充为记录型结构体，里面额外保存了一个进程表指针，用于链接所有等待进程。

struct ProcessControlBlock;

using PCB = ProcessControlBlock;
struct Semaphore {
    int value; // 资源数目
    PCB* processList;
};

wait(Semaphore *s) {
    if(--s->value < 0) {
        // 资源已被分配给其他进程，当前进程自我阻塞
        // 并把其插入等待队列
        block(s->processList);
    }
}

signal(Semaphore *s) {
    if(++s->value <= 0) {
        // 条件为真说明有进程在等待队列中，唤醒队列的第一个进程
        wakeup(s->processList);
    }
}

可以看到，进程在申请不到资源时会进行自我阻塞，也就符合让权等待的原则。特殊地，在资源初始数量为一时就会转化为互斥信号量。

AND型信号量

进程互斥只是针对多进程共享一个临界资源的情况。在某些情况下，一个进程需要获得不止一个共享资源后才可以执行任务。这种情况下进程很容易发生死锁。如：若两个进程需要的临界资源一致但申请顺序不一致且交替申请，那么他们都得不到所有所需的临界资源，即陷入死锁。

针对这个问题，AND型信号量的解决方案是：将进程在整个运行过程中需要的所有资源一次性全部分配给进程，待进程使用完后再一起释放。

Swait(s1, s2, ..., sn) {
    while(true) {
        if(s1 >= 1 && s2 >= 1 && ... && sn >= 1) {
            --s1; --s2; ...; --sn;
            break;
        } else {
            wait();
        }
    }
}

Ssignal(s1, s2, ..., sn) {
    while(true) {
        ++s1; ++s2; ...; ++sn;
    }
}

信号量集

由于P、V操作只能对信号量进行加一和减一操作，当一次需要n个单位时显然是低效的，而且逐单位分配更容易引起死锁。为了系统安全，有些情况下我们需要管制资源，具体而言即当所申请的资源数d低于对应的下限值t时不予分配。

针对这个问题，信号量集的解决方案是：在进行P、V操作时需要知道进程对资源的需求量以及对应资源的下限值，并由此决定资源的分配。

Swait(s1, t1, d1, ..., sn, tn, dn);
Ssignal(s1, d1, ..., sn, dn);

三种特殊的信号量集：

Swait(s, 0, 0)：信号量集中只有一个信号量，且下限值和允许申请数相同；
Swait(s, 1, 1)：此时的信号量集退化为记录型信号量；
Swait(s, 1, 0)：当s＞0时，允许多个进程进入某个特定区，当s变为0时封锁区域，作用类似于开关。

信号量的应用

实现进程互斥

要实现某个资源的互斥访问，只需要为该资源设置一个互斥信号量mutex并设初值为1，结合P、V操作即可。

Semaphore mutex = 1;

// a进程P资源
Pa() {
    while(true) {
        wait(mutex);
        // 临界区
        signal(mutex);
        // 剩余区
    }
}

实现前趋关系

前趋图是一种描述进程前趋关系的有向无环图。

利用信号量可以描述进程之间的前趋关系。有前趋图如下：

那么可以用如下代码框架描述这个关系：

Semaphore a, b, c, d, e, f, g;

p1() { s1; signal(a); signal(b); }
p2() { wait(a); s2; signal(c); signal(d); }
p3() { wait(b); s3; signal(e); }
p4() { wait(c); s4; signal(f); }
p5() { wait(d); s5; signal(g); }
p6() { wait(e); wait(f); wait(g); s6; }

main() {
    a.value = b.value = c.value = d.value = 0;
    e.value = f.value = g.value = 0;
    cobegin
        p1(); p2(); p3(); p4(); p5(); p6();
    coend
}

经典同步问题

生产者-消费者问题

有一群生产者进程在生产产品，并将产品提供给消费者进程消费。为了使生产者和消费者能并发执行，在两者之间设置了一个具有n个缓冲区的缓冲池。这也就暗含两个约束关系：消费者不能到一个空缓冲区取产品；生产者不能往一个满缓冲区投放产品。

利用记录型信号量即可解决这一问题。这里需要设置两个信号量：empty和full表示缓冲区的两个临界状态，用代码描述如下：

int in = 0, out = 0;
Product pool[n]; // 环形缓冲池
Semaphore mutex = 1, empty = n, full = 0;

void Producer() {
    while(true) {
        Produce(); // 生产产品
        wait(empty); // 需要一个空的缓冲区容纳新产品
        wait(mutex); // 请求锁
        pool[in] = nextp; // 存放新产品
        in = (in + 1) % n; // 偏移指针指向下一个可存放区域
        signal(mutex); // 释放锁
        signal(full); // 增加一个满缓冲区
    }
}

void Consumer() {
    while(true) {
        wait(full); // 需要一个满缓冲区来取其中的产品
        wait(mutex); // 请求锁
        nextc = pool[out]; // 取出产品
        out = (out + 1) % n; // 偏移指针指向下一个可取出区域
        signal(mutex); // 释放锁
        signal(empty); // 增加一个空缓冲区
        Consume(); // 消费取出的产品
    }
}

void main() {
    cobegin
		Producer();
		Consumer();
    coend
}

需要注意的是，对互斥信号量的申请一定要出现在对资源信号量的申请之后，否则可能引起死锁。显然这个问题也可以用AND型信号量解决。

int in = 0, out = 0;
Product pool[n];
Semaphore mutex = 1, empty = n, full = 0;

void Producer() {
    while(true) {
        Produce();
        Swait(empty, mutex); // 要同时申请到空缓冲区和互斥信号量
        pool[in] = nextp;
        in = (in + 1) % n;
        Ssignal(mutex, full); // 同时释放满缓冲区和互斥信号量
    }
}

void Consumer() {
    while(true) {
        Swait(full, mutex);
        nextc = pool[out];
        out = (out + 1) % n;
        Ssignal(mutex, empty);
        Consumer();
    }
}

哲学家进餐问题

有五个哲学家共用一张圆桌，桌上放着5个碗和5只筷子，哲学家只做两件事：思考、进餐。一个哲学家总是在思考，饥饿时也只能拿离他最近的两只筷子，拿到了才能进餐。进餐结束才继续思考。

利用记录型信号量可以解决这一问题。

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

while(true) {
    Think();
    wait(chopstick[i]);
    wait(chopstick[(i + 1) % 5]);
    Eat();
    signal(chopstick[i]);
    signal(chopstick[(i + 1) % 5]);
}

但上面的做法会有一个问题：如果5位哲学家都处于饥饿状态，那么他们都会先去拿自己左手边的筷子，引起死锁。可以制定一些规则解决死锁问题。而用AND型信号量则不用考虑死锁问题。

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

while(true) {
    Think();
    Swait(chopstick[i], chopstick[(i + 1) % 5]);
    Eat();
    Ssignal(chopstick[i], chopstick[(i + 1) % 5]);
}

读者-写者问题

一个数据文件可被多个进程共享，只对该文件做读操作的称为Reader进程，其他进程称为Writer进程。多个读进程可以同时读取文件，但当有写进程访问该文件时，其他进程（不管是读进程还是写进程）都不能访问该文件。这个问题常用于测试新的同步原语。

利用记录型信号量可以解决这个问题。

Semaphore rMutex = 1, wMutex = 1;
int readerCount = 0;

void Reader() {
    while(true) {
        wait(rMutex); // 申请读锁
        if(readerCount == 0) wait(wRmutex); // 如果当前没有读者，那就需要锁写入
        ++readerCount;
        signal(rMutex); // 由于读取可以同时进行，所以现在就释放读锁
        Read();
        wait(rMutex);
        --readerCount;
        if(readerCount == 0) signal(wMutex); // 没有读者才释放写锁
        signal(rMutex);
    }
}

void Writer() {
    while(true) {
        wait(wMutex);
        Write();
        signal(wMutex);
    }
}

void main() {
    cobegin
		Reader();
		Writer();
    coend
}

如果文件要求最多可以被RN个读进程访问，那么用信号量集解决问题更方便。

int RN;
Semaphore L = RN, mutex = 1;

void Reader() {
    while(true) {
        Swait(L, 1, 1);
        Swait(mutex, 1, 0);
        Read();
        Ssignal(L, 1);
    }
}

void Writer() {
    while(true) {
        Swait(mutex, 1, 1,  L, RN, 0);
        Write();
        Ssignal(mutex, 1);
    }
}

void main() {
    cobegin
		Reader();
		Writer();
    coend
}

Operating System