操作系统之互斥记录

忙等待: 

while (1); // 占用CPU资源

饥饿:

高个子(进程1)和矮子(进程2)抢篮板(CPU执行权), 矮子抢不到篮板, 矮子饥饿.

一. 临界区的四个特点

1. 互斥
2. 前进
3. 有限等待
4. 无忙等待(可选)
临界区很短时, 允许忙等待
临界区很长时, 考虑基于上下文切换实现无忙等待

二. 实现互斥的四种方式

1. 禁用硬件中断
OS如何实现多进程?
通过时钟中断, 导致进程切换, 实现并发.

具体方法:
进入临界区 禁用中断
退出临界区 开启中断

局限性:
- 硬件事件无法及时响应
- 临界区长, 影响系统效率
- 多CPU下, 无法实现互斥

2.  软件实现
2.1Peterson算法

适用于双进程

Peterson算法的多进程变式:
Eisenberg and Meauire's 算法

两个重要的参数:
flag 需要?
turn 谁来?

伪代码(双进程)

process (i) {
    do {
        flag[i] = true;
        turn = j; // 进程i将机会让给进程j
        while (turn == j && flag[j]); // 进程j把握机会且本身也想进入临界区
        // 临界区
        flag[i] = false;
        } while (1);
}

可以使用反证法证明Peterson算法满足临界区互斥, 前进和有限等待的属性.

2.2 Dekker算法

适用于双进程

2.3 面包店算法
适用于多进程

3. 原子指令

3.1 锁

两个方法:
acquire: 等待解锁, 获取锁
release: 解锁, 唤醒

锁方法具体实现:

3.1.1 基于test-and-set机器指令

test-and-set内部实现

boolean TestAndSet(boolean* target)
{
    boolean rv = *target;
    *target = true;
    return rv;
}

忙等待版:

class Lock {
    int value = 0;
}

Lock::Acquire() {
    while (test-and-set(value));
}

Lock::Release() {
    value = 0;
}

两种情况:
锁被释放, value=0, value=1且返回0, 跳过while, 进入临界区
锁被占用, value=1, value=1且返回1, 自旋while, 忙等待状态

若临界区很长时, 应该考虑基于上下文切换实现无忙等待

无忙等待版:

class Lock {
    int value = 0;
    WaitQueue q;
}

Lock::Acquire() {
    while (test-and-set(value)) {
        add this TCB to wait queue q;
        schedule(); // 线程睡眠, 阻塞, 让出CPU
    }
}

Lock::Release() {
    value = 0;
    remove one thread t from q;
    wakeup(t); // 唤醒
}

3.1.2 基于exchange机器指令

exchange内部实现

void Exchange(boolean* a, boolean* b)
{
    boolean temp = *a;
    *a = *b;
    *b = temp;
}

伪代码:

int lock = 0;

thread (i) {
    int key;
    do {
            key = 1;
            while (key == 1) exchange(lock, key);
            // 临界区
            lock = 0;
        } while (1);
}

3.2 信号量

可实现同步和互斥

3.2.1 信号量的实现

// 信号量
class Semaphore {
    int sem;
    // 等待队列
    WaitQueue q;
}

// P操作
Semaphore::P() {
    sem--;
    if (sem < 0) {
        add this thread t to q;
        block(t);
    }
}

// V操作
Semaphore::V() {
    sem++;
    if (sem <= 0) {
        remove a thread t from q;
        wakeup(t);
    }
}

4. 管程(可实现同步或互斥)

schedule和wakeup操作

schedule(): 当前thread原地睡眠(醒来继续向下执行), 获取一个就绪thread
wakeup(): 将sleep进程 -> 就绪态进程

4.1. 实现管程

管程由Lock和条件变量组成

Lock保证管程中只有唯一一个线程

4.1.1 Lock实现

见上文

4.1.2 条件变量实现

// 条件变量
Class Condition {
    // 等待队列默认为空
    int numWaiting = 0;
    WaitQueue q;
}

// 条件变量等待操作
Condition::Wait(lock) {
    numWaiting++;
    add this thread t to q;
    // 释放当前锁
    release(lock);
    schedule();
    // 重新获得锁
    require(lock);
}

// 条件变量唤醒操作
Condition::Signal() {
    // 等待队列不为空时
    if (numWaiting > 0) {
        remove a thread from q;
        wakeup(t);
        numWaiting--;
    }
}

4.2. 使用管程

生产者消费者问题

// 缓冲区
class BoundedBuffer {
    ...
    Lock lock;
    Condition notFull, notEmpty;
    // 缓冲区产品个数, 默认为空
    int count = 0;
}

// 生产者
BoundedBuffer::Deposit(c) {
    lock->Acquire();
    // 缓冲区为满
    while (count == n)
        notFull.Wait(&lock);
    add c to the buffer;
    // 缓冲区产品个数增加1, 执行此操作之后, 缓冲区必定不为空
    count++;
    notEmpty.Signal();
    lock->Release();
}

// 消费者
BoundedBuffer::Remove(c) {
    lock->Acquire();
    // 缓冲区为空
    while (count == 0)
        notEmpty.Wait(&lock);
    remove c from buffer;
    // 缓冲区产品个数减少1, 执行此操作之后, 缓冲区必定不为满
    count--;
    notFull.Signal();
    lock->Release();
}

三. 进程通讯

1. 通讯方式

间接通讯: 管道  消息队列(先进先出msg)  共享内存(shm)

直接通讯: 信号 

2. 阻塞和非阻塞

阻塞 同步
非阻塞 异步