操作系统-经典PV代码操作总结

最新推荐文章于 2022-08-19 09:30:18 发布
最新推荐文章于 2022-08-19 09:30:18 发布
阅读量2.6k 收藏 13
点赞数 1
文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38181970/article/details/80574899
版权
< 理发师 >
semphore mutex_i = 1 ,consumer = 0 ,baber = 0 ;
int i = 0 ;
seat = n
consumer ()
{
while ( 1 )
{

P (mutex_i);
if (i < n) //有座位
{
i ++ ;
V (costomer);
V (mutex_i);
P ()
}
else
{
走
V (mutex_i);
}
}

}
<!-- 叫号问题 -->
mutex_i <!-- 防止顾客拿到一个号 -->
mutex_j <!-- 防止 -->

semphore mutex_i = 1 ;
consumer ()
{
取号
P (mutex_i)
i ++ ;
V (mutex_i)
waiting...
}

seller ()
{
P (mutex_j)
if (j < i)
{
selling...
j ++
V (mutex_j)
}
else
{
V (mutex_j)
休息。。。
}
}

<!-- 银行 -->
semphore mutex_i;
consumer ()
{
P (mutex_i)
if (i < 10 )
{
i ++
}
}

<!-- 前趋图 -->
procecss P1 ()
{
P (s1)
...
V (s2)
V (s3) //释放 2 个
}
P2 ()
{
P (s2)
...
V (s4)
}
P3 ()
{
P (s3)
...
V (s4)
}
P4 ()
{
P (s4)
P (s4) //只有s4=2才可以
...
}
<!-- 十字路口 -->
semaphore s = 1 ;
process1 ()
{
while ( 1 )
{
P (s)
...
V (s)
}
}
process2 ()
{
while ( 1 )
{
P (s);
...
V (s);
}
}

semaphore s = 100 // 初始可以进入的人的个数

Process_i ()
{
P (s);
进入售票厅
出售票厅
V (s);
}





假设初始的车是停 门关闭
semaphore run = 1 //可以跑
semphore open = 0
diver () //司机进程
{
while ( 1 )
{
P (run)
开车..
停车..
V (open)
}
}

seller ()
{
while ( 1 )
{
P (open)
开门...
上乘客
关门...
V (run)
}
}

<!-- 老和尚喝水 -->
semaphore empty = n,full = 0 ;
well = 1 //互斥访问井
pail = 3 //三个水桶
vat = 1 //水缸

取水()
{
while ( 1 )
{
P (empty)
//井中取水
P (pail)
P (well)
井中打水
V (well)
P (vat)
倒入缸中
V (vat)

V (pail)
V (full)
}
}

喝水()
{
while ( 1 )
{
P (full)
P (pail)
P (vat) //互斥水缸
取水...
V (vat)
V (pail)
V (empty)

}
}

<!-- 南大三个消费者生产者问题 -->
semaphore empty = n,full = 0 ,mutex = 1 ;
R () //读入者
{
P (empty)
P (metex)
读入缓冲区...
i ++ ;
V (metex)
V (full_1)
}


M () //检验" "->";"
{
P (full_1)
P (metex)
if (B[i] == " " )
B[i] = ";"
V (metex)
V (full_2)
}

P () //打印者
{
P (full_2)
P (mutex)
cout << B[i]
V (mutex)
V (empty)
}

<!-- 理发师问题 -->
int wait = 0 ; //等待的人数
int chairs = n; //椅子
semaphore s_barber = 1 //理发师这个资源可用
semphore s_customer = 0 ;
mutex = 1 ; //互斥的座位的访问

Customer ()
{
while ( 1 )
{
P (mutex)
waiting ++ ;
if (waiting > chairs) //先看座位满不满
{
离开...
V (mutex);
}
else
{
waiting ++ ; //坐下
V (mutex);
P (s_barber) //request a haircut

V (s_consumer);
}
}
}





Barber ()
{
while ( 1 )
{
P (s_customer);
P (mutex)
waiting -- ;
剪发...
V (mutex)
V (s_barber);
}
}













<!-- 吸烟者问题的变型：零件问题 -->
semaphore offer1 = 0 //AB
offer2 = 0 //BC
offer3 = 0 //AC
finish = 0 ; //并未完成一次操作

Master () //师傅进程
{
int i = random () % 3 + 1 ; //写出随机函数
if (i == 1 )
{
V (offer1);
}
else if (i == 2 )
{
V (offer2)
}
else
{
V (offer3)
}
放到desk上...
P (finish)
}

A ()
{
while ( 1 )
P (offer2)
加工
V (finish)
}

B ()
{
while ( 1 )
P (offer3)
加工
V (finish)
}

C ()
{
while ( 1 )
P (offer1)
加工....
V (finish)
}

