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

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);
	}
}

管程示意图