操作系统—进程作业

1.喂金鱼问题

• 假设张三和李四共同养一条金鱼，金鱼每天进食一顿，所以每天仅能为一次
• 若超过一次，金鱼胀死，若一次都没有喂，金鱼饿死
• 两人都想把金鱼养活，请给两人设置喂金鱼的方式，并用伪代码描述两个人的行为

思路比较清晰，用信号量机制来做

Semaphore mutex=1      //对鱼的喂食要互斥进行
Semaphore NoteZ=0      //NoteZ=1时，张三对金鱼进行喂食并留下字条
Semaphore MoteL=0      //NoteL=1时，李四对金鱼进行喂食并留下字条

ZhangSan()
{
    P(mutex);
    while(NoteL)
    {
        P(NoteL);
        Do_Nothing();
    }
    DoFeed_Fish();
    V(mutex);

    V(NoteZ);
}

LiSi()
{
    P(mutex);
    while(NoteZ)
    {
        P(NoteZ);
        Do_Nothing();
    }
    DoFeed_Fish();
    V(mutex);

    V(NoteL);
}

2.写者优先的“读者-写者”问题

• 读者和写者地位完全平等，按到达的先后次序决定优先次序

Semaphore rw=1         //实现对于文件的互斥访问
Semaphore mutex=1      //保证对于count变量的互斥访问
Semaphore w=1          //写优先
int count=0            //记录当前有几个读进程在访问文件

Writer()
{
    while(1)
    {
        P(w);
        P(rw);
        Writing();
        V(rw);
        V(w);
    }
}

Reader()
{
    while (1)
    {
        P(w);
        P(mutex);
        if(count==0)
            P(rw);
        count++;
        V(mutex);
        V(w);

        Reading();

        P(mutex);
        count--;
        if(count==0)
            V(rw);
        V(mutex);
    }
}

• 提高写者的优先权，先到的读者比写者优先，写进程声明要进行写操作时，后续读者需等写操作完成

Semaphore rw=1         //实现对于文件的互斥访问
Semaphore mutex=1      //保证对于count变量的互斥访问
Semaphore w=1          //写优先
int count=0            //记录当前有几个读进程在访问文件

Writer()
{
    while(1)
    {
        P(w);
        P(rw);
        Writing();
        V(rw);
        V(w);
    }
}

Reader()
{
    while (1)
    {
        P(mutex);
        if(count==0)
            P(rw);
        count++;
        V(mutex);
        P(w);

        Reading();

        V(w);

        P(mutex);
        count--;
        if(count==0)
            V(rw);
        V(mutex);
    }
}

• 写者优先，某个写者到达，先于它到达还没有来得及读的读者需要等待

增加信号量r，初值是1：当至少有一个写进程准备访问数据区时，用于禁止所有的读进程。增加一个记数器，即整型变量writecount，记录写者数，初值是0。 writecount为多个写者共享的变量，是临界资源。用互斥信号量mutex2控制, mutex2初值是1。增加mutex3，初值是1：在r上不允许建造长队列，否则写进程将不能跳过这个队列，因此，只允许一个读进程在r上排队，而所有其他读进程在等待r之前，在信号量mutex3上排队。

int readcount=0            //记录当前有几个读进程在访问文件
int writecount=0       //记录写者数
Semaphore mutex1=1      //保证对于readcount变量的互斥访问
Semaphore mutex2=1      //保证对于writecount变量的互斥访问
Semaphore mutex3=1      //保证读者排队
Semaphore w=1          //写优先
Semaphore r=1          //读优先

Writer()
{
    P(mutex 2);
    writecount++;
    if (writecount == 1 )
        P(r);
    V(mutex 2);
    P(w);
   
    Writing();

    V(w);
    P(mutex 2);
    writecount --;
    if (writecount == 0)
        V(r);
    V(mutex 2);
}

Reader()
{
    P(mutex 3);
    P(r);
    P(mutex 1);
    readcount++;
    if (readcount == 1 ) 
        P(w);
    V(mutex 1);
    V(r);
    V(mutex 3);

     Reading();

    P(mutex 1);
    readcount --;
    if (readcount == 0 )
        V(w);
    V(mutex 1);
}

3.管程—生产者和消费者问题

monitor Producter&Consumer
    condition full,empty;
    int count=0;
    void insert(Item item)
    {
        if(count==N)
            P(full);
        count++;
        insert_item(item);
        if(count==0)
            V(empty);
    }
    Item remove()
    {
        if(count==0)
            P(empty);
        count--;
        remove_item();
        if(count==N)
            V(full);
        return remove_item();
    }
end monitor;

Producter()
{
    while(true)
    {
        item=Produce_item();
        Producter&Consumer.insert(item);
    }
}

Consumer()
{
    while(true)
    {
        Producter&Consumer.remove(item);
        Consume(item);
    }
}

大概就这样吧。。。