进程管理实验-C语言版

实验名称: 进程管理实验要求:阅读后面的C语言实例，修改程序，使其优先数在运行期间可以变化(动态优先数)。

例如，当某进程被时间片中断次数增加到一定数目时，提高其优先权。

关键问题:读懂源程序代码，了解进程管理的方式，并设计一个算法使程序能在运行过程中修改进程优先级。

设计思路:在进程控制块中定义一个记录进程中断次数的变量，在block函数中设置跟踪并记录进程中断次数，在调度函数schedule中设置算法，在进程中断3次后将该进程的优先级提升至最高。

改动后的代码:#include <stdio.h>#define TRUE 1#define FALSE 0#define MAXPRI 100#define NIL -1//进程控制块struct {int id; //进程号char status; //进程状态，'e'-执行态'r'-高就绪态't'-低就绪态'w'-等待态'c'-完成态int nextwr; //等待链指针，指示在同一信号量上等待的下一个等待进程的进程号。

int priority; //进程优先数，值越小，优先级越高。

int c;//进程中断次数}pcb[3];//共3个进程//s1、s2为三个进程共享的变量；seed为随机值；registeri模拟寄存器值,存放计算的重复次数。

int registeri,s1,s2,seed,exe=NIL;//exe为当前运行（占有cpu）的进程号//2个信号量sem[0]、sem[1],分别与共享变量s1、s2相联系。

//对应信号量sem[0]、sem[1]分别有两个阻塞队列，队列首由sem[].firstwr指定，队列链指针是pcb[].nextwrstruct{int value;//信号量值int firstwr;//等待该信号量的阻塞队列的首个进程号}sem[2];//三个进程的现场保留区，其中savearea[][0]为寄存器内容，savearea[][1]为下一条指令地址。

《操作系统》实验报告实验一题目用C语言模拟实现操作系统的进程管理机制一、实验内容使用顺序表模拟内存中的进程队列，实现对于进程的管理。

进程的管理主要包括进程的创建、进程的查询、进程的换出以及进程的删除等操作。

二、实验目的进程是计算机操作系统的重要的核心概念，合理的管理进程是一个操作系统最核心主要的功能之一，通过编写相应的进程程序，加强对进程概念的理解。

三、设计过程1进程结构PCB的描述：typedef struct jincheng_type{int pid;int priority;char state;int blocktime;}PCB;PCB是对进程的描述，pid代表进程号，priority代表优先级，state代表状态，blocktime代表阻塞时间。

2进程队列的描述：使用顺序表typedef struct queuelist{PCB pro[MAXSIZE];int length;}MEMORY;内存的描述，系统创建的进程都保存在这里，MAXSIZE是内存中允许存放最大的进程数目3本实验主要包含如下三个主要操作（1）创建进程操作void create(MEMORY *P,int count);参数P是指向存放进程的内存指针（头指针），count是指创建进程的数目。

（2）查询进程操作int check(MEMORY *P,int pid);参数P是指向存放进程的内存指针（头指针），pid是指查询进程的进程号，若查询到该进程则返回OK（1），否则返回ERROR（0）。

（3）置换进程操作int exchange(MEMORY *P);参数P是指向存放进程的内存指针（头指针），将换出的进程保存在PCB pcb;中，若换出某个进程则返回OK（1），否则返回ERROR（0）。

（4）删除进程操作int kill(MEMORY *P,int i);参数P是指向存放进程的内存指针（头指针），删除内存中第i个进程，若删除某个进程则返回OK （1），否则返回ERROR （0）。

一、实验目的1. 理解进程的基本概念，掌握进程的结构和生命周期。

2. 掌握进程的创建、终止、同步和通信的方法。

3. 熟悉进程调度算法和进程同步机制。

4. 通过实验加深对操作系统进程管理的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 实验工具：gcc、make、xterm三、实验内容1. 进程的创建与终止（1）使用fork()系统调用创建进程编写一个C程序，通过fork()系统调用创建一个子进程。

