编辑代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

// 进程结构体定义
struct jincheng_type {   
    int pid;          // 进程唯一标识ID
    int youxian;     // 进程优先级(数值越小优先级越高)
    int daxiao;      // 进程占用内存大小(单位:KB)
    int zhuangtai;   // 进程状态:0=不存在(未创建/已终止) 1=在内存中运行 2=阻塞(换出到外存)
    char info[10];   // 进程内容描述(模拟业务数据)
}; 

// 全局数据区
struct jincheng_type neicun[20];   // 内存进程表(最多管理20个进程)
int shumu = 0;                    // 当前在内存中的进程数量
int guaqi = 0;                    // 当前阻塞(换出)的进程数量

/**
 * 创建新进程函数
 * 功能:在内存中创建新进程,检查PID唯一性并初始化进程属性
 * 逻辑:遍历内存表寻找空闲位置(状态0),支持一次创建最多5个进程
 */
void create() {      
    // 内存容量上限检查
    if(shunu >= 20)) {
        printf("\n内存已满,请先换出或结束进程\n");
        return;
    }
     
    printf("**当前默认一次性创建5个进程,内存容量20**\n");
    int created = 0;  // 本次创建的进程计数
    
    // 遍历内存表寻找可创建位置
    int i;
    for(i=0; i<20 && created<5; i++) {
        // 发现空闲位置(状态0表示未使用)
        if(neicun[i].zhuangtai == 0) {
            // 输入并校验PID
            printf("\n请输入新进程pid: ");
            scanf("%d", &neicun[i].pid);
            
            // 全表查重(避免PID重复)
            int pid_exists = 0;
            int j;
            for(j=0; j<20; j++) {
                // 检查其他已存在进程(状态非0且PID相同)
                if(j != i && neicun[j].zhuangtai != 0 && neicun[j].pid == neicun[i].pid) {
                    pid_exists = 1;
                    break;
                }
            }
            
            if(pid_exists) {
                printf("该进程已存在\n");
                neicun[i].zhuangtai = 0// 重置状态为空闲
                i--;  // 回退索引重新检查当前位置(因输入错误导致)
                continue;  // 跳过后续属性输入
            }
            
            // 输入进程其他属性
            printf("优先级: ");
            scanf("%d", &neicun[i].youxian); 
            printf("大小: ");
            scanf("%d", &neicun[i].daxiao); 
            printf("内容: ");
            scanf("%s", neicun[i].info); 
            
            // 初始化进程状态
            neicun[i].zhuangtai = 1// 设置为内存中状态
            shumu++;// 内存进程数+1
            created++;// 创建计数+1
            printf("进程创建成功!\n");
        }
    }
}

/**
 * 显示内存中进程函数
 * 功能:遍历内存表,输出所有状态为1(运行中)的进程信息
 */
void run() {   
    printf("\n运行中进程 (%d 个):\n", shumu);
    int found = 0;  // 是否找到进程标记
    int i;
    for(i=0; i<20; i++) {
        // 筛选状态为1(在内存中)的进程
        if(neicun[i].zhuangtai == 1) {
            // 格式化输出进程信息
            printf("[PID:%d] 优先级:%d 大小:%dKB 内容:%s\n", 
                   neicun[i].pid, neicun[i].youxian,
                   neicun[i].daxiao, neicun[i].info);
            found = 1;
        } 
    }
    if(!found) printf("无运行进程\n");  // 无符合条件的进程
}

/**
 * 进程换出函数(阻塞处理)
 * 功能:将指定PID的内存进程换出到阻塞队列(状态转为2)
 * 状态转换:1(内存)→2(阻塞),更新内存和阻塞计数
 */