<! 复旦 > 文件必须有2个经理签字 方可发出
semphore sem = 2 //还需要2个经理签字
A ()
{
while ( 1 )
{
P (mutex) //互斥访问这2次 必须一起签完
P (sem)
P (sem) //签字2次
V (mutex)
发出
V (sem)
V (sem)
}
}





<!-- 北京工业大学 标志块更改 - 生产者消费者 -->
semaphore empty = 64 , full = 0 //初始64bit均是不可消费的
mutex = 1 ;
flag[ 64 ];
PUT () //生产者进程
{
P (empty)
P (mutex)
for ( int i = 0 ;i < 64 ;i ++ )
{
if (flag[i] == 1 )
{
flag[i] = 0 ;
break ;
}
}
V (mutex)
V (full)
}

GET () //消费者进程
{
P (full)
P (mutex)
for ( int i = 0 ;i < 64 ;i ++ )
{
if (flag[i] == 0 )
{
flag[i] == 1 ;
break ;
}
}
V (mutex)
V (empty)
}

<!-- 北大 读写进程 -->
semaphore write = 1 ;
semaphore read = 1 ;
semaphore mutex = 1 ;
int count = 0 ; //读者的个数
P2 () //只写
{
P (write)
write...
V (write)
}

P1 () //只读
{
while ( 1 )
{
P (mutex)
if (count == 0 ) P (write) //第一个关写门
count ++ ;
V (mutex)

reading...
//读完
P (mutex)
count -- ;
if (count == 0 ) V (write);
V (mutex)
}
}

//读和写进程
P3 ()
{
while ( 1 )
{
//先读
P (mutex)
if (count == 0 ) P (write) //第一个关写门
count ++ ;
V (mutex)

reading...

//读完
P (mutex)
count -- ;
if (count == 0 ) V (write);
V (mutex)

//后写
P (write)
writing...
V (write)
}
}
//理发师问题的变型： 北大牙医问题:
semaphore dentist = 3 ; //当前的牙医资源可用
semaphore mutex = 1 ; //互斥访问座位
int waiting = 0 ; //起始没人等候
semaphore paient = 0 ; //等待就医的病人
Patient ()
{
P (mutex)
if (waiting >= 10 ) //先检查座位
{
离开
V (mutex)
}
else
{
坐下
waiting ++
V (mutex)
P (dentist) //请求就医唤醒牙医

V (pateint)
}
}





dentist ()
{
P (patient)
P (mutex)
waiting -- ; //等候顾客减少一个
V (mutex);
看病....
V (dentist)
}


//北大酒吧听音乐问题
semaphore offer1 = 0 //电池+音乐磁带
semaphore offer2 = 0 //电池+随身听
semaphore offer3 = 0 //随身听+音乐磁带
semaphore finish = 0 ; //是否完成听歌
Boss () //老板进程
{
while ( 1 )
{
int i = radom () % 3 + 1 ; //产生随机数1-3
if (i == 1 )
{
V (offer1)
放置电池 + 音乐磁带....
}
else if (i == 2 )
{
V (offer2)
放置电池 + 随身听...
}
else
{
V (offer3)
放置随身听 + 音乐磁带
} //执行顺序是在这里转到：Listener进程
P (finish); //这里的P操作为等待听完
}
}

Listener1 ()
{
while ( 1 )
{
P (offer1) //消耗资源1
listen to the music...
V (finish) //宣告结束听歌
}
}
Listener2 ()
{
while ( 1 )
{
P (offer2) //消耗2类资源
listen to the music...
V (finish)
}
}
Listener3 ()
{
while ( 1 )
{
P (offer3)
listen to the music....
V (finish)
}
}

//华中科技大
North ()
{
P (mutex)
go thourgh the bridge...
V (mutex)
}
South ()
{
P (mutex)
go through the street...
V (mutex)
}





//可以过多辆车
semaphore bridge = 1 ; //桥的信号量
semaphore mutex_north = 1 ; //互斥信号量
semophore mutex_south = 1 ;
int count = 0 ;
North ()
{
P (mutex_north)

if (count == 0 )
P (bridge) // 将桥上锁
count ++ ;

V (mutex_north)
go though the bridge...

P (mutex_north)

count -- ;
if (count == 0 )
V (brigde);

V (mutex_north)
}

South ()
{
P (mutex_south)
if (count == 0 )
P (bridge)
count ++ ;
V (mutex_south)

go through the bridge...

P (mutex_south)
count -- ;
if (count == 0 )
V (bridge)
V (mutex_south)
}


//南大 存钱取钱流程
semaphore mutex = 1 ; //互斥访问账户的信号量
semphore take save;
save ()
{
while ( 1 )
{

P (mutex)

m1 = amount
m1 =+ 10
amount =+ m1
V (mutex)
V (take) //可以取钱
}
}