父进程和子进程分别执行不同的任务，并输出各自的信息。

```c#include <stdio.h>#include <sys/types.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid == -1) {printf("Fork failed!\n");return 1;printf("This is child process, PID: %d\n", getpid()); // 子进程执行的任务} else {printf("This is parent process, PID: %d\n", getpid()); // 父进程执行的任务}return 0;}```（2）使用exec()系统调用替换子进程内容在父进程中，使用exec()系统调用替换子进程的内容，执行新的程序。

```c#include <stdio.h>#include <sys/types.h>#include <sys/wait.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid == -1) {printf("Fork failed!\n");return 1;execlp("ls", "ls", "-l", (char )NULL);printf("Exec failed!\n");return 1;} else {wait(NULL);}return 0;}```2. 进程同步与通信（1）使用管道实现进程通信编写一个C程序，使用管道实现父进程和子进程之间的通信。

最新实验二-实验报告(进程管理)实验目的：1. 理解操作系统中进程的概念及其特性。

2. 掌握进程管理的基本原理和方法。

3. 学习进程创建、撤销、阻塞和唤醒等操作。

4. 熟悉进程间的同步与通信机制。

实验环境：- 操作系统：Linux/Unix- 编程语言：C/C++- 开发工具：GCC编译器，GDB调试器实验内容：1. 创建进程：编写程序，使用系统调用fork()创建子进程，并观察父进程与子进程的行为差异。

2. 进程撤销：实现一个程序，通过系统调用exit()或abort()撤销进程，并观察其对进程组和会话的影响。

3. 进程阻塞与唤醒：设计并实现一个父进程和多个子进程的程序，其中子进程执行阻塞操作（如sleep()），父进程负责唤醒这些子进程。

4. 进程同步：利用信号量或管程等同步机制，实现两个并发进程的同步操作。

5. 进程通信：通过管道(PIPE)、消息队列、共享内存等IPC机制，实现进程间的信息交换。

实验步骤：1. 设计并编写创建进程的程序代码。

2. 在Linux环境下使用GCC编译程序，并记录编译过程。

3. 运行程序，使用GDB等工具调试程序，并观察fork()的执行效果。

4. 实现进程撤销的程序，并记录exit()和abort()的不同行为。

5. 编写进程阻塞与唤醒的程序，并通过实验观察不同进程状态的变化。

6. 完成进程同步的代码实现，并测试死锁及其解决方法。

7. 编写并测试进程通信的程序，确保信息能够正确传递。

实验结果：- 展示创建进程前后的系统状态变化，包括进程表和内存分配情况。

- 记录进程撤销后，父进程收集子进程状态的输出。

- 展示进程阻塞与唤醒的输出结果，验证进程状态转换的正确性。

- 展示进程同步的实验结果，包括死锁的产生与解决。

- 展示进程通信的测试结果，验证信息传递的准确性。

实验分析：- 分析进程创建和撤销的系统资源变化。

- 讨论进程阻塞与唤醒机制的效率和应用场景。

- 探讨进程同步与通信的复杂性及其在多线程编程中的重要性。

