临界区
描述
- 临界区
- 指进程中访问临界资源的一段需要互斥访问的代码
- 进入区
- 检查可否进入临界区的一段代码
- 如可进入，设置相应“正在访问临界区”的标志
- 退出区
- 清除“正在访问临界区”的标志
- 剩余区
- 代码中的剩余代码
访问规则
- 空闲则入
- 没有进程在临界区时，任何进程可进入
- 忙则等待
- 如果有进程在临界区时，任何进程都不可进入临界区
- 有限等待
- 等待进入临界区的进程不能无限的被动等待
- 让权等待（可选）
- 不能进入临界区的进程，应该放弃CPU的使用
同步实现方法
1、禁用硬件中断
- 没有中断，也没有上下文的切换，没有并发执行
- 硬件将中断处理延迟到中断被启用之后
- 使用计算机体系结构的指令集提供的方法实现
缺点
- 禁用中断之后，进程无法被停止
- 可能导致饥饿
- 整个系统都会为此停下来
- 临界区可能很长
- 无法确定响应中断所需的时间
2、软件方法
共享变量
- 线程之间可以通过一些共有的变量去同步它们的行为
PS:以下为代码描述
do{
enter section //进入区
critical section
exit section //退出区
reminder section
}while(1);//第一种做法
int turn = 0;
turn == i ; //表示允许进入临界区的线程的代号
//线程的代码
do{
while(turn!=i);
critical section
turn =j;
reminder section;
}while(1);缺点
- 满足“忙则等待”，但不满足“空闲则入”
//第二种做法
int falg[2];
flag[0]=flag[1]=0;
flag[i] == 1 ; //表示线程i是否在临界区
//线程的代码
do{
while(flag[j]==1);
flag[i]=1;
critical section
flag[i]=0;
reminder section;
}while(1);缺点
- 满足“空闲则入”，不满足“忙则等待”
//第三种做法
int falg[2];
flag[0]=flag[1]=0;
flag[i] == 1 ; //表示线程i想要进入在临界区
//线程的代码
do{
flag[i] = 1 ;
while(flag[j] == 1);
critical section
flag[i] = 0;
reminder section;
}while(1);缺点
- 满足“忙则等待”,但不满足“空闲可入”
//Peterson算法
int turn;//表示该谁进入临界区
boolean flag[];//表示进程是否准备好进入临界区
do{
//进入区代码
flag[i] = true;
turn = j;
while(falg[j] && turn == j);
criticla section
//退出区代码
flag[i] = false;
remainder section
}while(1);//Dekkers算法
int turn;//表示该谁进入临界区
boolean flag[];//表示进程是否准备好进入临界区
do{
//进入区代码
flag[i] = true;
while(flag[j] == true ){
if(turn != i ){
flag[i] = false;
while(tuen != i){}
flag[i] = true;
}
}
criticla section
//退出区代码
flag[i] = false;
turn = j;
remainder section
}while(1);3、基于软件的解决方法的分析
- 复杂
- 需要两个进程间的共享数据项
- 需要程序编写者极高的素养
- 需要忙等待
- 浪费CPU时间
更高级的抽象方法
描述
- 硬件提供了一些同步原语
- 中断禁用，原子操作指令等
- 操作系统提供了更高级的编程抽象来简化进程同步
- 例如：锁、信号量
- 用硬件原语来构建
锁（lock）
- 锁是一种抽象的数据结构
- 一个二进制变量（锁定/解锁）
- Lock::Acquire
- 锁被释放前一直等待，然后得到锁
- Lock::Release
- 释放锁，唤醒任何等待的线程
- 在进入区得到锁，在退出区释放锁
原子操作指令
- 现代CPU体系都提供一些特殊的原子操作指令，保证在原子操作时不会被中断
- 测试和置位操作TS（Test-and-Set）（三个操作为一整个不会被中断的原子操作）
- 从内存中读取值
- 测试该值是否为1
- 内存单元值设置为1
- 交换指令
- 交换内存中的两个值
使用TS指令实现自旋锁（spinlock）
class Lock{
int value = 0;
};
Lock::Acquire() {
while(test-and_set(value))
;//等待
}
Lock::Release() {
value = 0;
}- 缺点： 线程在等待的时候也会消耗CPU资源
无忙等待锁(基于上面的自旋锁的忙等待进行优化)
- 在无法进入临界区的时候，将自己的CPU使用权交出
class Lock{
int value = 0;
waitQueue q;
};
Lock::Acquire() {
while(test-and_set(value)){
add this TCB to waitQueue q;//将需要进行CPU使用的进程或线程放入等待队列
schedule();
}
}
Lock::Release() {
value = 0;
remove one thread t from waitQueue q;//将等待队列中的线程取出
wakeup(t);//唤醒等待线程队列中的线程
}- 优点
- 适用于单处理器或者共享主存的多处理器中任意数量的进程同步
- 简单且容易证明
- 支持多临界区
- 缺点
- 忙等待锁会占用CPU时间
- 可能导致饥饿
- 进程离开临界区的时候有多个进程等待的情况
- 可能会出现死锁
- 如下为一种情况：
- 拥有临界区的低优先级进程没有获得CPU资源（没法执行完自己的工作）
- 请求访问临界区的高优先级进程获得处理器资源并等待临界区（如果是执行忙等待）
- 导致两者都没法执行自己的任务，造成死锁
- 如下为一种情况：
同步方法总结
锁是一种高级的同步抽象方法
- 互斥可以使用锁来支持
- 需要硬件的支持才能使用
常用的三种同步实现方法
- 禁用中断（仅限于单处理器）
- 软件方法（复杂）
- 原子指令操作（单处理器、多处理器均可实现）
信号量
简介
- 信号量是操作系统提供的一种协调
- 软件同步是平等线程中的一种同步协商机制
- OS是管理者，地位高于进程
- 由操作系统来规定谁使用临界区资源
- 用信号量表示资源的数量
- 有Dijkstra在60年代提出
- 早期操作系统的主要同步机制
描述
- 信号量是一种抽象的数据类型
- 由一个整型变量（sem）和两个原子操作组成
- P（Prolaag（荷兰语：尝试减少））
- sem减一
- 如果sem<0，进入等待，否则继续
- V（Verhoog（荷兰语：增加））
- sem加一
- 如果sem<=0，唤醒一个处于等待状态的进程
- 信号量是被保护的整型变量
- 初始化完成后，只能通过P()和V()操作修改
- 由操作系统保证，PV操作是原子操作
- P()可能被阻塞，V()不会被阻塞
- 通常假定信号量是“公平的”
- 线程不会无限期的被阻塞在P（）操作
- 假定信号量等待是按照先进先出排队（自旋锁无法实现先进先出）
信号量的实现
class Semaphore{
int sem;
waitQueue q;
};
Semaphore::P(){
sem--;
if(sem < 0){
add this thread t to q;
block(p);//阻塞P
}
}
Semaphore::V(){
sem++;
if(sem<=0){
remove a thread t from q;
wakeup (t);
}
}信号量的分类
- 可分为两种信号量
- 二进制信号量：资源数量为0或1
- 资源信号量：资源可为任何非负数
- 两者等价
- 基于一个可以实现另一个
- 信号量的使用
- 互斥访问
- 临界区的互斥访问控制
- 条件同步
- 线程间的事件等待
- 互斥访问
用信号量实现临界区的互斥访问
mutex = new Semaphore(1);//设置资源信号量，初始值为1
mutex->P();
Criticla Section;
mutex->V();- 必须成对使用P()和V()
- P()保证互斥访问临界资源
- V()保证在使用后释放临界资源
PV 解决生产者消费者问题
生产者 –> 缓冲区 –> 消费者
- 问题分析
- 任何时刻只能有一个线程操作缓冲区(互斥访问)
- 缓存区空时，消费者必须等待生产者（条件同步）
- 缓冲区满时，生产者必须等待消费者（条件同步）
- 用信号量描述每个约束
- 二进制信号量 mutex
- 资源信号量 fullBuffers
- 资源信号量 emptyBuffers
//信号量
class BoundedBuffer{
mutex = new Semaphore(1);
fullBuffers = new Semaphore(0);
emptyBuffers = new Semaphore(n);//资源
};
//生产者
BoudedBuffer::Deposit(c){
emptyBuffers->p();
mutex->P();
Add c to the buffer;
mutex->V();
fullBuffers->V();
}
//消费者
BoudedBuffer::Deposit(c){
fullBuffers->p();
mutex->P();
Remove c from the buffer;
mutex->V();
emotyBuffers->V();
}缺点和困难
- 读写代码很难
- 程序员需要能运用信号量机制
- 容易出错
- 使用的信号量已经被另一个线程占用
- 忘记释放信号量
- 不能处理死锁问题
管程
描述
- 管程是一种用于多线程互斥访问共享资源的程序结构
- 采用面向对象方法，简化了线程间的同步控制
- 任一时刻最多只有一个线程执行管程代码
- 正在管程中的线程可临时放弃管程的互斥访问，并等待时间出现时回复
- 管程的使用
- 在对象/模块中，收集相关共享数据
- 定义访问共享数据的方法
组成
- 一个锁
- 控制管程代码的互斥访问
- 0或者多个条件变量
- 管理共享数据的并发访问
条件变量
- 条件变量是管程内的等待机制
- 进入管程的线程因为资源被占用而进入等待状态
- 每个条件变量表示一种等待原因，对应一个等待队列
- wait()操作
- 将自己阻塞在等待队列中
- 唤醒一个等待着管程释放的互斥访问
- signal()操作
- 将等待队列中的一个线程唤醒
- 如果等待队列为空，则等同空操作
条件变量实现
class Condition{
int numWaiting = 0;
WaitQueue q;
};
Condition::Wait(lock){
numWaiting++; //等待数加一
add this thread t to q;//放入等待队列
release(lock);//释放管程使用权
schedule();//执行调度
require();//完成调度后，请求管程的访问权
}
Condition::Signal(){
if(numWaiting > 0){
remove a thread t from q;
wakeup(t);
numWaiting--;
}
}
用管程解决生产者- 消费者问题
代码实现：
class BoundedBuffer{
...
Lock lock;
int count=0;
Condition notFull,notEmpty;
};
//生产者
BoudedBuffer::Deposit(c){
lock->Acquire();
while(count -- ){
notFull.Wait(&lock);
}
Add c to the buffer;
count++;
notEmpty.Signal();
lock->Release();
}
//消费者
BoudedBuffer::Deposit(c){
lock->Acquire();
while(count -- ){
notEmpty.Wait(&lock);
}
Remove c from the buffer;
count -- ;
notFull.Signal();
lock->Release();
}管程条件变量的释放处理方式
根据方式不同可分为：
- Hansen管程
- Hoare管程
4615
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
