操作系统 线程同步 基础知识 (一)

6.2 临界区问题

临界区问题的解答必须满足以下三项要求:

1. 互斥. 不能有两个线程同时在临界区内执行

2. 前进. 当临界区为空, 而一个线程希望进入临界区时, 该线程进入临界区

3. 有限等待. 一个线程从申请进入临界区到真正进入临界区这段时间不能无限长.

6.3 Peterson 算法

一种软件的方法解决死锁问题, 但也并不能总是解决死锁问题

定义两个变量, 分别为 flag[0/1], turn. flag 表示哪个线程有进入临界区的意愿, turn 表示哪个线程

while(true) {
flag[i] = true;
turn = j;

while(flag[j] && turn == j); // let j run first
// cirtical section

flag[i] = false;
// remainer section
}

证明满足上面 3 个要求

1. 互斥. 假设两个线程同时进入临界区, 那么 flag[i] == flag[j] == 1. 当 turn = j 时, 线程 i 在自旋, 不可能进去.

2. 前进. 当线程 j 没有意愿进入临界区时, flag[j] = false; 当 i 有意愿进去时, 直接就进入了.

3. 有限等待. 首先申请临界区的线程进入临界区, 一个线程至多等待另一个线程在临界区执行一次, 满足有限等待.

6.4 硬件同步.

使用原子函数 setAndSwap()

void getAndSet(bool var) {
swap(lock, var);
}

上面的代码核心是 getAndSet 必须时原子操作. 当 lock 为 false 时, 线程上锁进入临界区. 当 lock 为 true 时, 那么 getAndSet 无限循环, 直到 lock 为 false;

6.5 信号量与死锁

acquire() {
value --;
if(value < 0) {
add this process to list
block;
}
}

release() {
value ++;
if(value <= 0) {
remove a process P from list
wakeup(P);
}
}

当 value 为负时, value 的绝对值对应被阻塞线程的数目.

死锁

S.acquire();         Q.acquire();
Q.acquire();         S.acquire();

...			...

S.release();         Q.release();
Q.release();         S.release();

上面代码中, P0 执行 S.acquire(), P1 执行 Q.acquire, 然后 P0 执行 Q.acquire, 最后 P1 S.acquire.

然后... 就死锁了

6.6 经典同步问题

1. 有限缓冲区问题

生成者通过 insert 函数向缓冲区内添加 item, 消费者通过 remove 函数在缓冲区内删除 item

信号量有 3 个, 分别为 empty, full, mutex. empty 表示缓冲区内的空格位置, insert 时需要检查缓冲区是否为空, remove 时需要检查缓冲区是否含有元素. mutex 提供对缓冲区的互斥访问

semaphore empty, full, mutex;

// init empty = size, full = 0, mutex = 1;

// java code
public void insert(Object item) {
empty.acquire();
mutex.acquire();

buffer[in] = item;
in = (in+1) % BUFFER_SIZE;

mutex.release();
full.release();
}

public Object remove() {
full.acquire();
mutex.acquire();

Object item = buffer[out];
out = (out + 1) % BUFFER_SIZE;

mutex.release();
empty.release();

return item;
}

　　

注意, empty, full 都必须使用信号量来表示其剩余个数, 不能用 if 代替

2. 读者写者问题

// writer may starve

void read() {
while(true) {
mutext.acquire();
readCount ++;
if(readCount == 1) {
writeLock.acquire();
}
mutext.release();

do reading

mutext.acquire();
readCount --;
if(readCount == 0) {
writeLock.release();
}
mutext.release();
}
}

void write() {
writeLock.acquire();
do writing
writeLock.release();
}

　　

6.7 管程

管程将 acquire, release 这些操作封装起来了. 管程确保一次只有一个进程能在管程内活动.

管程内的条件遍历有两个操作:

wait() 挂起调用进程并释放管程, 直至另一个进程在条件变量上执行 signal()

signal() 假如有因条件变量被挂起的线程, 那么释放之, 否则什么也不做.

管程实现生产者消费者问题

// full means that no space for new added item
// empty means that no item for consumer
monitor ProducerConsumer {
int itemCount;
condition full;
condition empty;

procedure add(item) {
if(itemCount == BUFFER_SIZE) {
wait(full);
}

putItemIntoBuffer(item);
itemCount ++;

if(itemCount == 1) {
signal(empty);
}
}

procedure remove() {
if(itemCount == 0) {
wait(empty);
}

removeItemFromBuffer();
itemCount --;

if(itemCount == BUFFER_SIZE-1)
signal(full);
}
}

管程示意图