take ()
{
while ( 1 )
{
P (take) //请求取钱
P (mutex)

m2 = amount
m2 =+ 10
amount = m2

V (mutex)
}

}
< 理发师 >
semphore mutex_i = 1 ,consumer = 0 ,baber = 0 ;
int i = 0 ;
seat = n
consumer ()
{
while ( 1 )
{

P (mutex_i);
if (i < n) //有座位
{
i ++ ;
V (costomer);
V (mutex_i);
P ()
}
else
{
走
V (mutex_i);
}
}

}
<!-- 叫号问题 -->
mutex_i <!-- 防止顾客拿到一个号 -->
mutex_j <!-- 防止 -->

semphore mutex_i = 1 ;
consumer ()
{
取号
P (mutex_i)
i ++ ;
V (mutex_i)
waiting...
}

seller ()
{
P (mutex_j)
if (j < i)
{
selling...
j ++
V (mutex_j)
}
else
{
V (mutex_j)
休息。。。
}
}

<!-- 银行 -->
semphore mutex_i;
consumer ()
{
P (mutex_i)
if (i < 10 )
{
i ++
}
}

<!-- 前趋图 -->
procecss P1 ()
{
P (s1)
...
V (s2)
V (s3) //释放 2 个
}
P2 ()
{
P (s2)
...
V (s4)
}
P3 ()
{
P (s3)
...
V (s4)
}
P4 ()
{
P (s4)
P (s4) //只有s4=2才可以
...
}
<!-- 十字路口 -->
semaphore s = 1 ;
process1 ()
{
while ( 1 )
{
P (s)
...
V (s)
}
}
process2 ()
{
while ( 1 )
{
P (s);
...
V (s);
}
}

semaphore s = 100 // 初始可以进入的人的个数

Process_i ()
{
P (s);
进入售票厅
出售票厅
V (s);
}





假设初始的车是停 门关闭
semaphore run = 1 //可以跑
semphore open = 0
diver () //司机进程
{
while ( 1 )
{
P (run)
开车..
停车..
V (open)
}
}

seller ()
{
while ( 1 )
{
P (open)
开门...
上乘客
关门...
V (run)
}
}

<!-- 老和尚喝水 -->
semaphore empty = n,full = 0 ;
well = 1 //互斥访问井
pail = 3 //三个水桶
vat = 1 //水缸

取水()
{
while ( 1 )
{
P (empty)
//井中取水
P (pail)
P (well)
井中打水
V (well)
P (vat)
倒入缸中
V (vat)

V (pail)
V (full)
}
}

喝水()
{
while ( 1 )
{
P (full)
P (pail)
P (vat) //互斥水缸
取水...
V (vat)
V (pail)
V (empty)

}
}

<!-- 南大三个消费者生产者问题 -->
semaphore empty = n,full = 0 ,mutex = 1 ;
R () //读入者
{
P (empty)
P (metex)
读入缓冲区...
i ++ ;
V (metex)
V (full_1)
}


M () //检验" "->";"
{
P (full_1)
P (metex)
if (B[i] == " " )
B[i] = ";"
V (metex)
V (full_2)
}

P () //打印者
{
P (full_2)
P (mutex)
cout << B[i]
V (mutex)
V (empty)
}

<!-- 理发师问题 -->
int wait = 0 ; //等待的人数
int chairs = n; //椅子
semaphore s_barber = 1 //理发师这个资源可用
semphore s_customer = 0 ;
mutex = 1 ; //互斥的座位的访问

Customer ()
{
while ( 1 )
{
P (mutex)
waiting ++ ;
if (waiting > chairs) //先看座位满不满
{
离开...
V (mutex);
}
else
{
waiting ++ ; //坐下
V (mutex);
P (s_barber) //request a haircut

V (s_consumer);
}
}
}





Barber ()
{
while ( 1 )
{
P (s_customer);
P (mutex)
waiting -- ;
剪发...
V (mutex)
V (s_barber);
}
}













<!-- 吸烟者问题的变型：零件问题 -->
semaphore offer1 = 0 //AB
offer2 = 0 //BC
offer3 = 0 //AC
finish = 0 ; //并未完成一次操作

Master () //师傅进程
{
int i = random () % 3 + 1 ; //写出随机函数
if (i == 1 )
{
V (offer1);
}
else if (i == 2 )
{
V (offer2)
}
else
{
V (offer3)
}
放到desk上...
P (finish)
}

A ()
{
while ( 1 )
P (offer2)
加工
V (finish)
}

B ()
{
while ( 1 )
P (offer3)
加工
V (finish)
}

C ()
{
while ( 1 )
P (offer1)
加工....
V (finish)
}

<! 复旦 > 文件必须有2个经理签字 方可发出
semphore sem = 2 //还需要2个经理签字
A ()
{
while ( 1 )
{
P (mutex) //互斥访问这2次 必须一起签完
P (sem)
P (sem) //签字2次
V (mutex)
发出
V (sem)
V (sem)
}
}