#include"stdio.h"#include"stdlib.h"#define ready 1#define run 2struct pcb{char name[10];int priority; /*进程的优先级*/int state; /*进程的状态:可以有run、ready、finish(可有可无)*/int needtime; /*进程需要运行的时间*/int runtime;int time; /*进程已运行的时间*/struct pcb *next; /*指向下一个进程PCB的指针*/};typedef struct pcb PCB;PCB *head=NULL;/*此函数用于创建进程队列*/void create(void){ PCB *p, *q;int n,i;printf("Enter the number of the process:");scanf("%d",&n); /*输入要创建的进程的数量*/ head=(PCB *)malloc(sizeof(PCB)); /*创建一个表头结点*/p=head;for(i=1;i<=n;i++) /*用循环来创建指定个结点*/ { q=(PCB*)malloc(sizeof(PCB));p->next=q;p=q;printf("\nenter the NO.%d name of process:",i);scanf("%s",&p->name);printf("enter the priority of process:");scanf("%d",&p->priority);printf("enter the time need:");scanf("%d",&p->needtime);p->state=ready;p->runtime=0;p->next=NULL;}}/*删除执行完毕的进程*/void delete(PCB *head,PCB *p) {PCB *q;q=head;while(q->next!=p)q=q->next;q->next=p->next;free(p);}/*找出执行时间最短的进程*/PCB *getminneedtime(PCB *head) {PCB *p,*q;p=head->next;q=p->next;while(q){if(p->needtime>q->needtime)p=q;q=q->next;}return(p);}/*找出优先级最高的进程*/PCB *getpriority(PCB *head) {PCB *p,*q;p=head->next;q=p->next;while(q){if (p->priority>q->priority)p=q;}return (p);}/*时间片轮转*/void RR (void){ PCB *p,*q,*r;int time;printf("input the time:\n ");scanf("%d",&time);for(p=head->next;p->next;p=p->next) {r=p;}while(head->next){p=head->next; /*选出就绪队列的第一个进程*/p->state=run;printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->needtime);q=head->next;if(p->needtime-p->runtime<=p->time) /*时间片内，进程运行结束否*/ {p->runtime=p->needtime;printf("runtime:%d\n",p->runtime);}else{p->runtime=p->runtime+p->time;printf("runtime:%d\n",p->runtime);}q=p->next;if(q!=NULL) /*输出就绪队列中的进程信息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");q=q->next;}if(p->runtime==p->needtime){delete(head,p);}else{head->next=p->next;r->next=p;r=p;r->state=ready;r->next=NULL;}}}/*优先权调度算法*/void HPF (void){PCB *p,*q;int flag=1;while(head->next){ if(flag==1){p=getpriority(head); /*调用“找出执行时间最短的进程”函数*/p->state=run;} /*将选出的进程的状态改为“run”*/(p->runtime)++;(p->priority)--;printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->runtime);q=head->next;if(q->next!=NULL) /*输出就绪队列中的进息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){if(q!=p){ printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");}q=q->next;}if(p->runtime==p->needtime){ delete(head,p);}else{for(q=head->next;q;q=q->next)if(p->priority>=q->priority){flag=0;}else { flag=1;p->state=ready;}}/*将该运行结束的进程删除掉*/}}/*短作业优先*/void SJF (void){PCB *p,*q;while(head->next){ p=getminneedtime(head); /*调用“找出执行时间最短的进程”函数*/p->state=run; /*将选出的进程的状态改为“run”*/printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->needtime);q=head->next;if(q->next!=NULL) /*输出就绪队列中的进程信息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){if(q!=p){ printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");}q=q->next;}delete(head,p); /*将该运行结束的进程删除掉*/ }}/*输出菜单*/void printfunc(void){printf(" *******************\n");printf(" * 1-create *\n");printf(" * 2-SJF *\n");printf(" * 3-HPF *\n");printf(" * 4-RR *\n");printf(" * 0-exit *\n");printf(" *******************\n");}/*主函数*/main(){int choice;printfunc();do{printf("please input the number:");scanf("%d",&choice);getchar();switch (choice){case 1:create();printfunc();break;case 2:if(head==NULL || head->next==NULL)printf("就绪队列没有进程，请先创建进程\n");else{SJF();printfunc();}break;case 3:if(head==NULL || head->next==NULL)printf("就绪队列没有进程，请先创建进程\n");else{HPF();printfunc();}break;case 4 :if(head==NULL || head->next==NULL)printf("就绪队列没有进程，请先创建进程\n");else{RR();printfunc();}break;case 0:exit(0);}}while(1);}。

