标签：com 问题： i+1 code ade 互斥量 出现 process 增加
以下出现代码均为伪代码；
分析上图：缓冲区存在互斥问题，生产者与消费者之间还 存在同步问题
??假定在生产者和消费者之间的共用缓冲池中具有n个缓冲区，这时可以利用互斥信号量mutex（初始值 1 ）实现进程对缓冲池的互斥作用；利用信号量empty（初始值为n）和full（初始值为0）分别表示缓冲池中空缓冲区和满缓冲区的数量。
??又假定这些生产者和消费者相互等效，置业总缓冲区未满，生产者便可将消息送入缓冲池中，只要缓冲池没空，消费者便可从缓冲池中取走一个消息
semaphore mutex =1; //缓冲区互斥操作的互斥信号量
semaphore empty = n; //空缓冲区数目,类型为资源信号量
semaphore full = 0; //满缓冲区为数目，类型为资源信号量
item buffer[n]
int in =0,out =0;
producer() //生产者进程
{
while(1)
{
produce an item nextp;
P(empty); //empty - 1,资源信号量又有同步作用
P(mutex); //加锁————>当多个生产者的时候要互斥访问
buffer[in] = nextp;
in = (in+1)%n; //循环队列
V(mutex); //解锁
V(full); //full + 1
}
}
consumer() //消费者进程
{
while(1)
{
P(full); //full - 1
P(mutex); //加锁————>当多个消费者的时候要互斥访问
nextc = buffer[out];
out = (out+1)%n; //循环队列
V(mutex); //解锁
V(empty); //full + 1
consumer the item in nextc;
}
}
注：
（1）empty + full = n ;
（2）若多个P操作颠倒，可能会存在死锁问题。
对于生产者-消费者问题，也可以利用AND信号量来解决，即：
semaphore mutex =1; //缓冲区互斥操作的互斥信号量
semaphore empty = n; //空缓冲区数目,类型为资源信号量
semaphore full = 0; //满缓冲区为数目，类型为资源信号量
item buffer[n]
int in =0,out =0;
producer() //生产者进程
{
while(1)
{
produce an item nextp;
Swait(empty,mutex)
buffer[in] = nextp;
in = (in+1)%n; //循环队列
Ssignal(empty,mutex); //解锁
}
}
consumer() //消费者进程
{
while(1)
{
Swait(full,mutex)
nextc = buffer[out];
out = (out+1)%n; //循环队列
Ssignal(empty,mutex)
consumer the item in nextc;
}
}
建立一个管程，并命名为producerconsumer，或简称PC。其中包括两个过程：
（1）put(x)过程。生产者利用该过程将自己生产的产品放到缓冲池中，并用整型变量count来表示在缓冲池中已有的产品数目，当count >= n 时，表示缓冲池已满，生产者等待。（也就意味需要有2个条件变量）
（2）get(x)过程。消费者利用该过程从缓冲池中取出一个产品，当count <= 0 时，表示缓冲池中已经无可取用的产品，消费者等待。
对于条件变量notfull 和 notempty,分别有两个过程cwait 和 csignal对它们进行操作：
（1）cwait(condition)过程：当管程被一个进程占用时，其他进程调用该过程时阻塞，并挂在条件condition 的队列上
（2）csignal(condition)过程：唤醒在cwait执行后阻塞在条件 condition 队列上的进程，如果这样的进程不止一个，则选择其中一个实施唤醒操作；如果队列为空，则无操作而返回
monitor producer-consumer //类似于一个类
{
int in=0,out=0,count=0;
itm buffer[n];
condition notfull,notempty;
void put(item nextp)
{
if count >= n then
cwait (notfull)
buffer [in]=nextp;
in= (in+1)%n;
count =count +1;
csignal(notempty);
}
void get(item *x)
{
if count <= 0 then
cwait (notempty)
*x=buffer[out];
out= (out+1)%n;
count =count - 1;
csignal(notfull); //告诉生产者你可以生产了
}
}PC;
//利用管程解决生产者-消费者问题
process producer()
{
item x;
while (TRUE)
{
produce an item in x;
PC.put(item); //相当于调用方法
}
}
process consumer()
{
item x;
while (TRUE)
{
PC.get(item);
consumer an item in x;
}
}
??5个哲学家坐在桌子边，桌上有 5 个碗和 5 只筷子，哲学家的生活方式是交替的进行思考和进餐，哲学家饥饿时便拿起两边的筷子进餐，但只有当拿到两只筷子后才能进餐，用餐完毕放下筷子，继续思考。
小提取：
?筷子对应临界资源，在一段时间内只允许一位哲学家使用。为实现筷子的互斥使用，可以用一个信号量表示一只筷子，由这五个信号量构成信号量数组。————> semaphore chopstick[5];
??至多只允许四位哲学家同时去拿左边的筷子，最终能保证至少有一位哲学家能够进餐，并且吃完后，释放两只筷子
semaphore chopstick[5]={1，1，1，1，1};
semaphore eating = 4; //仅允许四个哲学家可以进餐
void philosopher(int i) // 第 i 位哲学家的活动可以描述为
{
while( 1 )
{
P(eating); //请求就餐，若是第五个则先挨饿
P(chopstick[i]); //画个圈你就知道，这是他左手边的筷子
P(chopstick[i+1] % 5);
eating(); //进餐
V(chopstick[i+1] % 5); //释放右边筷子
V(chopstick[i]); //释放左边
V(eating); //释放信号量给其他哲学家
}
}
??仅当哲学家的左、右两只筷子均可用的时候，才可以进餐
semaphore chopstick[5]={1，1，1，1，1};
semaphore mutex = 1; //设置取筷子的信号量
void philosopher(int i) // 第 i 位哲学家的活动可以描述为
{
while( 1 )
{
thinking();
P(mutex); //在取筷子前获得互斥量
P(chopstick[i]); //画个圈你就知道，这是他左手边的筷子
P(chopstick[i+1] % 5);
V(mutex); //释放互斥量
eating(); //进餐
V(chopstick[i+1] % 5); //释放右边筷子
V(chopstick[i]); //释放左边
}
}
??规定奇数号（1，3，5）哲学家先拿起左边筷子，然后再去拿右边筷子，而偶数（）2，4哲学家则相反，即五位哲学家先竞争奇数筷子，获得后再去竞争偶数筷子，最后总会由一位哲学家能过获得两只筷子而就餐，下图是哲学家抢奇数筷子图示。
semaphore chopstick[5]={1，1，1，1，1};
semaphore mutex = 1; //设置取筷子的信号量
void philosopher(int i) // 第 i 位哲学家的活动可以描述为
{
while( 1 )
{
thinking();
if (i%2==0) //偶数哲学家，先右后左
{
P(chopstick[i+1] % 5);
P(chopstick[i]);
eating(); //进餐
V(chopstick[i+1] % 5); //释放右边筷子
V(chopstick[i]);
}
else
{
P(chopstick[i]);
P(chopstick[i+1] % 5);
eating(); //进餐
V(chopstick[i]);
V(chopstick[i+1] % 5); //释放右边筷子
}
}
}
??要求每个哲学家先获得两个临界资源（筷子）后方能进餐，本质就是AND同步问题，故用 AND 信号量机制解决哲学家进餐问题是最简洁的解法
semaphore chopstick[5]={1，1，1，1，1};
process(i)
{
while(1)
{
think;
Swait(chopstick[i+1] % 5,chopstick[i]); //把两个筷子全拿起来
eat;
Ssignal(chopstick[i+1] % 5,chopstick[i]);
}
}
注：读者变形（自主命题）
??一个数据文件或记录可被多个进程共享，只要求读该文件的进程称为“Reader 进程”，其他进程为“Writer 进程”，允许多个进程同时读一个共享对象，因为读不会使数据文件混乱，不允许一个Writer 进程和其他Reader 进程或Writer 进程同时访问一个对象。
??读者 - 写者问题：是保证一个Writer 进程必须与其他进程互斥访问共享对象的同步问题。
&emsp:?为实现Reader 和 Writer 进程间在读或写时的互斥而设置了一个互斥信号量 Wmutex.设置一个整型变量 Readcount 表示正在读的进程数目，由于只要一个 Reader 进程在读，便不允许 Writer 进程去写。
semaphore rmutex = 1,wmutex = 1; //readcount 和文件的互斥信号量
int readcount=0;
Reader() //这种方式用于——>独木桥问题
{
while(1)
{
P(rmutex); //允许多个进程同时读一个共享对象
if (readcount == 0)
P(wmutex); //缓冲区互斥
readcount ++;
V(rmutex);
perform read operation;
P(rmutex);
readcount --;
if (readcount == 0)
V(wmutex);
V(rmutex);
}
}
Writer()
{
while(1)
{
P(wmutex);
perform write operation;
V(wmutex);
}
}
说个简单问题， 读者 - 写者 问题相当于一个班用自习室抢房间，第一个人来了就开始占房间使用，陆续班上同学进入教室自习，当自习结束且直到最后一个人走了，这个房间不再使用
??增加一个限制，最多只允许RN个读者同时都。为此引入一个信号量L，并赋予初值为RN，通过执行wait(L，1，1)操作来控制读者数目。每当有一个读者进入时，就要先执行wait(L，1，1)操作，使L的值减 1 。当有 RN 个读者进入后，L便减为 0 ，第 RN+1个读者要进入读时，必然因为wait(L，1，操作失败而堵塞。
int RN = N;
semaphore L = RN,mx = 1;
void Rreder()
{
while (TRUE)
{
Swait(L,1,1);
Swait(mx,1,0); //1,1,0时没有操作，开关；
perform read operation;
Ssignal(L,1);
}
}
void Writer()
{
while (TRUE)
{
Swait(mx,1,1;L,RN,0);
perform writer operation;
Ssignal(mx,1);
}
}
标签：com 问题： i+1 code ade 互斥量 出现 process 增加
原文地址：https://www.cnblogs.com/BY1314/p/12842134.html
