进程的创建 操作系统实验报告
操作系统实验报告--进程的创建
{
printf("父进程id=%d,父进程打印a\n",getpid());
exit(0);
}
}
随机执行：
程序执行如下：
1.父进程里的fork调用，复制父进程生成一个副本即为子进程1
2.得到父进程与子进程1
3.随机执行这两进程中的一个，（两个进程都是压在栈里）
4.假设（那么栈底下的就是父进程）执行的是子进程1，则fork返回值是0，则for循环中断！这是也是子进程不能创建自己的子子进程的一个重点！i=0，往下继续执行当前进程的后面的程序，打印当前子进程1的信息，并且按照要求打印出b。这个进程执行完毕后自动销毁！
printf("\n开始调用fork函数:\n如果调用成功应该会生成一个子进程1\n返回值： 若成功调用一次则返回两个值，\n子进程返回0，父进程返回子进程标记(ID)；\n否则，出错返回-1。\n");
fpid1=fork();
fpid2=fork();
if(fpid1<0)exit(0);
else if(fpid1>0)
{
break;
}
}
if(pid==-1)
{
perror("fail to fork!\n");
exit(1);
}
else if(pid==0)
{
printf("子进程%did=%d,打印%c,其对应的父进程id=%d\n",i+1,getpid(),98+i,getppid());
exit(0);
}
源代码：
#include<stdio.h>
#include<unistd.h>
进程的创建实验报告
进程的创建实验报告进程的创建实验报告引言：在计算机科学领域中，进程是一个非常重要的概念。
进程是计算机程序的执行实例，它具有独立的内存空间和执行环境。
进程的创建是操作系统中一个关键的操作，本实验旨在通过编写一个简单的程序来演示进程的创建过程。
实验目的：通过实验，我们的目标是深入理解进程的创建过程，并了解操作系统是如何管理进程的。
实验步骤：1. 引入必要的头文件：在开始编写代码之前，我们需要引入一些必要的头文件。
这些头文件包括<sys/types.h>、<sys/wait.h>和<unistd.h>。
这些头文件提供了创建进程所需的函数和数据类型。
2. 创建一个子进程：在主程序中，我们使用fork()函数来创建一个子进程。
fork()函数会在当前进程的基础上创建一个新的进程，这个新进程称为子进程。
子进程和父进程几乎完全相同，只有在返回值上有所区别。
如果fork()函数返回0，表示当前进程是子进程；如果返回一个正整数，表示当前进程是父进程。
3. 子进程的执行：在子进程中，我们可以编写任意的代码来执行特定的任务。
子进程可以使用exec()函数来执行其他程序，或者执行一系列的操作。
在本实验中，我们简单地输出一条信息，以展示子进程的执行过程。
4. 父进程的执行：在父进程中，我们可以编写代码来执行其他任务，或者等待子进程的结束。
在本实验中，我们使用wait()函数来等待子进程的结束。
wait()函数会暂停父进程的执行，直到子进程结束为止。
5. 编译和运行程序：在完成代码编写后，我们需要将程序编译成可执行文件，并运行它。
我们可以使用gcc编译器来编译程序，然后运行生成的可执行文件。
实验结果：在运行程序后，我们可以观察到以下结果：子进程开始执行。
父进程等待子进程结束。
子进程结束。
父进程继续执行。
结论：通过本实验，我们成功地演示了进程的创建过程。
我们了解了操作系统是如何管理进程，并且掌握了使用fork()函数来创建子进程的方法。
操作系统实验二实验报告
操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术，包括进程的创建、执行、同步和通信。
通过实际编程和实验操作，提高对操作系统原理的认识，培养解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程环境为 Visual Studio 2019。
三、实验内容及步骤（一）进程创建实验1、首先，创建一个新的 C+＋项目。
2、在项目中，使用 Windows API 函数`CreateProcess`来创建一个新的进程。
3、为新进程指定可执行文件的路径、命令行参数、进程属性等。
4、编写代码来等待新进程的结束，并获取其退出代码。
（二）进程同步实验1、设计一个生产者消费者问题的模型。
2、使用信号量来实现生产者和消费者进程之间的同步。
3、生产者进程不断生成数据并放入共享缓冲区，当缓冲区已满时等待。
4、消费者进程从共享缓冲区中取出数据进行处理，当缓冲区为空时等待。
（三）进程通信实验1、选择使用管道来实现进程之间的通信。
2、创建一个匿名管道，父进程和子进程分别读写管道的两端。
3、父进程向管道写入数据，子进程从管道读取数据并进行处理。
四、实验结果及分析（一）进程创建实验结果成功创建了新的进程，并能够获取到其退出代码。
通过观察进程的创建和执行过程，加深了对进程概念的理解。
（二）进程同步实验结果通过使用信号量，生产者和消费者进程能够正确地进行同步，避免了缓冲区的溢出和数据的丢失。
分析结果表明，信号量机制有效地解决了进程之间的资源竞争和协调问题。
（三）进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。
数据能够准确地在进程之间传递，验证了管道通信的有效性。
五、遇到的问题及解决方法（一）在进程创建实验中，遇到了参数设置不正确导致进程创建失败的问题。
通过仔细查阅文档和调试，最终正确设置了参数，成功创建了进程。
（二）在进程同步实验中，出现了信号量使用不当导致死锁的情况。
操作系统进程的创建实验报告
分析main（）函数流程图如下：
三、.思考题
1)进程创建的核心内容是什么？
答：内容是：1、申请空白PCB 2、为新进程分配资源
3、初始化进程控制块4、将新进程插入到就绪队列
2)该设计和实际的操作系统进程创建相比，缺少了哪些步骤？
答缺少的步骤有：只是模拟的创建，并没有分配资源
只是模拟的创建并没有分配资源四实验总结通过本次实验让我对进程的创建有更深的理解是我真真切切的理解到进程和程序的本质区别
一、实验内容
树形图1：
树形图1分析：进程1、2、3是根进程的子进程，相反的根进程是进程1、2、3的父进程，他们分别对应的优先级为2、2、2；接下来进程4、5又是进程1的子进程，进程6、7是进程2的子进程，进程8是进程3的子进程。
四、实验总结
通过本次实验，让我对进程的创建有更深的理解，是我真真切切的理解到进程和程序的本质区别。学会了如何使用基本命令进行调试和运行程序。总之这让我受益非浅。
各个方面都很符合要求,完成很好,体会写得很深入,继续努力ing。
输入如下：
createpc(1,0,2)
createpc(2,0,2)
createpc(3,0,2)
createpc(4,2,3)
createpc(5,2,3)
createpc(6,2,3)
createpc(7,5,3)
createpc(8,5,3)
运行截图如下：
二、函数分析：
分析createpc(para)函数流程图如下：
输入如下：
createpc(1,0,2)
createpc(2,0,2)
createpc(3,0,2)
createpc(4,0,2)
进程创建实验报告
进程创建实验报告进程创建实验报告引言：进程是计算机系统中的基本概念之一，也是操作系统的核心概念之一。
进程创建是操作系统中的一个重要操作，它涉及到资源的分配和管理，对于操作系统的正常运行具有重要意义。
本实验旨在通过编写一个简单的程序，探索进程创建的过程以及相关概念。
一、实验目的本实验的主要目的是了解进程创建的基本过程，并掌握相关的概念和操作。
通过实践，加深对操作系统的理解和应用。
二、实验环境本实验使用的是Linux操作系统，具体的版本为Ubuntu 20.04 LTS。
在该环境下，我们可以使用C语言编写程序，并通过gcc编译器进行编译和运行。
三、实验步骤1. 编写源代码首先，我们需要编写一个简单的C语言程序，用于创建一个新的进程。
在程序中，我们可以使用fork()函数来创建新的进程。
具体的代码如下：```c#include <stdio.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("Failed to create a new process.\n");} else if (pid == 0) {printf("This is the child process.\n");} else {printf("This is the parent process.\n");}return 0;}```2. 编译和运行程序在终端中，使用gcc编译器将源代码编译为可执行文件。
具体的命令如下：```shellgcc -o process_create process_create.c```编译成功后，我们可以通过运行可执行文件来创建新的进程。
具体的命令如下：```shell./process_create```3. 观察输出结果运行程序后，我们可以观察到输出结果。
进程操作实验报告
进程操作实验报告进程操作实验报告一、引言进程是计算机系统中最基本的概念之一，它代表了正在运行的程序。
在操作系统中，进程的管理和操作是非常重要的。
本实验旨在通过对进程操作的实践，加深对进程概念的理解，并掌握进程的创建、调度和终止等操作。
二、实验目的1. 理解进程的概念和基本属性；2. 掌握进程的创建和终止操作；3. 熟悉进程调度算法的实现；4. 加深对操作系统中进程管理的理解。
三、实验环境本次实验使用的操作系统为Linux，并且需要具备C语言编程基础。
四、实验内容1. 进程的创建进程的创建是操作系统中的一个重要操作。
通过调用fork()函数，可以在当前进程的基础上创建一个新的子进程。
子进程将继承父进程的资源，包括内存空间、文件描述符等。
通过实验，我们可以编写一个简单的程序，演示进程的创建过程，并观察子进程和父进程的行为差异。
2. 进程的调度进程调度是操作系统中的核心功能之一。
在多任务系统中，操作系统需要合理地分配CPU时间片，以便每个进程都能得到执行的机会。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。
通过实验，我们可以编写一个简单的程序，模拟进程的调度过程，并观察不同调度算法对进程执行顺序的影响。
3. 进程的终止进程的终止是操作系统中的另一个重要操作。
通过调用exit()函数，可以结束当前进程的执行，并释放相关资源。
在实验中，我们可以编写一个程序，演示进程的终止过程，并观察终止进程后系统的行为。
五、实验步骤1. 进程的创建实验步骤：（1）编写一个简单的程序，调用fork()函数创建子进程；（2）在父进程和子进程中分别输出不同的信息，以便观察其行为差异；（3）编译并运行程序，观察输出结果。
2. 进程的调度实验步骤：（1）编写一个简单的程序，模拟多个进程的执行；（2）使用不同的调度算法，如FCFS、SJF、RR等，对进程进行调度；（3）观察不同调度算法对进程执行顺序的影响，并比较它们的优缺点。
操作系统实验报告(进程的创建)
wait(0);printf("parent process doesn't change the glob and loc:\n");printf("glob=%d,loc=%d\n",glob,loc);exit(0);}运行结果：2、理解vofork（）调用：程序代码：#include<stdio.h>#include<sys/types.h>#include<unistd.h>int glob=3;int main(void){pid_t pid;int loc=3;if((pid=vfork())<0){printf("vfork() error\n");exit(0);}else if(pid==0){glob++;loc--;printf("child process changes the glob and loc\n");exit(0);}elseprintf ("parent process doesn't change the glob and loc\n");printf("glob=%d,val=%d\n",glob,loc);}运行结果：3、给进程指定一个新的运行程序的函数exec().程序代码：printe1.c代码：#include<stdio.h>int main(int argc,char * argv[]){int n;char * * ptr;extern char * * environ;for(n=0;n<argc;n++)printf("argv[%d]:%s\n",n,argv[n]);for(ptr=environ; * ptr!=0;ptr++)printf("%s\n",* ptr);exit(0);}file4.c代码如下：#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>char * env_list[]={"USER=root","PATH=/root/",NULL};int main(){pid_t pid;if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execle("/root/print1","print1","arg1","arg2",(char *)0,env_list)<0) printf("execle error!\n");exit(0);}if((waitpid(pid,NULL,0))<0)printf("WAIT ERROR!\n");exit(0);if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execlp("print1","print1","arg1",(char *)0)<0)printf("execle error!\n");exit(0);}exit(0);}运行结果：4、进程终止函数exit()。
《操作系统》实验报告
一、实验目的1. 理解进程的概念及其在操作系统中的作用。
2. 掌握进程的创建、调度、同步和通信机制。
3. 学习使用进程管理工具进行进程操作。
4. 提高对操作系统进程管理的理解和应用能力。
二、实验环境1. 操作系统：Windows 102. 软件环境：Visual Studio 20193. 实验工具：C++语言、进程管理工具（如Task Manager）三、实验内容1. 进程的创建与销毁2. 进程的调度策略3. 进程的同步与互斥4. 进程的通信机制四、实验步骤1. 进程的创建与销毁（1）创建进程使用C++语言编写一个简单的程序，创建一个新的进程。
程序如下：```cpp#include <iostream>#include <windows.h>int main() {// 创建进程STARTUPINFO si;PROCESS_INFORMATION pi;ZeroMemory(&si, sizeof(si));si.cb = sizeof(si);ZeroMemory(&pi, sizeof(pi));// 创建进程if (!CreateProcess(NULL, "notepad.exe", NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {std::cout << "创建进程失败" << std::endl;return 1;}std::cout << "进程创建成功" << std::endl;// 等待进程结束WaitForSingleObject(pi.hProcess, INFINITE);// 销毁进程CloseHandle(pi.hProcess);CloseHandle(pi.hThread);return 0;}```（2）销毁进程在上面的程序中，通过调用`WaitForSingleObject(pi.hProcess, INFINITE)`函数等待进程结束，然后使用`CloseHandle(pi.hProcess)`和`CloseHandle(pi.hThread)`函数销毁进程。
进程操作的实验报告
一、实验目的1. 理解进程的基本概念和进程控制块（PCB）的作用。
2. 掌握进程创建、调度、同步和通信的基本方法。
3. 熟悉进程状态转换及进程同步机制。
4. 提高编程能力，加深对操作系统进程管理的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验内容1. 进程创建与销毁2. 进程调度3. 进程同步4. 进程通信四、实验步骤1. 进程创建与销毁（1）定义进程结构体```ctypedef struct {int pid; // 进程IDchar name[50]; // 进程名int status; // 进程状态struct PCB next; // 指向下一个进程的指针} PCB;```（2）创建进程```cPCB createProcess(char name) {PCB newProcess = (PCB )malloc(sizeof(PCB)); newProcess->pid = ...; // 分配进程IDstrcpy(newProcess->name, name);newProcess->status = ...; // 初始化进程状态 newProcess->next = NULL;// ... 其他初始化操作return newProcess;}```（3）销毁进程```cvoid destroyProcess(PCB process) {free(process);}```2. 进程调度（1）定义进程队列```ctypedef struct {PCB head; // 队列头指针PCB tail; // 队列尾指针} ProcessQueue;```（2）初始化进程队列```cvoid initProcessQueue(ProcessQueue queue) {queue->head = NULL;queue->tail = NULL;}```（3）入队```cvoid enqueue(ProcessQueue queue, PCB process) { if (queue->head == NULL) {queue->head = process;queue->tail = process;} else {queue->tail->next = process;queue->tail = process;}}（4）出队```cPCB dequeue(ProcessQueue queue) {if (queue->head == NULL) {return NULL;}PCB process = queue->head;queue->head = queue->head->next; if (queue->head == NULL) {queue->tail = NULL;}return process;}```3. 进程同步（1）互斥锁```ctypedef struct {int locked; // 锁的状态} Mutex;void initMutex(Mutex mutex) {mutex->locked = 0;void lock(Mutex mutex) {while (mutex->locked) {// 等待锁释放}mutex->locked = 1;}void unlock(Mutex mutex) {mutex->locked = 0;}```（2）信号量```ctypedef struct {int count; // 信号量值Mutex mutex; // 互斥锁} Semaphore;void initSemaphore(Semaphore semaphore, int count) { semaphore->count = count;initMutex(&semaphore->mutex);}void P(Semaphore semaphore) {lock(&semaphore->mutex);while (semaphore->count <= 0) {// 等待信号量}semaphore->count--;unlock(&semaphore->mutex);}void V(Semaphore semaphore) {lock(&semaphore->mutex);semaphore->count++;unlock(&semaphore->mutex);}```4. 进程通信（1）管道通信```cint pipe(int pipefd[2]) {// 创建管道}void writePipe(int pipefd[2], const void buf, size_t nbyte) { // 向管道写入数据}void readPipe(int pipefd[2], void buf, size_t nbyte) {// 从管道读取数据}```（2）消息队列通信```cint msgget(key_t key, int msgflg) {// 创建消息队列}void msgsnd(int msqid, const void msgp, size_t msgsz, int msgflg) {// 向消息队列发送消息}void msgrcv(int msqid, void msgp, size_t msgsz, long msgtype, int msgflg) {// 从消息队列接收消息}```五、实验结果与分析1. 进程创建与销毁：通过创建和销毁进程，验证了进程结构体的正确性。
计算机操作系统实训教程之进程的创建实验报告
计算机操作系统实训教程实验报告姓名王学杰专业计算机应用技术班级班课程操作系统实验项目进程的创建【实验目的】.加深对进程、进程树等概念的理解。
.进一步明确进程和程序的区别。
.理解进程并发执行的实质。
.掌握系统中进程的创建方法及并发执行的情况。
【实验内容】.编写一段程序，使用系统调用（）创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一段字符信息。
.学习对后台执行程序的控制方式。
.分析程序执行过程中产生的子进程情况。
【实验步骤】一、、编写源代码生成源文件“$ ”。
.编译“$ –”。
.前台运行“$ ”（按组合键终止死循环的程序）。
.多次使用–命令查看进程状态。
.使用命令控制该进程。
二、编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
.后台运行“$ ”。
.查看进程树“$ ”。
三例编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
.运行“$ ”。
四编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
.运行“$”。
五编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
运行结果如下【实验总结】一、入门知识一个进程，包括代码、数据和分配给进程的资源。
（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。
一个进程调用（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。
然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。
相当于克隆了一个自己。
调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：）在父进程中，返回新创建子进程的进程；）在子进程中，返回；）如果出现错误，返回一个负值；二、（）与（）区别（）与（）都是创建一个进程，那他们有什么区别呢？总结有以下三点区别：. （）：子进程拷贝父进程的数据段，堆栈段（）：子进程与父进程共享数据段. （）父子进程的执行次序不确定保证子进程先运行，在调用或之前与父进程数据是共享的,在它调用或之后父进程才可能被调度运行。
操作系统实验一(进程创建、删除、调度等)实验报告
实验一实验报告实验源码：#include "stdio.h"#include <stdlib.h>#include <string.h>#include <conio.h>#include <iostream.h>#include <windows.h>// 内存最大装备作业数#define N 5#define P_TIME 50struct PCB{int pid; // 进程idint priority; // 优先权int size; // 大小int state; // 进程状态0表示不存在1表示运行状态2表示阻塞状态char info[10]; // 消息};struct PCB neicun[N];int shumu = 0, guaqi = 0;int pid;int flag = 0; // 查找相应进程是否存在的标志// 进程调度enum state{ready,working,block,finish};// 定义进程状态struct D_PCB{char name[4]; // 进程名int priority; // 优先权int cputime; // CPU运行时间int needtime; // 进程运行所需时间int count; // 进程执行次数int round; // 时间片轮转轮次state process; // 进程状态D_PCB *next;};// 定义进程PCB// 创建进程void create(){system("cls");if(shumu >= N) printf("\n内存已满，请先换出或杀死进程\n");else{for(int i = 0; i < N; i++)// 定位，找到还未创建的进程if(neicun[i].state == 0) break;printf("请输入新进程pid\n");scanf("%d",&(neicun[i].pid));for(int j = 0; j < i; j++)if(neicun[j].pid == neicun[i].pid){printf("\n该进程已存在\n");return;}printf("请输入新进程优先级\n");scanf("%d",&(neicun[i].priority));printf("请输入新进程大小\n");scanf("%d",&(neicun[i].size));printf("请输入新进程内容\n");scanf("%s",&(neicun[i].info));// 创建进程，使标记位为1neicun[i].state = 1;shumu++;}}// 查看运行进程void run(){system("cls");printf("\npid\tprioroty\tsize\tstate\tinfo\n");for(int i = 0; i < N; i++){if(neicun[i].state == 1){// 输出运行进程的各个属性值printf("%d\t%d\t\t%d\t%d\t%s\n",neicun[i].pid,neicun[i].priority,neicun[i].size,n eicun[i].state,neicun[i].info);flag = 1;}}if(!flag) printf("\n当前没有运行进程\n");}// 换出进程void huanchu(){system("cls");if(!shumu){printf("当前没有运行进程\n");return;}printf("\n输入换出运行进程ID值\n");scanf("%d",&pid);for(int i = 0; i < N; i++){// 定位，找到所要换出的进程，根据其状态做相应处理if(pid == neicun[i].pid){if(neicun[i].state == 1){neicun[i].state = 2;guaqi++;printf("\n已经成功换出进程\n");}else if(neicun[i].state == 0) printf("\n要换出的进程不存在\n");else printf("\n换出的进程已被挂起\n");flag = 1;break;}}// 找不到，则说明不存在if(flag == 0) printf("\n要换出的进程不存在\n");}// 杀死进程void kill(){system("cls");if(!shumu){printf("当前没有运行进程\n");return;}printf("\n输入杀死进的的ID值\n");scanf("%d",&pid);for(int i = 0; i < N; i++){// 定位，找到所要杀死的进程，根据其状态做相应处理if(pid == neicun[i].pid){if(neicun[i].state == 1){neicun[i].state = 0;shumu--;printf("\n已成功杀死进程\n");}else if(neicun[i].state == 0) printf("\n要杀死的进程不存在\n");else printf("\n要杀死的进程已被挂起\n");flag = 1;break;}}// 找不到，则说明进程不存在if(!flag) printf("\n要杀死的进程不存在\n");}// 唤醒进程void huanxing(){system("cls");if(!shumu){printf("当前没有运行进程\n");return;}if(!guaqi){printf("\n当前没有挂起进程\n");return;}printf("\n输入pid：\n");scanf("%d",&pid);for(int i = 0; i < N; i++){// 定位，找到所要杀死的进程，根据其状态做相应处理if(pid == neicun[i].pid){flag = 0;if(neicun[i].state = 2){neicun[i].state = 1;guaqi--;printf("\n已经成功唤醒进程\n");} else if (neicun[i].state == 0)printf("\n要唤醒的进程不存在\n");break;}}// 找不到，则说明进程不存在if(flag) printf("\n要唤醒的进程不存在\n");}// 进程通信void tongxin(){system("cls");int ps,pr;printf("Please enter sender's pid:\n");scanf("%d",&ps);printf("Please enter receiver's pid:\n");scanf("%d",&pr);for(int i = 0; i < N; i++){for(int j = 0; j < N; j++){if((neicun[i].pid == ps) && (neicun[j].pid == pr))strcpy(neicun[j].info, neicun[i].info);}}}// 进程调度// 优先权调度算法// 输入模拟测试的进程名和执行所需时间，初始设置可模拟5个进程的调度D_PCB *get_process(){D_PCB *q;D_PCB *t;D_PCB *p;int i = 0;int P_NUM;printf("input number:");scanf("%d",&P_NUM);printf("input name and time\n");while(i < P_NUM){q = (struct D_PCB *)malloc(sizeof(D_PCB));scanf("%s",&(q->name));scanf("%d",&(q->needtime));q->cputime = 0;q->priority = P_TIME - q->needtime;q->process = ready;q->next = NULL;if(i == 0){p = q;t = q;}else{t->next = q; // 创建就绪进程队列t = q;}i++;}// end whilereturn p;}// 显示模拟结果，包含进程名、CPU时间、运行所需时间以及优先级void display(D_PCB *p){printf("name\tcputime\tneedtime\tprioruty\tstate\n");while(p){printf("%s\t%d\t%d\t\t%d\t\t",p->name,p->cputime,p->needtime,p->priority);switch(p->process){case ready:printf("ready\n");break;case working:printf("working\n");break;case block:printf("block\n");break;case finish:printf("finish\n");break;}p = p->next;}}// 结束进程，即将队列中各进程所需时间设置为0int process_finish(D_PCB *q){int bl = 1;while(bl && q){bl = bl && q->needtime == 0;q = q->next;}return bl;}// 选择某一进程，给它分配CPUvoid cpuexe(D_PCB *q){D_PCB *t = q;int tp = 0;while(q){if(q->process != finish){q->process = ready;if(q->needtime == 0){q->process = finish;}}if(tp < q->priority && q->process != finish){ tp = q->priority;t = q;}q = q->next;}if(t->needtime != 0){t->priority -= 3;t->needtime--;t->process = working;t->cputime++;}}// 计算进程优先级void priority_cal(){D_PCB * p;system("cls");p = get_process();int cpu = 0;system("cls");while(!process_finish(p)){cpu++;printf("cputime:%d\n",cpu);cpuexe(p);display(p);Sleep(2);}printf("All processes have finished!\n");}// 显示调度算法菜单，可供用户选择优先权调度算法和时间片轮转算法void display_menu(){system("cls");printf("*******************************\n");printf(" CHOOSE THE ALGORITHM: \n");printf(" 1 PRIORITY\n"); // 优先权调度算法printf(" 2 ROUNDROBIN\n"); // 时间片轮转算法printf(" 3 EXIT\n");printf("*******************************\n");}// 时间片轮转算法// 时间片轮转调度算法创建就绪进程队列D_PCB * get_process_round(){D_PCB *q;D_PCB *t;D_PCB *p;int i = 0;int P_NUM;printf("input number:");scanf("%d",&P_NUM);printf("input name and time\n");while(i < P_NUM){q = (struct D_PCB *)malloc(sizeof(D_PCB));scanf("%s",&(q->name));scanf("%d",&(q->needtime));q->cputime = 0;q->round = 0;q->count = 0;q->process = ready;q->next = NULL;if(i == 0){p = q;t = q;}else{t->next = q;t = q;}i++;}// end whilereturn p;}// 采用时间片轮转算法执行某一进程void cpu_round(D_PCB *q){q->cputime += 2;q->needtime -= 2;if(q->needtime < 0){q->needtime = 0;}q->count++;q->round++;q->process = working;}// 获取下一个进程D_PCB * get_next(D_PCB *k, D_PCB *head){D_PCB *t;t = k;do{t = t->next;}while(t && t->process == finish);if(t == NULL){t = head;while(t->next != k && t->process == finish){t = t->next;}}return t;}// 设置队列中进程执行状态void set_state(D_PCB *p){while(p){if(p->needtime == 0){p->process = finish; // 如果所需执行时间为0，则设置运行状态为结束}if(p->process == working){p->process = ready; // 如果所需执行状态则设置为就绪}p = p->next;}}// 时间片轮转调度算法输出调度信息void display_round(D_PCB *p){printf("NAME\tCPUTIME\tNEEDTIME\tCOUNT\tROUND\tSTATE\n");while(p){printf("%s\t%d\t%d\t\t%d\t%d\t",p->name,p->cputime,p->needtime,p->count,p ->round);switch(p->process){case ready:printf("ready\n");break;case working:printf("working\n");break;case block:printf("block\n");break;case finish:printf("finish\n");break;}p = p->next;}}// 时间片轮转调度算法计算轮次及输出调度信息void round_cal(){D_PCB * p;D_PCB *r;system("cls");p = get_process_round();int cpu = 0;system("cls");r = p;while(!process_finish(p)){cpu+=2;cpu_round(r);r = get_next(r,p);printf("cpu:%d\n",cpu);display_round(p);set_state(p);Sleep(2);}}void return_menu();// 是否返回主菜单void is_return_menu(){printf("return to former menu?(Y or N to Main Menu)\n");char k;k = getch();switch(k){case 'Y':return_menu();break;case 'N':break;case 'y':return_menu();break;case 'n':break;default:is_return_menu();break;}}// 返回主菜单void return_menu(){display_menu();int k;scanf("%d",&k);switch(k){case 1:priority_cal();is_return_menu();break;case 2:round_cal();is_return_menu();break;case 3:break;}}int main(int argc, char* argv[]){int n = 1;int num;// 初始化所有未被创建进程的状态，一开始所有进程都不在内存中for(int i = 0; i < N;i++)neicun[i].state = 0;while(n){printf("\n**************************************************");printf("\n* 进程演示系统*");printf("\n**************************************************");printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.唤醒某个进程 6.进程之间通信");printf("\n 7.进程调度8.退出系统");printf("\n**************************************************");printf("\n请选择（1~8）\n");scanf("%d",&num);switch(num){case 1:create();break;case 2:run();break;case 3:huanchu();break;case 4:kill();break;case 5:huanxing();break;case 6:tongxin();break;case 7:return_menu();break;case 8:exit(0);break;default: n = 0;}flag = 0;// 恢复标记}return 0;}实验结果截图：主界面：创建一个新的进程：查看进程：再创建两个新的进程并查看：换出进程号为1的进程并查看：杀死一个进程号为3的进程并查看：唤醒刚刚被挂起的进程号为1的进程并查看：进程号为1的进程和进程号为2的进程之间通信并查看：进程调度：优先权算法：输入有几个进程：输入5个进程名及其优先权运行时间：时间片轮转算法：输入有几个进程：输入5个进程名及其优先权运行时间：。
进程的创建实验报告
一、实验目的1. 理解进程的概念及其在操作系统中扮演的角色。
2. 掌握在特定编程环境中创建进程的方法。
3. 分析进程创建的过程和机制。
4. 熟悉进程间通信和同步的基本原理。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发工具：Visual Studio 2019三、实验原理进程是操作系统中执行的基本单元，是系统进行资源分配和调度的基本单位。
在操作系统中，进程的创建是系统调用的过程，通过系统调用，父进程可以创建子进程。
在创建子进程时，子进程将继承父进程的某些属性，如环境变量、打开的文件等。
四、实验步骤1. 创建父进程- 编写一个简单的C/C++程序，使用`fork()`系统调用创建子进程。
2. 创建子进程- 在父进程中，通过`fork()`函数创建子进程。
`fork()`函数返回值有以下几种情况：- 返回0：表示子进程；- 返回子进程的进程ID：表示父进程；- 返回-1：表示创建子进程失败。
3. 父进程和子进程的区分- 通过检查`fork()`的返回值，父进程和子进程可以相互区分。
父进程可以通过返回值获取子进程的进程ID。
4. 父进程和子进程的通信- 使用管道（pipe）实现父进程和子进程之间的通信。
创建管道后，父进程通过管道向子进程发送数据，子进程从管道中读取数据。
5. 父进程和子进程的同步- 使用互斥锁（mutex）和条件变量（condition variable）实现父进程和子进程的同步。
父进程在完成工作后，可以通知子进程继续执行。
五、实验代码```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#include <fcntl.h>int main() {int pipe_fd[2];pid_t pid;// 创建管道if (pipe(pipe_fd) == -1) {perror("pipe");exit(EXIT_FAILURE);}// 创建子进程pid = fork();if (pid == -1) {perror("fork");exit(EXIT_FAILURE);}if (pid == 0) {// 子进程close(pipe_fd[1]); // 关闭管道的写端dup2(pipe_fd[0], STDIN_FILENO); // 将管道的读端复制到标准输入execlp("date", "date", NULL); // 执行date命令} else {// 父进程close(pipe_fd[0]); // 关闭管道的读端write(pipe_fd[1], "Hello, world!\n", 15); // 向管道写入数据close(pipe_fd[1]); // 关闭管道的写端wait(NULL); // 等待子进程结束printf("Child process exited with PID %d\n", pid);}return 0;}```六、实验结果与分析1. 父进程和子进程分别运行`date`命令和输出“Hello, world!”字符串。
进程创建实验报告
进程创建实验报告第一篇：进程创建实验报告实验二进程的创建一、实验目的熟悉进程的创建过程，了解系统调用函数fork()和 execl()。
二、实验内容1、阅读实例代码fork1，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握系统调用fork()的用法，返回值的意义。
2、阅读实例代码fork2，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握在程序中运行一个操作系统命令和运行一个程序的方法。
3、修改fork2，使之能把运行的命令和程序作为参数传给fork2。
三、设计思想1、程序框架pid =-1 pid = 0 pid > 02、用到的文件系统调用函数 fork()和 execl()四、调试过程1、测试数据设计（1）fork1 命名程序1：编写程序1：编译程序1：运行程序1：(2)fork2 编写程序2：运行程序2：(3)修改fork2 编写修改程序2：修改后的运行结果：2、测试结果分析（1）对于程序1：因为系统调用fork()函数是一次调用两次返回值，而且先生成子进程还是父进程是不确定的，所以第一次执行生成子进程的时候返回的pid = 0，判断pid!=-1，所以输出了I’m the child.I’m the parent.第二次，执行父进程的时候，返回的是子进程的进程号pid > 0，即pid的值仍然不为-1，所以又输出了一次I’m the child.I’m the parent。
（2）对于程序2：第一次调用fork()函数时，由于执行的是子进程还是父进程是随机的，所以第一次对父进程返回的是子进程的进程号（大于0），即pid > 0，所以输出I’m the parent.Program end.当第二次执行子进程时返回值是0，即pid = 0，所以输出I’m the child.并调用了execl()函数，查看了指定路径中的文件。
操作系统实验报告(进程的创建)范文
实验题目进程的创建小组合作否姓名班级学号一、实验目的1、了解进程的创建。
2、了解进程间的调用以及实现。
3、分析进程竞争资源的现象，学习解决互斥的方法。
4、加深对进程概念的理解，认识并发执行的本质。
二．实验环境Windows 系统的计算机一台，安装了Linux虚拟机三、实验内容与步骤1、fork（）系统调用的使用例子程序代码：#include<stdio.h>#include<sys/types.h>#include<unistd.h>int glob=3;int main(void){pid_t pid;int loc=3;printf("before fork();glod=%d,loc=%d.\n",glob,loc);if((pid=fork())<0){printf("fork() error. \n");exit(0);}else if(pid==0){glob++;loc--;printf("child process changes glob and loc: \n");}elsewait(0);printf("parent process doesn't change the glob and loc:\n");printf("glob=%d,loc=%d\n",glob,loc);exit(0);}运行结果：2、理解vofork（）调用：程序代码：#include<stdio.h>#include<sys/types.h>#include<unistd.h>int glob=3;int main(void){pid_t pid;int loc=3;if((pid=vfork())<0){printf("vfork() error\n");exit(0);}else if(pid==0){glob++;loc--;printf("child process changes the glob and loc\n");exit(0);}elseprintf ("parent process doesn't change the glob and loc\n");printf("glob=%d,val=%d\n",glob,loc);}运行结果：3、给进程指定一个新的运行程序的函数exec().程序代码：printe1.c代码：#include<stdio.h>int main(int argc,char * argv[]){int n;char * * ptr;extern char * * environ;for(n=0;n<argc;n++)printf("argv[%d]:%s\n",n,argv[n]);for(ptr=environ; * ptr!=0;ptr++)printf("%s\n",* ptr);exit(0);}file4.c代码如下：#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>char * env_list[]={"USER=root","PATH=/root/",NULL};int main(){pid_t pid;if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execle("/root/print1","print1","arg1","arg2",(char *)0,env_list)<0) printf("execle error!\n");exit(0);}if((waitpid(pid,NULL,0))<0)printf("WAIT ERROR!\n");exit(0);if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execlp("print1","print1","arg1",(char *)0)<0)printf("execle error!\n");exit(0);}exit(0);}运行结果：4、进程终止函数exit()。
模拟进程创建实验报告(3篇)
第1篇一、实验目的1. 理解进程的概念和进程创建的基本原理。
2. 掌握使用C语言模拟进程创建的方法。
3. 熟悉进程的属性和进程之间的通信机制。
4. 分析实验结果，加深对进程管理的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio 2019三、实验原理进程是计算机中程序执行的基本单位，是操作系统进行资源分配和调度的一个独立单位。
进程创建是操作系统的一个重要功能，它负责为进程分配必要的资源，并建立进程控制块（PCB）。
在模拟进程创建实验中，我们将使用C语言编写程序，模拟进程的创建、运行和销毁过程。
通过模拟进程的创建，我们可以了解进程的基本属性，如进程ID、进程状态、父进程ID等。
四、实验步骤1. 定义进程结构体，包含进程的基本属性，如进程ID、进程状态、父进程ID等。
```ctypedef struct {int pid; // 进程IDint state; // 进程状态int parent_pid; // 父进程ID// 其他属性} Process;```2. 编写进程创建函数，用于创建新进程。
```cProcess create_process(int parent_pid) {Process new_process;new_process.pid = ...; // 分配进程IDnew_process.state = ...; // 设置进程状态 new_process.parent_pid = parent_pid;// 设置其他属性return new_process;}```3. 编写进程运行函数，用于模拟进程的运行过程。
```cvoid run_process(Process p) {// 模拟进程运行过程// ...}```4. 编写进程销毁函数，用于销毁进程。
```cvoid destroy_process(Process p) {// 销毁进程资源// ...}```5. 编写主函数，模拟进程创建、运行和销毁过程。
进程系统演示实验报告
一、实验目的1. 理解进程的概念及其在操作系统中的作用。
2. 掌握进程的创建、调度、同步和通信的基本原理。
3. 通过实验演示进程系统的运行过程，加深对进程管理的理解。
二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 开发工具：gcc三、实验内容1. 进程的创建2. 进程的调度3. 进程的同步4. 进程的通信四、实验步骤1. 进程的创建（1）编写一个主函数，作为父进程；（2）在父进程中，使用fork()系统调用创建子进程；（3）输出父进程和子进程的进程号、父进程号和子进程号。
2. 进程的调度（1）使用进程调度算法（如FIFO、时间片轮转）对进程进行调度；（2）设置进程的优先级，实现进程的动态调度；（3）输出进程的调度结果，包括进程名、进程号、优先级和调度时间。
3. 进程的同步（1）使用互斥锁（mutex）实现进程的互斥访问；（2）使用条件变量（condition variable）实现进程的同步；（3）输出进程同步的结果，包括互斥锁的使用情况和条件变量的等待/唤醒情况。
4. 进程的通信（1）使用管道（pipe）实现进程间的数据传递；（2）使用共享内存（shared memory）实现进程间的数据共享；（3）输出进程通信的结果，包括管道和共享内存的使用情况。
五、实验结果与分析1. 进程的创建实验结果：成功创建父进程和子进程，输出进程号、父进程号和子进程号。
分析：通过fork()系统调用，父进程创建子进程，子进程继承父进程的代码段和数据段。
2. 进程的调度实验结果：根据进程调度算法，输出进程的调度结果，包括进程名、进程号、优先级和调度时间。
分析：通过设置进程优先级和调度算法，实现进程的动态调度，提高系统资源利用率。
3. 进程的同步实验结果：成功实现互斥锁和条件变量的使用，输出进程同步的结果。
分析：通过互斥锁和条件变量，实现进程的同步访问和条件等待，保证数据的一致性和进程的同步。
4. 进程的通信实验结果：成功使用管道和共享内存实现进程间的数据传递和共享。
操作系统实验报告实验3_1
操作系统实验报告实验3_1一、实验目的本次实验的主要目的是深入理解操作系统中进程管理的相关概念和原理，通过实际操作和观察，掌握进程的创建、调度、同步与互斥等关键机制，提高对操作系统内核工作原理的认知和实践能力。
二、实验环境本次实验在装有 Windows 10 操作系统的计算机上进行，使用了Visual Studio 2019 作为开发工具，编程语言为 C+＋。
三、实验内容与步骤（一）进程创建1、编写一个简单的 C+＋程序，使用系统调用创建一个新的进程。
2、在父进程和子进程中分别输出不同的信息，以区分它们的执行逻辑。
｀｀｀cppinclude ＜iostream>include ＜windowsh>int main(）｛DWORD pid;HANDLE hProcess ＝ CreateProcess(NULL, ＂childexe"， NULL, NULL, FALSE, 0, NULL, NULL, NULL, ＆pid)；if （hProcess!＝ NULL) ｛std:：cout ＜＜＂Parent process: Created child process with PID ＂＜＜ pid ＜＜ std:：endl;WaitForSingleObject(hProcess, INFINITE)；CloseHandle(hProcess)；｝ else ｛std:：cerr ＜＜＂Failed to create child process" ＜＜ std:：endl;return 1;｝return 0;｝｀｀｀（二）进程调度1、设计一个多进程并发执行的程序，通过设置不同的优先级，观察操作系统对进程的调度情况。
2、记录每个进程的执行时间和等待时间，分析调度算法的效果。
｀｀｀cppinclude ＜iostream>include ＜windowsh>DWORD WINAPI ProcessFunction(LPVOID lpParam) ｛int priority ＝（int)lpParam;DWORD start ＝ GetTickCount(）；std:：cout ＜＜＂Process with priority ＂＜＜ priority ＜＜＂started" ＜＜ std:：endl;for （int i ＝ 0; i ＜ 100000000; i+＋）｛／／执行一些计算操作｝DWORD end ＝ GetTickCount(）；DWORD executionTime ＝ end start;std:：cout ＜＜＂Process with priority ＂＜＜ priority ＜＜＂ ended Execution time: ＂＜＜ executionTime ＜＜＂ ms" ＜＜ std:：endl;return 0;｝int main(）｛HANDLE hThread1, hThread2;int priority1 ＝ 1, priority2 ＝ 2;hThread1 ＝ CreateThread(NULL, 0, ProcessFunction, ＆priority1, 0, NULL)；hThread2 ＝ CreateThread(NULL, 0, ProcessFunction, ＆priority2, 0, NULL)；if （hThread1!＝ NULL ＆＆ hThread2!＝ NULL) ｛SetThreadPriority(hThread1, THREAD_PRIORITY_LOWEST)；SetThreadPriority(hThread2, THREAD_PRIORITY_NORMAL)；WaitForSingleObject(hThread1, INFINITE)；WaitForSingleObject(hThread2, INFINITE)；CloseHandle(hThread1)；CloseHandle(hThread2)；｝ else ｛std:：cerr ＜＜＂Failed to create threads" ＜＜ std:：endl;return 1;｝return 0;｝｀｀｀（三）进程同步与互斥1、实现一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。
操作系统实验报告二进程的创建
1、编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程分别显示字符'b'和字符'c'。试观察记录屏幕上的显示结果，并分析原因。
2、修改上述程序，每一个进程循环显示一句话。子进程显示'daughter …'及'son ……'，父进程显示'parent ……'，观察结果，分析原因。
学院：计算机科学与信息学院专业实验时间
2011.11.10
指导教师
成绩
实验项目名称
实验二进程的创建
实验目的
1、掌握进程的概念，明确进程的含义
2、认识并了解并发执行的实质
实验要求
课堂集中授课参考程序和学生编程实现、并回答相关疑问；
实验原理
实验手段：编程验证原理
实验仪器
PC机，虚拟机软件
实验数据
实验总结
创建进程是要考虑到内存回收及防止进程进入死循环。
指导教师意见
签名：年月日
注：各学院可根据教学需要对以上栏木进行增减。表格内容可根据内容扩充。
实验步骤
1、编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程分别显示字符'b'和字符'c'。试观察记录屏幕上的显示结果，并分析原因。
2、修改上述程序，每一个进程循环显示一句话。子进程显示'daughter …'及'son ……'，父进程显示'parent ……'，观察结果，分析原因。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
进程的创建
一.实验目的
1、掌握进程的概念，明确进程的含义。
2、认识并了解并发执行的实质。
二.实验内容
编写一段程序，使用系统调用fork( )创建一个子进程。
当此程序运行时，在系统中有一个父进程和一个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程显示字符'b'。
试观察记录屏幕上的显示结果，并分析原因。
三.实验过程及结果
1.打开centos，在文档中输入创建进程的代码。
图1 代码界面
2.在桌面上右击，在下拉列表中选择Open in Terminal，打开控制台，然后输入编译和运行的命令，当输入编译命令的时候，桌面会生成一个a.out的文件。
图2 编译界面
3.当输入运行命令，就会显示出结果了
图3 最终结果
四.实验小结
1.代码在执行的时候，就创建了一个进程，此时的进程是父进程。
2.当代码执行到fork()函数时，就创建了一个子进程，因为子进程是继承父进程的，所以他们的内容基本上是一样的。
3.可以看到，在最后输入运行命令时，同时跳出两个结果，证明了进程是并发执行的。
4.对于进程的定义，从不同的角度有不同的定义，较典型的有：进程是程序的一次执行，进程是具有独立功能的程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位等。
5.并发执行就是指两个或者多个事件在同一时间间隔内发生。