C语言实现操作系统简单的P V操作

简单说明

cpp的文件，C语言的语法

代码如下

#include "stdio.h"
#include "stdlib.h"
struct process{  //进程结构体
    long pid;
    long uid;
    struct process *next;
};

typedef struct semaphore{  //记录型信号量
    int value;
    struct process *L;
} semaphore;

void PrintBlockQueue(semaphore S){
    struct process *p = S.L;
    printf("此时共享资源数量为: %d\t,阻塞队列：",S.value);
    if(p==NULL){
        printf("NULL\n");
    }else{
        while(p!=NULL){
            printf("%d -> ",p->pid);
            p=p->next;
        }
        printf("NULL\n");
    }
}

void ProcessRun(struct process p){
    printf("进程 %d 正在使用资源\n",p.pid);
}

void block(struct process *&L,struct process P){
    if(L==NULL){
        L=(struct process *) malloc(sizeof(struct process));
        L->pid = P.pid;
        L->uid = P.uid;
        L->next = NULL;
    }else{
        struct process *p = L,*q;
        while (p->next != NULL){
            p = p->next;
        }
        q = (struct process *) malloc(sizeof (struct process));
        q->pid = P.pid;
        q->uid = P.uid;
        q->next = NULL;
        p->next = q;
    }

}

void wakeup(struct process *&L){
    struct process *p = L;
    struct process P;
    if(L!=NULL){
        P.pid = L->pid;
        P.uid = L->uid;
        p = L->next;
        L = p;
    }
    ProcessRun(P);
}

void wait(semaphore &S,struct process p){
    printf("进程 %d 在申请资源 \n",p.pid);
    S.value--;
    if(S.value<0){
        printf("进程 %d 申请资源失败,进入阻塞队列\n");
        block(S.L,p);
    } else{
        ProcessRun(p);
    }
    PrintBlockQueue(S);
    printf("\n");
}

void signal(semaphore &S,struct process p){
    printf("进程 %d 正在释放资源\n",p.pid);
    S.value++;
    if(S.value <= 0){
        printf("进程 %d 释放资源完毕,存在阻塞进程,将其唤醒\n",p.pid);
        wakeup(S.L);
    } else{
        printf("进程 %d 释放资源完毕,未存在阻塞进程\n",p.pid);
    }
    PrintBlockQueue(S);
    printf("\n");
}


int main(){
    semaphore S;
    S.value =2;  //系统资源
    S.L = NULL;

    struct process p1,p2,p3,p4; //4个进程
    p1.pid = 202201; p1.uid =1001;
    p2.pid = 202202; p2.uid =1002;
    p3.pid = 202203; p3.uid =1003;
    p4.pid = 202204; p4.uid =1004;

    wait(S,p1);     //p1申请资源
    wait(S,p2);     //p2申请资源
    wait(S,p3);     //p3申请资源

    signal(S,p2);   //p2释放资源
    wait(S,p4);     //p4申请资源
    signal(S,p1);  //p1释放资源
    signal(S,p4);  //p4释放资源
    signal(S,p3);  //p3释放资源
    return 0;
}

实现效果

进程 202201 在申请资源
进程 202201 正在使用资源
此时共享资源数量为: 1   ,阻塞队列：NULL

进程 202202 在申请资源
进程 202202 正在使用资源
此时共享资源数量为: 0   ,阻塞队列：NULL

进程 202203 在申请资源
进程 -1 申请资源失败,进入阻塞队列
此时共享资源数量为: -1  ,阻塞队列：202203 -> NULL

进程 202202 正在释放资源
进程 202202 释放资源完毕,存在阻塞进程,将其唤醒
进程 202203 正在使用资源
此时共享资源数量为: 0   ,阻塞队列：NULL

进程 202204 在申请资源
进程 -1 申请资源失败,进入阻塞队列
此时共享资源数量为: -1  ,阻塞队列：202204 -> NULL

进程 202201 正在释放资源
进程 202201 释放资源完毕,存在阻塞进程,将其唤醒
进程 202204 正在使用资源
此时共享资源数量为: 0   ,阻塞队列：NULL

进程 202204 正在释放资源
进程 202204 释放资源完毕,未存在阻塞进程
此时共享资源数量为: 1   ,阻塞队列：NULL

进程 202203 正在释放资源
进程 202203 释放资源完毕,未存在阻塞进程
此时共享资源数量为: 2   ,阻塞队列：NULL