进程同步---生产者与消费者问题以及进程同步机制--信号量及P、V操作

进程同步 synchronization

描述

场景

一个进程运行到某一点时，要求另一个伙伴进程为它提供消息，在未获得消息之前，该进程进入阻塞态，获得消息后被唤醒进入就绪态。*

生产者与消费者问题又称为有界缓冲区问题

场景：

要解决的问题：

#define N 100
int count = 0;
void producer(void)
｛
int item;
while(TRUE)
{
item = produce_item();
if(count == N)         /*判断缓冲区是否满了*/
sleep();
insert_item(item);
count = count + 1;
if(count == 1) /*判断是否有消费者睡眠*/
wakeup(consumer);
}
｝

void consumer(void)
{
int item;
while(TRUE)
{
if(count == 0) /*判断是否有数据*/
sleep();
item = remove_item();
count = count - 1;
if(count == N-1) /*判断是否有生产者睡眠*/
wakeup(producer);
consume_item(item);
}
}

一种经典的进程同步机制–信号量及P、V操作

信号量及P、V操作

struct semaphore
{
int count;
queueType queue;
}

P(s)
{
s.count--;
if(s.count < 0)
{
该进程状态置为阻塞状态；
该进程插入相应的等待队列s.queue末尾；
重新调度；
}
}

V(s)
{
s.count++;
if(s.count <= 0)
{
唤醒相应的等待队列s.queue中等待的一个进程；
改变其状态为就绪态，并将其插入就绪队列；
}
}

用PV操作解决进程间的互斥问题

用信号量解决生产者、消费者问题

#define N 100                   /*缓冲区个数*/
typedef int semaphore;          /*信号量是一种特殊的整数类型*/
semaphore mutex = 1;            /*互斥信号量：控制对临界区的访问*/
semaphore empty= N;             /*空缓冲区的个数*/
semaphore full = 0;             /*满缓冲区个数*/
void producer(void)
{
int item;
while(TRUE)
{
item = produce_item()
P(&empty);
P(&mutex);
insert_item(item);
V(&mutex);
V(&full);

}

}

void consumer(void)
{
int item;
while(TRUE)
{
P(&full);
P(&mutex);
item = remove_item()
P(&mutex);
V(&empty);
consume_item(item);
}

}