<!-- 北京工业大学 标志块更改 - 生产者消费者 -->
semaphore empty = 64 , full = 0 //初始64bit均是不可消费的
mutex = 1 ;
flag[ 64 ];
PUT () //生产者进程
{
P (empty)
P (mutex)
for ( int i = 0 ;i < 64 ;i ++ )
{
if (flag[i] == 1 )
{
flag[i] = 0 ;
break ;
}
}
V (mutex)
V (full)
}

GET () //消费者进程
{
P (full)
P (mutex)
for ( int i = 0 ;i < 64 ;i ++ )
{
if (flag[i] == 0 )
{
flag[i] == 1 ;
break ;
}
}
V (mutex)
V (empty)
}

<!-- 北大 读写进程 -->
semaphore write = 1 ;
semaphore read = 1 ;
semaphore mutex = 1 ;
int count = 0 ; //读者的个数
P2 () //只写
{
P (write)
write...
V (write)
}

P1 () //只读
{
while ( 1 )
{
P (mutex)
if (count == 0 ) P (write) //第一个关写门
count ++ ;
V (mutex)

reading...
//读完
P (mutex)
count -- ;
if (count == 0 ) V (write);
V (mutex)
}
}

//读和写进程
P3 ()
{
while ( 1 )
{
//先读
P (mutex)
if (count == 0 ) P (write) //第一个关写门
count ++ ;
V (mutex)

reading...

//读完
P (mutex)
count -- ;
if (count == 0 ) V (write);
V (mutex)

//后写
P (write)
writing...
V (write)
}
}
//理发师问题的变型： 北大牙医问题:
semaphore dentist = 3 ; //当前的牙医资源可用
semaphore mutex = 1 ; //互斥访问座位
int waiting = 0 ; //起始没人等候
semaphore paient = 0 ; //等待就医的病人
Patient ()
{
P (mutex)
if (waiting >= 10 ) //先检查座位
{
离开
V (mutex)
}
else
{
坐下
waiting ++
V (mutex)
P (dentist) //请求就医唤醒牙医

V (pateint)
}
}





dentist ()
{
P (patient)
P (mutex)
waiting -- ; //等候顾客减少一个
V (mutex);
看病....
V (dentist)
}


//北大酒吧听音乐问题
semaphore offer1 = 0 //电池+音乐磁带
semaphore offer2 = 0 //电池+随身听
semaphore offer3 = 0 //随身听+音乐磁带
semaphore finish = 0 ; //是否完成听歌
Boss () //老板进程
{
while ( 1 )
{
int i = radom () % 3 + 1 ; //产生随机数1-3
if (i == 1 )
{
V (offer1)
放置电池 + 音乐磁带....
}
else if (i == 2 )
{
V (offer2)
放置电池 + 随身听...
}
else
{
V (offer3)
放置随身听 + 音乐磁带
} //执行顺序是在这里转到：Listener进程
P (finish); //这里的P操作为等待听完
}
}

Listener1 ()
{
while ( 1 )
{
P (offer1) //消耗资源1
listen to the music...
V (finish) //宣告结束听歌
}
}
Listener2 ()
{
while ( 1 )
{
P (offer2) //消耗2类资源
listen to the music...
V (finish)
}
}
Listener3 ()
{
while ( 1 )
{
P (offer3)
listen to the music....
V (finish)
}
}

//华中科技大
North ()
{
P (mutex)
go thourgh the bridge...
V (mutex)
}
South ()
{
P (mutex)
go through the street...
V (mutex)
}





//可以过多辆车
semaphore bridge = 1 ; //桥的信号量
semaphore mutex_north = 1 ; //互斥信号量
semophore mutex_south = 1 ;
int count = 0 ;
North ()
{
P (mutex_north)

if (count == 0 )
P (bridge) // 将桥上锁
count ++ ;

V (mutex_north)
go though the bridge...

P (mutex_north)

count -- ;
if (count == 0 )
V (brigde);

V (mutex_north)
}

South ()
{
P (mutex_south)
if (count == 0 )
P (bridge)
count ++ ;
V (mutex_south)

go through the bridge...

P (mutex_south)
count -- ;
if (count == 0 )
V (bridge)
V (mutex_south)
}


//南大 存钱取钱流程
semaphore mutex = 1 ; //互斥访问账户的信号量
semphore take save;
save ()
{
while ( 1 )
{

P (mutex)

m1 = amount
m1 =+ 10
amount =+ m1
V (mutex)
V (take) //可以取钱
}
}









take ()
{
while ( 1 )
{
P (take) //请求取钱
P (mutex)

m2 = amount
m2 =+ 10
amount = m2

V (mutex)
}

}
< 理发师 >
semphore mutex_i = 1 ,consumer = 0 ,baber = 0 ;
int i = 0 ;
seat = n
consumer ()
{
while ( 1 )
{

P (mutex_i);
if (i < n) //有座位
{
i ++ ;
V (costomer);
V (mutex_i);
P ()
}
else
{
走
V (mutex_i);
}
}

}
<!-- 叫号问题 -->
mutex_i <!-- 防止顾客拿到一个号 -->
mutex_j <!-- 防止 -->