void huanchu() {
    // 空检查
    if(!shumu) {
        printf("当前没有运行进程!\n");
        return;
    }
    
    printf("\n输入换出进程PID: ");
    int target_pid;
    scanf("%d", &target_pid);
    
    int found = 0;  // 进程是否存在标记
    int i;
    for(i=0; i<20; i++) {
        if(neicun[i].pid == target_pid) {
            found = 1;
            switch(neicun[i].zhuangtai) {
                case 1:  // 内存中的进程可以换出
                    neicun[i].zhuangtai = 2;  // 设置阻塞状态
                    shumu--;  // 内存进程数-1
                    guaqi++;  // 阻塞进程数+1
                    printf("进程已换出到阻塞队列\n");
                    break;
                case 2:  // 已在阻塞队列
                    printf("进程已在阻塞队列\n");
                    break;
                case 0:  // 进程不存在
                    printf("进程不存在\n");
                    break;
            }
            break;
        }
    }
    if(!found) printf("未找到指定进程\n");  // PID不存在于任何进程
}

/**
 * 终止进程函数
 * 功能:终止指定PID的进程(无论在内存还是阻塞状态)
 * 状态转换:1/2→0,释放所有资源并更新计数
 */
void kill() {
    printf("\n输入终止进程PID: ");
    int target_pid;
    scanf("%d", &target_pid);
    
    int found = 0;
    int i;
    for(i=0; i<20; i++) {
        if(neicun[i].pid == target_pid) {
            found = 1;
            switch(neicun[i].zhuangtai) {
                case 1:  // 内存中进程终止
                    neicun[i].zhuangtai = 0;//内存状态设置为 0
                    shumu;  // 内存进程数-1
                    break;
                case 2:  // 阻塞进程终止
                    neicun[i].zhuangtai = 0;
                    guaqi--;  // 阻塞进程数-1
                    break;
                case 0:  // 不应出现的状态(防御性处理)
                    printf("进程状态异常\n");
                    break;
            }
            printf("进程已终止\n");
            break;
        }
    }
    if(!found) printf("未找到指定进程\n");
}

/**
 * 唤醒进程函数
 * 功能:将阻塞队列中的进程重新加载到内存(状态2→1)
 * 前置条件:内存有空闲空间(shumu < 20)
 */
void huanxing() {
    // 阻塞队列空检查
    if(!guaqi) { 
        printf("\n当前没有阻塞进程\n");
        return;
    }
    
    printf("\n输入唤醒进程PID: ");
    int target_pid;
    scanf("%d", &target_pid);
    
    int found = 0;
    int i;
    for(i=0; i<20; i++) {
        if(neicun[i].pid == target_pid) {
            found 
= 1;
            if(neicun[i].zhuangtai == 2) {  // 仅唤醒阻塞状态的进程
                // 内存容量检查
                if(shumu >= 20) {
                    printf("内存已满无法唤醒\n");
                    return;
                }
                // 状态转换
                neicun[i].zhuangtai = 1;  // 恢复为内存状态
                shumu++;  // 内存进程数+1
                guaqi--;  // 阻塞进程数-1
                printf("进程已唤醒\n");
            } else if(neicun[i].zhuangtai == 1) {
                printf("进程已在内存中运行\n");
            } else {
                printf("进程不存在\n");
            }
            break;
        }
    }
    if(!found) printf("未找到指定进程\n");
}

int main() {
    // 初始化内存表:所有进程初始状态为0(不存在)
    int i;
    for(i=0; i<20; i++) 
        neicun[i].zhuangtai = 0;

    while(1) {
        // 主菜单界面
        printf("\n======== 进程管理系统 ========\n");
        printf("1.创建进程\t2.查看进程\n");
        printf("3.换出进程\t4.终止进程\n");
        printf("5.唤醒进程\t6.退出系统\n");
        printf("请选择操作: ");
        
        int choice;
        scanf("%d", &choice);
        
        switch(choice) {
            case 1: create(); break;       // 进程创建
            case 2: run(); break;          // 状态查看
            case 3: huanchu(); break;      // 换出到阻塞
            case 4: kill(); break;         // 终止进程
            case 5: huanxing(); break;     // 唤醒阻塞进程
            case 6: exit(0);               // 安全退出
            default: printf("请输入1-6的数字\n");  // 输入校验
        }
    }
    return 0;
}