实验一进程管理1．目的和要求通过实验理解进程的概念，进程的组成（PCB结构），进程的并发执行和操作系统进行进程管理的相关原语（主要是进程的创建、执行、撤消）。

2．实验内容用C语言编程模拟进程管理，至少要有：创建新的进程；查看运行进程；换出某个进程；杀死运行进程以及进程之间通信等功能。

3．实验环境Windows操作系统、VC++6.0C语言4．实验提示PCB结构通常包括以下信息：进程名，进程优先数，轮转时间片，进程所占用的CPU时间，进程的状态，当前队列指针等。

可根据实验的不同，PCB结构的内容可以作适当的增删。

主体程序#include "conio.h"#include "stdio.h"#include "stdlib.h"struct jincheng_type{int pid;int youxian;int daxiao;int msg;int live;};struct jincheng_type neicun[20],waicun[20];int shumu=0,pid_l;main(){int n,m,i;char a;n=1;while(n==1){system("cls");printf("\n********************************************");printf("\n* 进程演示系统*");printf("\n********************************************");printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.进程之间通信 6.退出");printf("\n********************************************");printf("\n请选择（1～6) ");a=getch();switch(a){case'1':create( );break;case'2':viewrun( );break;case'3':huanchu();break;case'4':kill( );break;case'5':tongxun( );break;case'6': exit(0);default: n=0;}}}create( ) /* 创建一个进程的示例（不完整的程序）*/ {if(shumu>=20){printf("\n内存已满，请先结束或换出进程\n");}else{printf("\n请输入新进程的pid\n");scanf("%d",&neicun[shumu+1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu+1].youxian);printf("\n请输入新进程的大小\n");scanf("%d",&neicun[shumu+1].daxiao);printf("\n请输入新进程的消息\n");scanf("%d",&neicun[shumu+1].msg);neicun[shumu+1].live=1;shumu++;}return neicun[shumu-1].live;}viewrun( )/*查看运行进程*/{int vpid;printf("\n请输入进程的pid\n");scanf("%d",&vpid);if(vpid>0&&vpid<=20&&neicun[vpid].live==1){printf("\n进程的pid是: %d\n",neicun[vpid].pid);printf("进程的优先级是: %d\n",neicun[vpid].youxian);printf("进程的大小是:%d\n",neicun[vpid].daxiao);printf("进程的消息是:%d\n",neicun[vpid].msg);}else{printf("\n所查看运行进程不存在\n");}printf("请按回车退出查看\n");vpid=getch();}huanchu()/*换出某个进程*/{int pid1,pid2;char c;printf("\n请输入第一个替换进程的pid\n");scanf("%d",&pid1);printf("\n请输入第二个替换进程的pid\n");scanf("%d",&pid2);if(pid1>0&&pid1<=20&&neicun[pid1].live==1){if(neicun[pid1].youxian>neicun[pid2].youxian){waicun[20].pid=neicun[pid1].pid;waicun[20].youxian=neicun[pid1].youxian;waicun[20].daxiao=neicun[pid1].daxiao;waicun[20].msg=neicun[pid1].msg;neicun[pid1].pid=neicun[pid2].pid;neicun[pid1].youxian=neicun[pid2].youxian;neicun[pid1].daxiao=neicun[pid2].daxiao;neicun[pid1].msg=neicun[pid2].msg;neicun[pid2].pid=waicun[20].pid;neicun[pid2].youxian=waicun[20].youxian;neicun[pid2].daxiao=waicun[20].daxiao;neicun[pid2].msg=waicun[20].msg;printf("\n替换完成\n");printf("\n被替换进程的pid是: %d\n",waicun[20].pid); printf("被替换进程的优先级是: %d\n",waicun[20].youxian); printf("被替换进程的大小是:%d\n",waicun[20].daxiao); printf("被替换进程的消息是:%d\n",waicun[20].msg);}else{printf("\n进程优先级不够大");}}else{printf("所查看运行进程不存在");}printf("请按回车退出换出进程\n");c=getche();return;}kill()/*杀死运行进程*/{int kpid;printf("\n请输入进程的pid\n");scanf("%d",&kpid);if(kpid>0&&kpid<20&&neicun[kpid].live==1){neicun[kpid].live=0;}return;}tongxun( )/*进程之间通信*/{int tpid1,tpid2;int buffer;char d;printf("\n请输入通信源进程pid\n");scanf("%d",&tpid1);printf("\n请输入通信目的进程pid\n");scanf("%d",&tpid2);if(tpid1>0&&tpid1<20&&neicun[tpid1].live==1){buffer=neicun[tpid1].msg;neicun[tpid1].msg=neicun[tpid2].msg;neicun[tpid2].msg=buffer;printf("\n源进程的消息是: %d\n",neicun[tpid1].msg);printf("\n目的进程的消息是: %d\n",neicun[tpid2].msg);}else{printf("\n所查看运行进程不存在\n");}printf("\n请按回车退出进程通信\n");d=getch();return;}5．实验运行结果******************************************** * 进程演示系统* ********************************************1.创建新的进程2.查看运行进程3.换出某个进程4.杀死运行进程5.进程之间通信6.退出系统******************************************** 请选择（1～6）然后根据你选择的不同，出现不同的结果。

