进程管理器的模拟实现
操作系统实验报告进程管理
操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。
进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。
本实验报告将介绍进程管理的基本概念、原理和实验结果。
一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例，它拥有独立的内存空间和执行环境。
线程是进程中的一个执行单元，多个线程可以共享同一个进程的资源。
进程和线程是操作系统中最基本的执行单位。
2. 进程状态进程在运行过程中会经历不同的状态，常见的进程状态包括就绪、运行和阻塞。
就绪状态表示进程已经准备好执行，但还没有得到处理器的分配；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，需要等待某些事件的发生。
3. 进程调度进程调度是操作系统中的一个重要任务，它决定了哪个进程应该获得处理器的使用权。
常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转等。
二、进程管理的原理1. 进程控制块（PCB）PCB是操作系统中用于管理进程的数据结构，它包含了进程的各种属性和状态信息，如进程标识符、程序计数器、寄存器值等。
通过PCB，操作系统可以对进程进行管理和控制。
2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。
进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。
进程的创建和撤销是操作系统中的基本操作之一。
3. 进程同步与通信多个进程之间可能需要进行同步和通信，以实现数据共享和协作。
常见的进程同步与通信机制包括互斥锁、信号量和管道等。
三、实验结果与分析在本次实验中，我们使用了一个简单的进程管理模拟程序，模拟了进程的创建、撤销和调度过程。
通过该程序，我们可以观察到不同调度算法对系统性能的影响。
实验结果显示，先来先服务（FCFS）调度算法在一些情况下可能导致长作业等待时间过长，影响系统的响应速度。
操作系统进程调度模拟(全三分合集)
实验一进程调度实验一、目的要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、例题：设计一个有 N个进程共行的进程调度程序进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
调度算法的流程图如下图所示。
三．实验题：1、编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如：在进程获得一次CPU后就将其优先数减少1。
或者，进程等待的时间超过某一时限时增加其优先数的值，等等。
2、编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。
轮转法可以是简单轮转法、可变时间片轮转法，或多队列轮转法。
电大操作系统实验报告3_ 进程管理实验
电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一，本次实验的目的是通过实际操作和观察，深入理解进程的概念、状态转换、进程调度以及进程间的通信机制，掌握操作系统中进程管理的基本原理和方法，提高对操作系统的整体认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C 语言，开发工具为 Visual Studio 2019。
三、实验内容及步骤（一）进程的创建与终止1、编写一个 C 程序，使用系统调用创建一个子进程。
2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。
3、子进程执行一段简单的计算任务，父进程等待子进程结束后输出结束信息。
以下是实现上述功能的 C 程序代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>include ＜unistdh>int main(）｛pid_t pid;pid ＝ fork(）；if （pid ＜ 0) ｛printf(＂创建子进程失败\n"）；return 1;｝ else if （pid ＝＝ 0) ｛printf(＂子进程：我的进程 ID 是％d，父进程 ID 是％d\n"，getpid(）， getppid(））；int result ＝ 2 ＋ 3;printf(＂子进程计算结果：2 ＋ 3 ＝％d\n"， result)；exit(0)；｝ else ｛printf(＂父进程：我的进程 ID 是％d，子进程 ID 是％d\n"，getpid(）， pid)；wait(NULL)；printf(＂子进程已结束\n"）；｝return 0;｝｀｀｀编译并运行上述程序，可以观察到父进程和子进程的输出信息，验证了进程的创建和终止过程。
（二）进程的状态转换1、编写一个 C 程序，创建一个子进程，子进程进入睡眠状态一段时间，然后被唤醒并输出状态转换信息。
实验1：进程管理
实验1：进程管理要求：编写程序，模拟实现创建新的进程；查看运行进程；换出某个进程；撤销某个进程。
提示：1、进程状态简单处理为：0为不在内存，1为在内存，2为阻塞，3为挂起。
2、撤销进程指将进程的状态从运行变为阻塞。
3、程序的结构可以处理为在主函数中用switch语句调用各种表示进程管理功能的函数。
源程序代码：#include <iostream>#include <fstream>#include <string>#include <windows.h>#include <iomanip>using namespace std;const Max=100;int Tread[3][Max];//[号码][大小][状态]int n=-1;int mem=64;int a;void T(){cout<<"**********************************"<<endl;cout<<"* 进程演示系统*"<<endl;cout<<"**********************************"<<endl;cout<<"* 1.创建进程*"<<endl;cout<<"* 2.调入内存*"<<endl;cout<<"* 3.杀死进程*"<<endl;cout<<"* 4.查看进程*"<<endl;cout<<"----------------------------------"<<endl;cout<<"< 提示：状态0为不在内存，1为在内存，2为阻塞，3为挂起。
模拟进程创建终止阻塞唤醒原语_操作系统原理
模拟进程创建终止阻塞唤醒原语_操作系统原理操作系统中的进程是程序运行的基本单位，它可以被创建、终止、阻塞和唤醒等。
下面将模拟进程的创建、终止、阻塞和唤醒的原语，以帮助更好地理解操作系统原理。
一、进程的创建进程的创建是指在操作系统中新建一个进程，并为其分配资源，使其能够运行。
进程的创建可以通过以下步骤来模拟：1.初始化进程控制块（PCB）：创建一个用于记录进程信息的数据结构，称为进程控制块（PCB）。
PCB中包含了进程的标识符、状态信息、程序计数器等。
2.为进程分配资源：根据进程的需要，为其分配必要的资源，例如内存空间、文件资源等。
这样进程就可以运行了。
3.设置进程优先级：为进程设置优先级，以便操作系统能够按照优先级来调度进程。
4.进程初始化：对进程进行初始化操作，例如设置进程的初始状态、初始化进程的堆栈等。
5.将进程添加到就绪队列：将新建的进程添加到就绪队列中，表示该进程已经准备好运行了。
二、进程的终止进程的终止是指进程运行完成或者由于异常情况退出运行的过程。
进程的终止可以通过以下步骤来模拟：1. 处理终止信号：当操作系统接收到终止信号时，会进行相应的处理。
可以是用户通过按下Ctrl+C键发送的中断信号，或者是进程运行出错导致的异常信号。
2.终止进程的运行：操作系统会终止当前正在运行的进程，停止它的运行。
3.释放资源：操作系统会释放进程占用的资源，包括内存空间、文件资源等。
4.清理进程控制块：操作系统会清理进程控制块中的相关信息，以便重新利用。
5.将进程从就绪队列或阻塞队列中移除：如果进程在就绪队列中，将其从队列中移除。
如果进程在阻塞队列中，将其唤醒。
三、进程的阻塞进程的阻塞是指进程由于其中一种原因无法继续执行，进入等待状态，直到一些条件满足后才能继续运行的过程。
进程的阻塞可以通过以下步骤来模拟：1. 设置阻塞标志：操作系统会将进程的阻塞标志设置为true，表示该进程已被阻塞。
2.保存进程状态：操作系统会保存进程的当前状态，包括程序计数器、寄存器、栈指针等。
Linux编程：模拟进程调度算法
Linux编程：模拟进程调度算法稍稍有点操作系统基础的朋友应该知道进程的调度算法，在这⾥Koala还是给⼤家略微介绍⼀下接下来将要⽤到的⼏种算法：1. 先来先服务（FCFS）采⽤FCFS调度，先请求CPU的进程会先分配到CPU。
使⽤FCFS调度的等待时间通常较长，CPU利⽤率也会较低2. 最短作业优先调度（SJF）采⽤SJF调度会选择具有最短CPU运⾏时间的进程分配CPU使⽤权。
如果两个进程的CPU区间相同，则按照FCFS来进⾏选择。
SJF调度可以证明是最佳的，它降低了平均等待时间。
3. 轮转法调度（RR）RR调度将CPU时间分为较⼩的时间⽚，调度程序循环就绪队列。
为每⼀个进程分配不超过⼀个时间⽚的CPU。
RR调度专门⽤于分时系统。
4. 优先级调度每⼀个进程都有⼀个优先级与其关联，具有最⾼优先级的进程会分配到CPU。
优先级调度的⼀个主要问题是优先级较低的进程会产⽣饥饿现象。
整个编程思路按照如下进⾏：创建主线程，主线程创建⼦线程，⼦线程有⼀个虚拟PCB主线程创建20个⼦线程，分别实现FCFS调度、SJF调度、RR调度、优先级调度，并且计算每个调度的平均等待时间。
对于每个⼦线程，在其运⾏期间，输出其占⽤的时间标号（例如，第3个线程占⽤了第10秒的CPU时间，输出为：“Thread3：10”）。
下⾯是整个的代码（仅供参考）：#include<stdio.h>#include<stdlib.h>#include<sys/types.h>#include<unistd.h>#include<pthread.h>#include<time.h>#include<iostream>#define Thread_Num 20using namespace std;pthread_mutex_t Device_mutex ;//Virtual PCB of threadsstruct VirtualPCB{int tid;int priority;int waittime;int runtime;int arrivetime;int visited;int tempruntime;public:int gettid(){return tid;}int getwaittime(){return waittime;}int getpriority(){return priority;}int getruntime(){return runtime;}int getarrivetime(){return arrivetime;}void setvisit(int a){visited=a;}int getvisit(){return visited;}int gettempruntime(){return tempruntime;}void setwaittime(int n){waittime = n;}void settempruntime(int n){tempruntime = tempruntime - n;}}TCB[Thread_Num];//Function to initial virtual PCBvoid t_init(){int n;srand(time(NULL));for(n =0;n<Thread_Num;n++){TCB[n].tid = n + 1;//⽤线程创建序号作为虚拟进程id//⽤随机数随机产⽣虚拟PCB的值TCB[n].priority = 1 + rand()%19;TCB[n].runtime = 1 + rand()%19;TCB[n].arrivetime = 0;//模拟时，默认进程按创建顺序依次在0时刻到达TCB[n].waittime = 0;TCB[n].visited =0;TCB[n].tempruntime = TCB[n].runtime;}}//Threads run functionvoid *t_print(void *arg){int n = *(int *)arg;//get argumentwhile(1){pthread_mutex_lock(&Device_mutex);printf("Thread_%-2d: ",n);printf("tid:%-2d priority:%-2d runtime:%-2d \n",TCB[n-1].gettid(),TCB[n-1].priority,TCB[n-1].runtime); pthread_mutex_unlock(&Device_mutex);sleep(1);break;}//printf("Error %d\n",n);pthread_exit(0);}//First come first service schedule functionvoid FCFS(){cout<<"-----------FCFS:"<<endl;int i,j;int start = 0;float waittime = 0;float avwait = 0;for(i=0;i<Thread_Num/2;i++){for(j=0;j<Thread_Num;j++){if(TCB[j].getarrivetime()==i && TCB[j].getvisit()==0){printf("Thread: %-2d Start: %-3d Runtime: %-2d\n",TCB[j].gettid(),start,TCB[j].getruntime()); waittime = waittime + (float)start;start = start + TCB[j].getruntime();TCB[j].setvisit(1);}}}avwait = waittime / (float)Thread_Num;printf("Total waitting time : %f\n",waittime);printf("Average waitting time : %f\n",avwait);}//Shortest job first schedule functionvoid SJF(){for(int k=0 ;k<Thread_Num;k++){TCB[k].setvisit(0);}cout<<"-------------SJF:"<<endl;int i,j;int start = 0;float waittime = 0;float avwait = 0;for(i=1;i<Thread_Num;i++){for(j=0;j<Thread_Num;j++){if(TCB[j].getruntime()==i && TCB[j].getvisit()==0){printf("Thread: %-2d Start: %-3d Runtime: %-2d\n",TCB[j].gettid(),start,TCB[j].getruntime()); waittime = waittime + (float)start;start = start + TCB[j].getruntime();TCB[j].setvisit(1);}}}avwait = waittime / (float)Thread_Num;printf("Total waitting time : %f\n",waittime);printf("Average waitting time : %f\n",avwait);}//Round R schedule functionvoid RR(int r){cout<<"--------------RR:"<<endl;int start = 0;float waittime = 0;float avwait = 0;for(int i=0;i<Thread_Num;i++){int totaltime = totaltime + TCB[i].getruntime();TCB[i].setvisit(0);}for(int j=0;j<20*Thread_Num;j=j+r){int k = (j%(20*r))/r;if(TCB[k].gettempruntime() > 0){int tepruntime = r;if(TCB[k].gettempruntime()-r<=0){tepruntime = TCB[k].gettempruntime();TCB[k].setwaittime(start + tepruntime - TCB[k].getruntime());}printf("Thread: %-2d Start: %-3d Runtime:%-2d \n",TCB[k].gettid(), start,tepruntime);start = start + tepruntime;TCB[k].settempruntime(r) ;}}for(int m=0;m<Thread_Num;m++){waittime += TCB[m].getwaittime();//printf("TCB[%d].getwaittime():%d\n",m+1,TCB[m].getwaittime());}avwait = waittime / (float)Thread_Num;printf("Total waitting time : %f\n",waittime);printf("Average waitting time : %f\n",avwait);}//Priority schedule functionvoid Priority(){for(int k=0 ;k<Thread_Num;k++){TCB[k].setvisit(0);}cout<<"-----------Priority:"<<endl;int i,j;int start = 0;float waittime = 0;float avwait = 0;for(i=1;i<Thread_Num;i++){for(j=0;j<Thread_Num;j++){if(TCB[j].getpriority()==i && TCB[j].getvisit()==0){printf("Thread: %-2d Start: %-3d Runtime: %-2d\n",TCB[j].gettid(),start,TCB[j].getruntime()); waittime = waittime + (float)start;start = start + TCB[j].getruntime();TCB[j].setvisit(1);}}}avwait = waittime / (float)Thread_Num;printf("Total waitting time : %f\n",waittime);printf("Average waitting time : %f\n",avwait);}//Main thread execute function to create 20 children threadsvoid *Children(void*){int ret[Thread_Num];t_init();pthread_t tid[Thread_Num];pthread_mutex_init(&Device_mutex,NULL);int i,j;for(i=0;i<Thread_Num;i++){int k =i+1;ret[i] = pthread_create(&tid[i],NULL,&t_print, &k);if(ret[i] == 0) {sleep(1);}else{printf("Thread_%-2d failed!\n",i+1);}}for(j=0;j<Thread_Num;j++)pthread_join (tid[i], NULL);pthread_mutex_destroy(&Device_mutex);pthread_exit(0);}int main(){int ret1;pthread_t tid1;//Declare main threadret1 = pthread_create(&tid1,NULL,&Children,NULL);//Create main threadif(ret1 == 0){printf("Main Thread ok!\n");sleep(20);}else{printf("Thread failed!\n");}FCFS();SJF();cout<<"Please enter RR time:\n";//Request RR timeint rr;scanf("%d",&rr);RR(rr);Priority();return 0;}OK！此代码的运⾏结果如下（部分）：第⼀张图打印了⼀下虚拟PCB的部分内容：第⼆张图⽚打印了FCFS调度算法运⾏结果：第三张图⽚打印了SJF调度算法运⾏结果：第四张图⽚打印了RR调度算法运⾏结果（部分）：第五张图⽚打印了Priority调度算法运⾏结果：注意看每张图下⾯的两⾏数据，分别是不同算法对应的总的进程的等待时间以及平均等待时间的⼤⼩，印证了SJF算法通常是最少平均等待时间的调度算法最后希望⼤家能够积极提建议，指出纰漏！。
进程管理实验报告_共10篇 .doc
★进程管理实验报告_共10篇范文一：_进程管理实验报告进程管理实验报告一、进程与线程1.实验目的：1.通过本实验学习Linux中创建进程的方法。
2.学习系统调用fork的使用方法。
3.学习系统调用exec族调用的使用方法。
2.实验准备1．进程的创建创建一个进程的系统调用很简单，只要调用fork函数就可以了。
#includepid_tfork()；当一个进程调用了fork以后，系统会创建一个子进程，这个子进程和父进程是不同的地方只有它的进程ID和父进程ID，其他的都一样，就像父进程克隆（clone）自己一样，当然创建两个一模一样的进程是没有意义的，为了区分父进程和子进程，我们必须跟踪fork调用返回值。
当fork调用失败的时候（内存不足或者是用户的最大进程数已到）fork返回—1，否则fork的返回值有重要的作用。
对于父进程fork返回子进程ID，而对于fork 子进程返回0，我们就是根据这个返回值来区分父子进程的。
2.关于fork的说明使用该函数时，该函数被调用一次，但返回两次，两次返回的区别是子进程的返回值是0，而父进程的返回值则是新子进程的进程ID。
将子进程ID返回给父进程的理由是：因为一个进程的子进程可以多于一个，所以没有一个函数可以是一个子进程获得其所有子进程的进程ID。
而fork函数使子进程得到的返回值是0的理由是：一个子进程只会有一个父进程，所以子进程总是可以调用函数getpid获得其父进程的进程ID。
3.系统调用exec族调用的说明父进程创建子进程后，子进程一般要执行不同的程序。
为了调用系统程序，我们可以使用系统调用exec族调用。
Exec族调用有以下五个函数：intexecl(constchar*path,constchar*arg,?);intexeclp(constchar*file,constchar*arg,?);intexecle(constchar*path,constchar*arg,?);intexecv(constchar*path,constchar*argv[]);intexecvp(constchar*file,constchar*argv[]);exec族调用可以执行给定程序。
操作系统实验报告实验一进程管理
实验一进程管理一、目的进程调度是处理机管理的核心内容。
本实验要求编写和调试一个简单的进程调度程序。
通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。
二、实验内容及要求1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。
可根据实验的不同，PCB结构的内容可以作适当的增删）。
为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
2、系统资源(r1…r w),共有w类，每类数目为r1…r w。
随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。
3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。
建立进程就绪队列。
4、编制进程调度算法：时间片轮转调度算法本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。
在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。
三、实验环境操作系统环境：Windows系统。
编程语言：C#。
四、实验思路和设计1、程序流程图2、主要程序代码//PCB结构体struct pcb{public int id; //进程IDpublic int ra; //所需资源A的数量public int rb; //所需资源B的数量public int rc; //所需资源C的数量public int ntime; //所需的时间片个数public int rtime; //已经运行的时间片个数public char state; //进程状态，W（等待）、R（运行）、B（阻塞）//public int next;}ArrayList hready = new ArrayList();ArrayList hblock = new ArrayList();Random random = new Random();//ArrayList p = new ArrayList();int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数//r为可随机产生的进程数（r=m-n）//a，b，c分别为A，B，C三类资源的总量//i为进城计数，i=1…n//h为运行的时间片次数，time1Inteval为时间片大小（毫秒）//对进程进行初始化，建立就绪数组、阻塞数组。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
衡阳师范学院《操作系统》课程设计题目：进程管理器的模拟实现系别：计算机科学系专业：物联网工程班级：1206班学生姓名：郑晓娟学号：12450218指导老师：王玉奇完成日期：2014年12月28日目录一、需求分析 (3)二、概要设计 (3)三、详细设计 (4)1.进程PCB结构体的定义 (4)2.创建模块 (4)3.查看模块 (5)4.换出模块 (6)5.杀死模块 (8)四、程序调试 (10)五、总结分析 (14)一、需求分析有时候我们需要去了解我们电脑的运行情况，掌握和管理它的进程，并对其异常情况给予操作和控制。
进程管理器就像我们了解和控制自己电脑运作的一个窗口，通过这个窗口我们可以查看到所有进程的运行情况，并对运行的进程加以管理和控制。
在本课程设计中，进入模拟进程系统后，可以根据请求选择“创建进程”创建新的进程。
还可以选择“查看进程“来查看当前正在运行的进程，以及该进程的相关的信息，其中包括进程的pid，进程优先级，进程大小和进程的内容，我们可以通过这些来了解计算机中每个进程的使用状况。
选择“换出进程”，可以挂起某个正在运行的进程。
选择“撤销进程”，可以停止某个正在运行的程序，并且释放其占用的资源。
选择“退出进程”，可以退出进程模拟系统。
二、概要设计程序流程：三、详细设计（1）进程PCB结构体的定义struct jincheng_type{ //定义表示进程信息的结构体int pid; //进程IDint youxian; //优先级int daxiao; //大小int zhuangtai; //进程的状态，这里用0表示没有建立或被杀死，1表示执行，2表示换出int neirong; //内容};（2）创建模块void create() //函数--创建一个新进程{if(shumu>=20) printf("\n内存已满，请先换出或杀死进程\n") //判断内存空间是否已满else{for(int i=0;i<20;i++)if(neicun[i].zhuangtai==0) break; //选出空着的内存单元给新进程使用printf("\n请输入新进程pid\n"); //输入新进程ID存至选出的内存单元scanf("%d",&(neicun[i].pid));for(int j=0;j<i;j++)if(neicun[i].pid==neicun[j].pid) //当输入的新进程与原有进程ID相同时，显示"该进程已存在"{printf("\n该进程已存在\n");return;}printf("\n请输入新进程优先级\n"); //输入新进程的优先级、大小和内容scanf("%d",&(neicun[i].youxian));printf("\n请输入新进程大小\n");scanf("%d",&(neicun[i].daxiao));printf("\n请输入新进程内容\n");scanf("%d",&(neicun[i].neirong));neicun[i].zhuangtai=1; //将新进程的内存单元状态（zhuangtai）设成"1"，以表示存在且未被换出shumu++; //正在运行的进程数目加一}}（3）查看模块void run() //函数--查看正在运行的进程{for(int i=0;i<20;i++){if(neicun[i].zhuangtai==1) //将存在且未被挂起（即zhuangtai=1）的进程显示出来，若存在这样的程序，则将flag设成1 {printf("\n pid=%d",neicun[i].pid);printf("youxian=%d",neicun[i].youxian);printf("daxiao=%d",neicun[i].daxiao);printf("zhuangtai=%d",neicun[i].zhuangtai);printf("neirong=%d",neicun[i].neirong);flag=1;}}if(!flag)printf("\n当前没有运行进程\n"); //若当前没有运行进程（即flag=0），则显示"当前没有运行进程"}（4）换出模块void huanchu() //函数--换出进程{if(!shumu) //判断是否无进程存在{printf("\n当前没有进程存在\n");return;}printf("\n 输入换出进程ID值"); //输入需要换出的进程ID scanf("%d",&pid);for(int i=0;i<20;i++){if(pid==neicun[i].pid){if(neicun[i].zhuangtai==1) //若该ID代表的进程正在运行，则将其挂起，即将zhuangyai置成2，并将guaqi 加一{neicun[i].zhuangtai=2;guaqi++;printf("\n已经成功换出进程\n");}else if(neicun[i].zhuangtai==2)printf("\n要唤出的进程已被挂起\n"); //若该ID代表的进程已被挂起，即zhuangtai==2,则显示'要唤出的进程已被挂起'flag=1;break;}}if(!flag)printf("\n要换出的进程不存在\n"); //若进程不存在，给出显示}（4）杀死模块void kill() //函数--杀死进程{if(!shumu) //判断是否无进程存在{printf("\n当前没有进程存在\n");return;}printf("\n 输入杀死进程的ID值"); //读入要杀死的进程IDscanf("%d",&pid);for(int i=0;i<20;i++){if(pid==neicun[i].pid){if(neicun[i].zhuangtai==1) //若进程正在运行则再次询问是否要杀死，通过用户的反馈执行不同操作{printf("\n该进程正在运行，您确定要杀死吗？\n");printf("\n请输1：确定；0：不确定\n");scanf("%d",&flag);if(flag){neicun[i].zhuangtai=0; //将zhuangtai置为0，表示进程被杀死，并将shumu自减一shumu--;printf("\n已经成功杀死进程\n");}elseprintf("\要杀死的进程正在运行\n");}else if(neicun[i].zhuangtai==2) //若该进程已经被挂起，则直接杀死{neicun[i].zhuangtai=0;shumu--;printf("\n已经成功杀死进程\n");}flag=1;break;}}if(flag==0)printf("\n要杀死的进程不存在\n"); //若进程不存在，给出显示}四．调试运行本程序可以在VC++6.0的环境下。
1、依次建立进程1、2、3，图中以建立进程3为例。
2、查看正在运行的进程及内存状态。
3、换出进程，图中以进程1为例。
4、此时查看正在运行的进程，可以看到进程1已经不在运行的进程中，表明进程1确实已经被换出。
5、杀死进程，图中以杀死进程2为例。
6、此时查看正在运行的进程，可以看到进程1已经不在运行的进程中，表明进程1确实已经被杀死。
五．总结分析（不足和改进）上个学期做过课程设计了，这次也稍微有了一点经验，不会像上学期一样无从着手，知道写程序之前要先把思路理清，先从大体上知道自己所写程序有哪几个模块，他们之间又有怎样的调用关系。
在写每个模块的代码时，也可以先画出程序框图帮助自己理解，然后根据程序框图来写代码，让自己的思路更加清晰。
反正对于我来说每次设计之前都会把书本里与设计题目相关的知识都看，一面有利于理清思路，一面自己也更有信心，有底气。
总体来说，这次我选的题目还是比较简单的，大体上4个模块，不过在模块的编写时，由于for循环里面使用了if语句的多层嵌套，所以也费了比较多的时间，甚至还借了同学C语言的教程来看，才终于顺利完成了编写。
以后还是要多多练习编程，实践中才能发现问题，解决问题，从而提高自身水平。