semphore mutex_i = 1 ;
consumer ()
{
取号
P (mutex_i)
i ++ ;
V (mutex_i)
waiting...
}

seller ()
{
P (mutex_j)
if (j < i)
{
selling...
j ++
V (mutex_j)
}
else
{
V (mutex_j)
休息。。。
}
}

<!-- 银行 -->
semphore mutex_i;
consumer ()
{
P (mutex_i)
if (i < 10 )
{
i ++
}
}

<!-- 前趋图 -->
procecss P1 ()
{
P (s1)
...
V (s2)
V (s3) //释放 2 个
}
P2 ()
{
P (s2)
...
V (s4)
}
P3 ()
{
P (s3)
...
V (s4)
}
P4 ()
{
P (s4)
P (s4) //只有s4=2才可以
...
}
<!-- 十字路口 -->
semaphore s = 1 ;
process1 ()
{
while ( 1 )
{
P (s)
...
V (s)
}
}
process2 ()
{
while ( 1 )
{
P (s);
...
V (s);
}
}

semaphore s = 100 // 初始可以进入的人的个数

Process_i ()
{
P (s);
进入售票厅
出售票厅
V (s);
}





假设初始的车是停 门关闭
semaphore run = 1 //可以跑
semphore open = 0
diver () //司机进程
{
while ( 1 )
{
P (run)
开车..
停车..
V (open)
}
}

seller ()
{
while ( 1 )
{
P (open)
开门...
上乘客
关门...
V (run)
}
}

<!-- 老和尚喝水 -->
semaphore empty = n,full = 0 ;
well = 1 //互斥访问井
pail = 3 //三个水桶
vat = 1 //水缸

取水()
{
while ( 1 )
{
P (empty)
//井中取水
P (pail)
P (well)
井中打水
V (well)
P (vat)
倒入缸中
V (vat)

V (pail)
V (full)
}
}

喝水()
{
while ( 1 )
{
P (full)
P (pail)
P (vat) //互斥水缸
取水...
V (vat)
V (pail)
V (empty)

}
}

<!-- 南大三个消费者生产者问题 -->
semaphore empty = n,full = 0 ,mutex = 1 ;
R () //读入者
{
P (empty)
P (metex)
读入缓冲区...
i ++ ;
V (metex)
V (full_1)
}


M () //检验" "->";"
{
P (full_1)
P (metex)
if (B[i] == " " )
B[i] = ";"
V (metex)
V (full_2)
}

P () //打印者
{
P (full_2)
P (mutex)
cout << B[i]
V (mutex)
V (empty)
}

<!-- 理发师问题 -->
int wait = 0 ; //等待的人数
int chairs = n; //椅子
semaphore s_barber = 1 //理发师这个资源可用
semphore s_customer = 0 ;
mutex = 1 ; //互斥的座位的访问

Customer ()
{
while ( 1 )
{
P (mutex)
waiting ++ ;
if (waiting > chairs) //先看座位满不满
{
离开...
V (mutex);
}
else
{
waiting ++ ; //坐下
V (mutex);
P (s_barber) //request a haircut

V (s_consumer);
}
}
}





Barber ()
{
while ( 1 )
{
P (s_customer);
P (mutex)
waiting -- ;
剪发...
V (mutex)
V (s_barber);
}
}













<!-- 吸烟者问题的变型：零件问题 -->
semaphore offer1 = 0 //AB
offer2 = 0 //BC
offer3 = 0 //AC
finish = 0 ; //并未完成一次操作

Master () //师傅进程
{
int i = random () % 3 + 1 ; //写出随机函数
if (i == 1 )
{
V (offer1);
}
else if (i == 2 )
{
V (offer2)
}
else
{
V (offer3)
}
放到desk上...
P (finish)
}

A ()
{
while ( 1 )
P (offer2)
加工
V (finish)
}

B ()
{
while ( 1 )
P (offer3)
加工
V (finish)
}

C ()
{
while ( 1 )
P (offer1)
加工....
V (finish)
}

<! 复旦 > 文件必须有2个经理签字 方可发出
semphore sem = 2 //还需要2个经理签字
A ()
{
while ( 1 )
{
P (mutex) //互斥访问这2次 必须一起签完
P (sem)
P (sem) //签字2次
V (mutex)
发出
V (sem)
V (sem)
}
}





<!-- 北京工业大学 标志块更改 - 生产者消费者 -->
semaphore empty = 64 , full = 0 //初始64bit均是不可消费的
mutex = 1 ;
flag[ 64 ];
PUT () //生产者进程
{
P (empty)
P (mutex)
for ( int i = 0 ;i < 64 ;i ++ )
{
if (flag[i] == 1 )
{
flag[i] = 0 ;
break ;
}
}
V (mutex)
V (full)
}