电大操作系统实验报告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. 理解进程的概念和进程管理的基本原理。

2. 掌握进程的创建、调度、同步和通信等操作。

3. 通过编程实现简单的进程管理功能。

二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);sleep(1); // 模拟任务执行pthread_mutex_unlock(&mutex); // 解锁return NULL;}int main() {pthread_t thread1, thread2;// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_create(&thread1, NULL, thread_func, (void )1); pthread_create(&thread2, NULL, thread_func, (void )2); // 等待线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。

一、实验目的1. 理解进程的基本概念和进程管理的基本原理。

2. 掌握进程的创建、调度、同步和通信等基本操作。

3. 通过实验加深对进程管理的理解和应用。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验内容1. 进程的创建与终止2. 进程的调度3. 进程同步4. 进程通信四、实验步骤1. 进程的创建与终止（1）编写代码创建一个进程，并获取该进程的进程ID（PID）。

（2）编写代码终止创建的进程。

2. 进程的调度（1）编写代码实现一个简单的进程调度算法，如先来先服务（FCFS）。

（2）模拟多个进程的运行，观察进程调度的效果。

3. 进程同步（1）编写代码实现生产者-消费者问题，使用互斥锁和条件变量实现进程同步。

（2）观察生产者和消费者进程的同步效果。

4. 进程通信（1）编写代码实现进程间通信，使用管道实现进程间的数据传递。

（2）观察进程间通信的效果。

五、实验结果与分析1. 进程的创建与终止实验结果：成功创建了进程，并通过PID获取到了进程信息。

终止进程后，进程的运行状态变为退出状态。

分析：通过实验，我们掌握了进程的创建与终止的基本操作，了解了进程的基本属性。

2. 进程的调度实验结果：实现了FCFS调度算法，模拟了多个进程的运行。

观察结果显示，进程按照创建顺序依次执行。

分析：通过实验，我们了解了进程调度的基本原理，掌握了FCFS调度算法的实现方法。

3. 进程同步实验结果：实现了生产者-消费者问题，观察结果显示，生产者和消费者进程可以同步执行，不会出现生产者等待消费者消费或消费者等待生产者生产的情况。

分析：通过实验，我们掌握了进程同步的基本方法，了解了互斥锁和条件变量的作用。

4. 进程通信实验结果：实现了进程间通信，观察结果显示，两个进程可以成功传递数据。

分析：通过实验，我们掌握了进程间通信的基本方法，了解了管道在进程通信中的应用。

六、实验总结通过本次实验，我们学习了进程管理的基本概念和原理，掌握了进程的创建、调度、同步和通信等基本操作。