GET () //消费者进程
{
P (full)
P (mutex)
for ( int i = 0 ;i < 64 ;i ++ )
{
if (flag[i] == 0 )
{
flag[i] == 1 ;
break ;
}
}
V (mutex)
V (empty)
}

<!-- 北大 读写进程 -->
semaphore write = 1 ;
semaphore read = 1 ;
semaphore mutex = 1 ;
int count = 0 ; //读者的个数
P2 () //只写
{
P (write)
write...
V (write)
}

P1 () //只读
{
while ( 1 )
{
P (mutex)
if (count == 0 ) P (write) //第一个关写门
count ++ ;
V (mutex)

reading...
//读完
P (mutex)
count -- ;
if (count == 0 ) V (write);
V (mutex)
}
}

//读和写进程
P3 ()
{
while ( 1 )
{
//先读
P (mutex)
if (count == 0 ) P (write) //第一个关写门
count ++ ;
V (mutex)

reading...

//读完
P (mutex)
count -- ;
if (count == 0 ) V (write);
V (mutex)

//后写
P (write)
writing...
V (write)
}
}
//理发师问题的变型： 北大牙医问题:
semaphore dentist = 3 ; //当前的牙医资源可用
semaphore mutex = 1 ; //互斥访问座位
int waiting = 0 ; //起始没人等候
semaphore paient = 0 ; //等待就医的病人
Patient ()
{
P (mutex)
if (waiting >= 10 ) //先检查座位
{
离开
V (mutex)
}
else
{
坐下
waiting ++
V (mutex)
P (dentist) //请求就医唤醒牙医

V (pateint)
}
}





dentist ()
{
P (patient)
P (mutex)
waiting -- ; //等候顾客减少一个
V (mutex);
看病....
V (dentist)
}


//北大酒吧听音乐问题
semaphore offer1 = 0 //电池+音乐磁带
semaphore offer2 = 0 //电池+随身听
semaphore offer3 = 0 //随身听+音乐磁带
semaphore finish = 0 ; //是否完成听歌
Boss () //老板进程
{
while ( 1 )
{
int i = radom () % 3 + 1 ; //产生随机数1-3
if (i == 1 )
{
V (offer1)
放置电池 + 音乐磁带....
}
else if (i == 2 )
{
V (offer2)
放置电池 + 随身听...
}
else
{
V (offer3)
放置随身听 + 音乐磁带
} //执行顺序是在这里转到：Listener进程
P (finish); //这里的P操作为等待听完
}
}

Listener1 ()
{
while ( 1 )
{
P (offer1) //消耗资源1
listen to the music...
V (finish) //宣告结束听歌
}
}
Listener2 ()
{
while ( 1 )
{
P (offer2) //消耗2类资源
listen to the music...
V (finish)
}
}
Listener3 ()
{
while ( 1 )
{
P (offer3)
listen to the music....
V (finish)
}
}

//华中科技大
North ()
{
P (mutex)
go thourgh the bridge...
V (mutex)
}
South ()
{
P (mutex)
go through the street...
V (mutex)
}





//可以过多辆车
semaphore bridge = 1 ; //桥的信号量
semaphore mutex_north = 1 ; //互斥信号量
semophore mutex_south = 1 ;
int count = 0 ;
North ()
{
P (mutex_north)

if (count == 0 )
P (bridge) // 将桥上锁
count ++ ;

V (mutex_north)
go though the bridge...

P (mutex_north)

count -- ;
if (count == 0 )
V (brigde);

V (mutex_north)
}

South ()
{
P (mutex_south)
if (count == 0 )
P (bridge)
count ++ ;
V (mutex_south)

go through the bridge...

P (mutex_south)
count -- ;
if (count == 0 )
V (bridge)
V (mutex_south)
}


//南大 存钱取钱流程
semaphore mutex = 1 ; //互斥访问账户的信号量
semphore take save;
save ()
{
while ( 1 )
{

P (mutex)

m1 = amount
m1 =+ 10
amount =+ m1
V (mutex)
V (take) //可以取钱
}
}









take ()
{
while ( 1 )
{
P (take) //请求取钱
P (mutex)

m2 = amount
m2 =+ 10
amount = m2

V (mutex)
}

}

Buerle
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统中的PV操作
weixin_46577581的博客
10-07 8614
PV操作起源： 1962年，荷兰学者Dijksrta在参与X8计算机的开发中设计并实现了具有多道程序运行能力的操作系统——THE Multiprogramming System。为了解决这个操作系统中进程（线程）的同步与互斥问题，他巧妙地利用火车运行控制系统中的“信号灯”（semaphore，或叫“信号量”）概念加以解决。信号量的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，这个信号量的值仅能由PV操作来改变。 PV操作概念： 操作系统中的一种同步机制，实
操作系统作业三：PV操作
zijin-jdd的博客
05-09 1890
文章目录作业1作业2 作业1 题目：桌上有一空盘，只允许存放一个水果。爸爸专向盘中放橙子,妈妈专向盘中放苹果，女儿专等吃橙子，儿子专等吃苹果。规定当盘空时一次只能放一个水果供吃者自用,请用PV操作实现爸爸、妈妈、女儿、儿子四个并发进程的同步。 【答】 设计四个信号量metux,empty、orange、apple； metux表示：爸爸、妈妈、儿子和女儿进程对盘子的互斥使用； empty表示：盘子是否为空； apple表示：是否可以取苹果； orange表示：是否可以取橙子。 伪代码描述如下： sema
操作系统PV操作伪代码（小和尚提水、老和尚饮水问题）
zhan_qian的博客
04-16 4007
题目： 某寺庙，有小和尚、老和尚若干。庙内有一水缸，由小和尚提水入缸，供老和尚饮用。水缸可容纳10桶水，每次入水、取水仅为1桶，不可同时进行。水取自同一井中，水井径窄，每次只能容纳一个水桶取水。设水桶个数为3个，试用信号量和PV操作给出老和尚和小和尚的活动。 提示：从井中取水并放入水缸是一个连续的动作可以视为一个进程，从缸中取水为另一个进程。 设水井和水缸为临界资源，引入mutex1,mutex2；三个水桶无论从井中取水还是放入 水缸中都一次一个，应该给他们一个信号量count，...
计算机操作系统的pv是什么意思,计算机操作系统关于PV操作的一道题
weixin_39705794的博客
07-19 552
满意答案sbx19012014.06.02采纳率：41%等级：9已帮助：113人//算法描述语言使用基于C语言的伪代码//算法思想：根据楼主的要求“为防止数的丢失和重复取同一个数”可以看出，进程A、进程B、进程C三者之间应该是互斥的关系。那么问题所限定的使用信号量的方式来管理的潜藏意思，就是要利用PV原语实现并发进程在资源争夺中有效互斥。//而具体实现的目标是“防止数的丢失”和“重复取同一...
PV操作的实现（源代码＋报告）
06-09
本资源包括PV操作的源代码和报告，通过PV操作实现同步机制
王道数据结构-线性表中顺序表的一些综合应用题 王道操作系统-PV操作综合大题总结
12-31
在本文中，我们将探讨线性表中顺序表的几种综合应用问题，以及如何使用C++来实现这些操作。顺序表是一种基本的数据结构，它在线性表中存储元素的方式是连续的内存空间。这里我们主要关注如何在顺序表中进行高效地...
操作系统课程设计-linux系统下实现PV操作.docx
06-30
“操作系统课程设计-linux系统下实现PV操作” 本文主要介绍了 Linux 操作系统下的 PV 操作实现，涵盖了 Linux 系统的基本使用、线程和进程的同步方法、信号量和互斥量的应用等知识点。 一、Linux 系统简单使用 ...
操作系统实验 5 信号量的实现和应用.docx
01-02
操作系统实验报告——信号量的实现和应用 在操作系统中，信号量是一种重要的同步机制，用于管理并发进程间的访问控制和资源分配。实验5主要关注如何使用信号量解决经典的生产者-消费者问题，以及如何在Linux内核中...
操作系统复习提纲及经典习题.pdf
01-04
总结来说，操作系统复习提纲涵盖了操作系统的基本概念、类型、功能、进程管理、同步与通信、资源调度等多个方面，这些都是理解和学习操作系统的关键知识点。掌握这些内容对于从事IT行业的人员至关重要，因为操作系统...
操作系统指导书
11-30
操作系统是计算机科学中的核心课程，它涉及到计算机系统如何管理和协调硬件资源，以及为用户提供服务的基础。本指导书主要关注操作系统的几个关键概念，包括进程、线程和文件系统，这些都是操作系统实现多任务处理、...
操作系统PV操作
12-10
操作系统的PV操作，由C语言实现。桌上有一盘子，可以存放一个水果。爸爸总是放苹果到盘子中，而妈妈总是放香蕉到盘子中；一个儿子专等吃盘中的香蕉，一个女儿专等吃盘中的苹果。用P，V操作实现上述问题的解。
PV操作1
08-08
在给定的代码示例中，...总结来说，这段代码展示了如何使用线程锁和管道来解决生产者-消费者问题，并引出了对经典 `PV` 操作的模拟以及其潜在的问题。在实际应用中，可能需要进一步优化以提高系统的并发性能和稳定性。
操作系统05本B带答案[总结].pdf
10-12
操作系统是计算机系统的核心组成部分，它负责管理和协调计算机硬件和软件资源，以提供高效、可靠的服务。以下是一些操作系统相关的知识点，主要基于题目中的内容： 1. **进程状态转换**：进程有三种基本状态——...
计算机操作系统考试重点习题集.doc
06-19
总结，计算机操作系统涉及众多核心概念，如并发性、共享性、虚拟化、同步和通信机制等。理解并掌握这些知识点对于学习和理解操作系统的工作原理至关重要，也是操作系统考试的重点。通过深入学习和实践，可以提升解决...
计算机操作系统复习知识点汇总.doc
10-03
总结，操作系统复习涵盖了从基础概念到高级特性，包括进程管理、存储管理、设备管理、文件管理等多个方面。理解这些知识点，不仅有助于通过考试，更能深入理解操作系统如何支持和驱动计算机系统高效运行。
操作系统-进程PV操作
weixin_43585822的博客
07-29 1684
V主要特点，激活进程，但程序运行到V的时候，判断是否有激活的进程，如有激活的，就激活，这时分是否是抢占式的，如果是抢占式，被激活的进程先执行，非抢占式的则做V操作的当前进程先执行，没有激活的继续就继续执行当前进程。如S1初始值是1，P(S1)后，S1=S1-1=-1，这时候就阻塞进程，1表示当前有一个进程正在执行，后续动作阻塞挂起，等待激活，如何进行激活，需要通过V进行控制，举个去饭店吃菜的粒子，点了一份菜，只有厨师烧好菜，把菜盛到碗里，客人才有菜吃，否则客人吃不到菜。...
Semaphore
asade12345的博客
12-12 270
Semaphore 　　并发编程领域的先锋人物 Edsger Dijkstra（没错，也是最短路径算法的作者）在 1965 年首次提出了信号量（ Semaphores） 这一概念来解决线程同步的问题。信号量是一种特殊的变量类型，为非负整数，只有两个特殊操作PV： P(s) 如果 s!=0，将 s-1；否则将当前线程挂起，直到 s 变为非零 　　V(s) 将 s+1，如果有线程堵塞在 P 操作等待 ...
软件设计师考试—第四章 操作系统知识
HiGirl0802的博客
08-19 1783
软件设计师考试-第四章 操作系统知识
秒杀多线程第十二篇 多线程同步内功心法——PV操作上
huobengluantiao8
06-11 982
阅读本篇之前推荐阅读以下姊妹篇： 《秒杀多线程第四篇一个经典的多线程同步问题》 《秒杀多线程第五篇经典线程同步关键段CS》 《秒杀多线程第六篇经典线程同步事件Event》 《秒杀多线程第七篇经典线程同步互斥量Mutex》 《秒杀多线程第八篇经典线程同步信号量Semaphore》 《秒杀多线程第九篇经典线程同步总结关键段事件互斥量信号量》 《秒杀多线程第十篇生产者消费者问题》 《秒杀多线程第十一篇读...
操作系统打印机pv代码linux
最新发布
04-14
在Linux操作系统中，可以使用信号量（Semaphore）来实现进程间的互斥访问共享资源，例如打印机。下面是一个简单的示例代码，演示了如何使用PV操作来实现多个进程共享一台打印机的互斥访问[^1]： ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/sem.h> #define KEY 1234 void P(int semid) { struct sembuf buf; buf.sem_num = 0; buf.sem_op = -1; buf.sem_flg = SEM_UNDO; semop(semid, &buf, 1); } void V(int semid) { struct sembuf buf; buf.sem_num = 0; buf.sem_op = 1; buf.sem_flg = SEM_UNDO; semop(semid, &buf, 1); } int main() { int semid; pid_t pid; // 创建信号量 semid = semget(KEY, 1, IPC_CREAT | 0666); if (semid == -1) { perror("semget"); exit(1); } // 初始化信号量 semctl(semid, 0, SETVAL, 1); // 创建子进程 pid = fork(); if (pid == -1) { perror("fork"); exit(1); } if (pid == 0) { // 子进程 P(semid); // 进入临界区 printf("Child process is printing...\n"); sleep(2); // 模拟打印过程 printf("Child process finished printing.\n"); V(semid); // 离开临界区 } else { // 父进程 P(semid); // 进入临界区 printf("Parent process is printing...\n"); sleep(2); // 模拟打印过程 printf("Parent process finished printing.\n"); V(semid); // 离开临界区 } // 删除信号量 semctl(semid, 0, IPC_RMID); return 0; } ``` 这段代码使用了System V信号量机制，通过`semget`函数创建一个信号量集合，然后使用`semctl`函数初始化信号量的值为1。在子进程和父进程中，分别调用`P`函数和`V`函数来实现进入和离开临界区的操作。其中，`P`函数将信号量的值减1，如果信号量的值小于0，则进程被阻塞；`V`函数将信号量的值加1，如果有进程因为等待信号量而被阻塞，则唤醒其中一个进程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值