1实验一进程管理参考代码
#include
#include
#include
#define NULL 0
int number=0;//进程数
//进程的内容结构体
struct node
{
int a;
char ch;
};
struct process //进程PCB结构体
{
int pid; //进程标识
int priority; //优先级
float luntime; //lun轮转时间
float zhantime; //zhan占用CPU时间
char status; //状态，a表示执行，b表示动态就绪
node *content; //进程内容
struct process *next;
};
struct process *ready,*present,*p,*q;//present正在执行进程指针，ready就绪进程队列指针
//换出进程函数
void outchange(int a)
{
p=ready;
while(p->pid!=a&&p!=NULL)
{
q=p;
p=p->next;
}
if(p==NULL)
{
printf("该进程不在内存里!\n");
return;
}
if(p==ready)
{
ready=ready->next;
}
else
{
q->next=p->next; //把目标进程换出来，即把目标进程从就绪队列中移出来
}
}
//杀死正在运行进程函数
void kill()
{
present->next=NULL;
printf("运行的进程已经杀死!\n");
return;
}
//创建新进程后与正在运行进程比较优先级并根据优先级判断谁该占用处理机
int compare()
{
int i,j;
p=ready;
while(p!=NULL)
{
q=p;
p=p->next; //q指向进程的末尾，即新建的进程
}
i=q->priority; //i代表新进进程的优先级
j=present->next->priority; //j代表正在执行进程的优先级
if(i>j) //如果新建的进程的优先级高于正在执行程序的优先级 {
p=ready;
if(p==q) //就绪队列的进程中只有一个进程。也就是那个新建的进程{
ready=present->next;
p->content=(node*)malloc(sizeof(node));
p->content->a=9;
p->content->ch='c';
present->next=p; //把处理机交给优先级高的新进程
return 1;
}
else{
while(p->next!=q)
{
p=p->next;
} //执行完后p 指针在q指针前面
p->next=present->next; //将正在执行的进程放置p的后面
q->content=(node*)malloc(sizeof(node));
q->content->a=9;
q->content->ch='c';
present->next=q; //将q放置在正在执行列表中，把处理机交给优先级高的进程present->next->next=NULL;
return 1;
}
}
else
return -1;
}
void main()
{
int execute();//定义函数
void kill();//定义杀死函数
void check();//定义查看函数
void communication(int);//定义通信函数
present=(process*)malloc(sizeof(process));
present->next=NULL;
ready=(process*)malloc(sizeof(process));
ready->next=NULL;
ready->pid=1;
ready->priority=6;
ready->luntime=3.5;
ready->zhantime=3;
ready->content=(node*)malloc(sizeof(node));
ready->content=NULL;
ready->status='b';
number++;
p=(process*)malloc(sizeof(process));
p->next=ready->next;
ready->next=p;
p->pid=2;
p->priority=5;
p->luntime=3.5;
p->zhantime=3;
p->content=(node*)malloc(sizeof(node));
p->content=NULL;
p->status='b';
number++;
q=(process*)malloc(sizeof(process));
q->next=p->next;
p->next=q;
q->pid=3;
q->priority=4;
q->luntime=3.5;
q->zhantime=3;
q->zhantime=3;
q->content=(node*)malloc(sizeof(node));
q->content=NULL;
q->status='b';
number++;
int i,n=1;
int k,j,s;
j=execute();
int createnewprocess();
while(n==1)
{
printf("********************************************\n");
printf("* 进程演示系统*\n");
printf("********************************************\n");
printf(" 1.创建新的进程 2.查看运行进程\n");
printf(" 3.换出某个进程 4.杀死运行进程\n");
printf(" 5.进程之间通信 6.退出系统\n");
printf("********************************************\n");
printf("请选择（1～6）\n");
scanf("%d",&i);
switch(i)
{
case 1:k=createnewprocess();
if(k==1)
printf("进程创建成功!\n");
if(ready->next==NULL)
{
printf("由于只有一个进程所以为它分配处理机.\n");
present->next=ready;
ready->content=(node*)malloc(sizeof(node));
ready->content->a=3;
ready->content->ch='c';
ready=NULL;
continue;
}
k=compare();
if(k==1)
{
printf("由于新进程的优先级高于正在执行的进程所以正在执行的\n");
printf("进程让出处理机交给新进程,而它变为活动就绪!\n");
}
if(k!=1)
printf("新进程的优先级低于正在运行的进程所以它只有等待!\n");
break;
case 2:
if(present->next==NULL)
{
printf("没有进程处于执行状态!\n");
continue;
}
check();break;
case 3:
if(ready==NULL)
{
printf("内存中已经没有处于活动就绪的进程了请创建!!\n");
continue;
}
printf("已有处于活动就绪进程的名字为:\n");
p=ready;
printf("(");
while(p!=NULL)
{
printf("%d ",p->pid);
p=p->next;
}
printf(")\n");
printf("请输入要换出的处于活动就绪进程的名字:\n");
scanf("%d",&s);
outchange(s);
if(ready==NULL)
printf("内存中已经没有活动就绪进程!\n");
else
{
printf("已有处于活动就绪进程的名字为:\n");
p=ready;
printf("(");
while(p!=NULL)
{
printf("%d ",p->pid);
p=p->next;
}
printf(")\n");
}
break;
case 4:
if(present->next==NULL)
{
printf("没有处于执行状态的进程!\n");
continue;
}
kill();
if(ready==NULL)
{
printf("已经没有处于活动就绪的进程请创建!\n");
continue;
}
j=execute();
if(j==1)
{ printf("已为一个动态就绪进程中优先级最高的进程分配处理器!\n");
}
break;
case 5:
if(ready==NULL)
{
printf("内存中已经没有处于活动就绪的进程了请创建!\n");
continue;
}
if(present->next==NULL)
{
printf("没有处于执行状态的进程!\n");
continue;
}
printf("请输入要与正在运行的进程进行进程通讯的进程名字\n");
scanf("%d",&s);
communication(s);
break;
case 6:exit(0);
default:n=0;
}
}
}
//创建新的进程函数
int createnewprocess()
{
int i;
if(number>20)
{
printf("内存已满请先换出进程!\n");
i=-1;
return i;
}
else
{
if(ready==NULL) //如果没有就绪队列中没有进程的话
{
p=(process*)malloc(sizeof(process));
printf("请输入新进程的名字（数字）:\n");
scanf("%d",&p->pid);
printf("请输入新进程的优先级:（数字）\n");
scanf("%d",&p->priority);
p->luntime=3.5;
p->zhantime=3;
p->content=(node*)malloc(sizeof(node));
p->content=NULL;
p->status='b'; //新建进程的状态设置为"就绪"
p->next=NULL;
ready=p;
number++;
i=1;
}
else //如果就绪队列不是空队列
{
p=ready;
while(p->next!=NULL)
{
p=p->next; //p一直指向就绪队列的队尾}
q=(process*)malloc(sizeof(process));
q->next=p->next;
p->next=q; //在就绪队列的队尾加入新建的进程
printf("请输入新进程的名字（数字）:\n");
scanf("%d",&q->pid);
printf("请输入新进程的优先级:（数字）\n");
scanf("%d",&q->priority);
q->luntime=3.5;
q->zhantime=3;
q->content=(node*)malloc(sizeof(node));
q->content=NULL;
q->status='b'; //新建进程的状态设置为就绪
number++;
i=1;
}
}
return i;
}
//从活动就绪进程队列中找到一个优先级最高的进程并为它分配处理机int execute()
{
int i,j;
p=ready;
if(present->next!=NULL)
{
return -1;
}
i=ready->priority;
p=ready->next;
while(p!=NULL)
{ j=p->priority;
if(i>=j)
{
p=p->next;
}
if(i { i=p->priority; p=p->next; } } if(ready->priority==i) { ready->content=(node*)malloc(sizeof(node)); ready->content->a=9; ready->content->ch='c'; present->next=ready; ready=ready->next; present->next->next=NULL; } else { p=ready; while(i!=p->priority) { q=p; p=p->next; } // q是p前面的指针 p->content=(node*)malloc(sizeof(node)); p->status='a'; p->content->a=9; p->content->ch='c'; present->next=p; //将p放入执行列表 q->next=p->next; //将优先级高的节点舍去 } return 1; } // void check() { p=present->next; printf("该执行进程的名字为:%d\n",p->pid); printf("该执行进程的的优先级:%d\n",p->priority); printf("该执行进程的轮转时间为:%f\n",p->luntime); printf("该执行进程占用cpu的时间为:%f\n",p->zhantime); printf("该执行的进程内容为:\n"); printf("%d ",p->content->a); printf("%c",p->content->ch); printf("\n"); } void communication(int a) { q=ready; while(q->pid!=a&&q!=NULL) { q=q->next; }//q为id为a的进程 if(q==NULL) { printf("所输入的进程不在内存中!\n"); return ; } p=present->next;//p为正在执行的进程 q->content=(node*)malloc(sizeof(node)); q->content->a=p->content->a; q->content->ch=p->content->ch;//将正在执行的进程内容复制给id为a的进程printf("通信成功!\n"); return; } 实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 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; //进程ID public 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为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0; 实验一进程管理 【实验目的】 1）加深对进程概念及进程管理各部分内容的理解。 2）熟悉进程管理中主要数据结构的设计和进程调度算法、进程控制机构、同步机构、通讯机构的实施。 【实验要求】 调试并运行一个允许n 个进程并发运行的进程管理模拟系统。了解该系统的进程控制、同步及通讯机构，每个进程如何用一个PCB 表示、其内容的设置；各进程间的同步关系；系统在运行过程中显示各进程的状态和有关参数变化情况的意义。 【实验环境】 具备Windows或MS-DOS操作系统、带有Turbo C 集成环境的PC机。 【实验重点及难点】 重点：理解进程的概念，进程管理中主要数据结构的设计和进程调度算法、进程控制机构、同步机构、通讯机构的实施。 难点：实验程序的问题描述、实现算法、数据结构。 【实验内容】 一．阅读实验程序 程序代码见【实验例程】。 二．编译实验例程 用Turbo C 编译实验例程。 三．运行程序并对照实验源程序阅读理解实验输出结果的意义。 【实验例程】 #include init() { int j; for (j=0;j<3;j++) { pcb[j].id=j; pcb[j].status='r'; pcb[j].nextwr=NIL; printf("\n process%d priority?",j+1); scanf("%d",&i); pcb[j].priority=i; } sem[0].value=1; sem[0].firstwr=NIL; sem[1].value=1; sem[1].firstwr=NIL; for(i=1;i<3;i++) for(j=0;j<4;j++) savearea[i] [j]='0'; } float random() { int m; if (seed<0) m=-seed; else m=seed; seed=(25173*seed+13849)%65536; return(m/32767.0); } timeint(ad) char ad; { float x; x=random(); if((x<0.33)&&(exe==0))return(FALSE); if((x<0.66)&&(exe==1))return(FALSE); if((x<1.0)&&(exe==2))return(FALSE); savearea[exe][0]=i; savearea[exe][1]=ad; pcb[exe].status='t'; printf("times silce interrupt'\n process%d enter into ready.\n",exe+1); exe=NIL; return(TRUE); } scheduler() 实验报告 课程名称：操作系统 实验项目：windows进程管理 姓名： 专业：计算机科学与技术 班级： 学号： 计算机科学与技术学院 计算机系 2019 年 4 月 23 日 实验项目名称： windows进程管理 一、实验目的 1. 学习windows系统提供的线程创建、线程撤销、线程同步等系统调用； 2. 利用C++实现线程创建、线程撤销、线程同步程序； 3. 完成思考、设计与练习。 二、实验用设备仪器及材料 1. Windows 7或10， VS2010及以上版本。 三、实验内容 1 线程创建与撤销 写一个windows控制台程序（需要MFC），创建子线程，显示Hello, This is a Thread. 然后撤销该线程。 相关系统调用： 线程创建： CreateThread() 线程撤销： ExitThread() 线程终止： ExitThread(0) 线程挂起： Sleep() 关闭句柄： CloseHandle() 参考代码： ; } 运行结果如图所示。 完成以下设计题目： 1. 向线程对应的函数传递参数，如字符串“hello world！”，在线程中显示。 2. 如何创建3个线程A, B, C，并建立先后序执行关系A→B→C。 实验内容2 线程同步 完成父线程和子线程的同步。父线程创建子线程后进入阻塞状态，子线程运行完毕后再唤醒。 相关系统调用： 等待对象 WaitForSingleObject(), WaitForMultipleObjects(); 信号量对象 CreateSemaphore(), OpenSemaphore(), ReleaseSemaphore(); HANDLE WINAPI CreateSemaphore( _In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes _In_ LONG lInitialCount, _In_ LONG lMaximumCount, _In_opt_ LPCTSTR lpName ); 第一个参数：安全属性，如果为NULL则是默认安全属性 第二个参数：信号量的初始值，要>=0且<=第三个参数 第三个参数：信号量的最大值 第四个参数：信号量的名称 返回值：指向信号量的句柄，如果创建的信号量和已有的信号量重名，那么返回已经存在的信号量句柄参考代码： n"); rc=ReleaseSemaphore(hHandle1,1,NULL); err=GetLastError(); printf("Release Semaphore err=%d\n",err); if(rc==0) printf("Semaphore Release Fail.\n"); else printf("Semaphore Release Success. rc=%d\n",rc); } 编译运行，结果如图所示。 实验2过程管理实验报告学生号姓名班级电气工程系过程、过程控制块等基本原理过程的含义：过程是程序运行过程中对数据集的处理，以及由独立单元对系统资源的分配和调度。在不同的数据集上运行程序，甚至在同一数据集上运行多个程序，是一个不同的过程。（2）程序状态：一般来说，一个程序必须有三种基本状态：就绪、执行和阻塞。然而，在许多系统中，过程的状态变化可以更好地描述，并且增加了两种状态：新状态和终端状态。1）就绪状态，当一个进程被分配了除处理器（CPU）以外的所有必要资源时，只要获得了处理器，进程就可以立即执行。此时，进程状态称为就绪状态。在系统中，多个进程可以同时处于就绪状态。通常，这些就绪进程被安排在一个或多个队列中，这些队列称为就绪队列。2）一旦处于就绪状态的进程得到处理器，它就可以运行了。进程的状态称为执行状态。在单处理器系统中，只有一个进程在执行。在多处理器系统中，可能有多个进程在执行中。3）阻塞状态由于某些事件（如请求输入和输出、额外空间等），执行进程被挂起。这称为阻塞状态，也称为等待状态。通常，处于阻塞状态的进程被调度为-？这个队列称为阻塞队列。4）新状态当一个新进程刚刚建立并且还没有放入就绪队列中时，它被称为新状态。5）终止状态是 什么时候-？进程已正常或异常终止，操作系统已将其从系统队列中删除，但尚未取消。这就是所谓的终结状态。（3）过程控制块是过程实体的重要组成部分，是操作系统中最重要的记录数据。控制块PCB记录操作系统描述过程和控制过程操作所需的所有信息。通过PCB，一个不能独立运行的程序可以成为一个可以独立运行的基本单元，并且可以同时执行一个进程。换句话说，在进程的整个生命周期中，操作系统通过进程PCB管理和控制并发进程。过程控制块是系统用于过程控制的数据结构。系统根据进程的PCB来检测进程是否存在。因此，进程控制块是进程存在的唯一标志。当系统创建一个进程时，它需要为它创建一个PCB；当进程结束时，系统回收其PCB，进程结束。过程控制块的内容过程控制块主要包括以下四个方面的信息。过程标识信息过程标识用于对过程进行标识，通常有外部标识和内部标识。外部标识符由流程的创建者命名。通常是一串字母和数字。当用户访问进程时使用。外部标识符很容易记住。内部标识符是为了方便系统而设置的。操作系统为每个进程分配一个唯一的整数作为内部标识符。通常是进程的序列号。描述性信息（process scheduling message）描述性信息是与流程调度相关的一些有关流程状态的信息，包括以下几个方面。流程状态：表 实验一进程管理 1. 实验目的 ⑴加深对进程概念的理解，明确进程和程序的区别； ⑵进一步认识并发执行的实质； ⑶分析进程争用资源的现象，学习解决进程互斥的方法； ⑷了解Linux系统中进程通信的基本原理。 2. 实验准备 ⑴阅读Linux的sched.h源码文件，加深对进程管理的理解。 ⑵阅读Linux的fork.h源码文件，分析进程的创建过程。 3. 实验内容 ⑴进程的创建 编写一段程序，使用系统调用fork ( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 ⑵进程的控制 修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 如果在程序中使用系统调用lockf ( )来给每一个进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。 ⑶软中断通信 编制一段程序实现进程的软中断通信。要求：使用系统调用fork ( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上发来的中断信号（既按Del键）；当捕捉到中断信号后，父进程系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent process is killed! 在上面的程序中增加语句signal (SIGINT, SIG_IGN) 和signal (SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。 4. 实验指导 进程的控制 1 ．实验目的 通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。 【答：进程概念和程序概念最大的不同之处在于： (1)进程是动态的，而程序是静态的。 (2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。没有建立进程的程序不能作为1个独立单位得到操作系统的认可。 (3)1个程序可以对应多个进程，但1个进程只能对应1个程序。进程和程序的关系犹如演出和剧本的关系。 (4)进程和程序的组成不同。从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。而程序是一组有序的指令集合。】2 ．实验内容 (1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。 (2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。 (3) 编写一段程序，使用系统调用fork()来创建一个子进程。子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“new program.”。而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。 3 ．实验步骤 （1）gedit创建进程1.c （2）使用gcc 1.c -o 1编译并./1运行程序1.c #include 实验一linux进程的创建与控制 【实验目的】 1、加深对进程概念的理解，明确进程和程序的区别； 2、进一步认识并发执行的实质； 3、分析进程争用资源的现象，学习解决进程互斥的方法； 【实验环境】 编程环境：TC或者VC 操作系统软件：linux 【准备知识】 一.基本概念 1、进程的概念；进程与程序的区别。 2、并发执行的概念。 3、进程互斥的概念。 二.系统调用 系统调用是一种进入系统空间的办法。通常，在OS的核心中都设置了一组用于实现各 种系统功能的子程序，并将它们提供给程序员调用。程序员在需要OS提供某种服务的时候，便可以调用一条系统调用命令，去实现希望的功能，这就是系统调用。因此，系统调用就像 一个黑箱子一样，对用户屏蔽了操作系统的具体动作而只是控制程序的执行速度等。各个不同的操作系统有各自的系统调用，女口windows API，便是windows的系统调用，Linux的系 统调用与之不同的是Linux由于内核代码完全公开，所以可以细致的分析出其系统调用的机制。 三.相关函数。 1 fork()函数 fork()函数创建一个新进程。 其调用格式为：int fork()； 其中返回int取值意义如下： 正确返回：等于0 :创建子进程，从子进程返回的ID值； 大于0 :从父进程返回的子进程的进程ID值。 错误返回：等于一1创建失败。 2 wait()函数 wait()函数常用来控制父进程与子进程的同步。在父进程中调用wait()函数，则父进程被阻塞，进入等待队列，等待子进程结束。当子进程结束时，会产生一个终止状态字，系统会向父进程发出SIGCHLD言号。当接到信号后，父进程提取子进程的终 止状态字，从wait()函数返回继续执行原程序。 其调用格式为：#i nclude 实验三进程管理 一、实验目的 1．熟悉和理解进程和进程树的概念，掌握有关进程的管理机制 2．通过进程的创建、撤销和运行加深对进程并发执行的理解 3．明确进程与程序、并行与串行执行的区别 4．掌握用C 程序实现进程控制的方法 二、实验学时 2学时 三、实验背景知识 所涉及的系统调用 1、exec( )系列（exec替换进程映像） 系统调用exec( )系列，也可用于新程序的运行。fork( )只是将父进程的用户级上下文拷贝到新进程中，而exec( )系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上，以更改新进程的用户级上下文。exec( )系列中的系统调用都完成相同的功能，它们把一个新程序装入内存，来改变调用进程的执行代码，从而形成新进程。如果exec( )调用成功，调用进程将被覆盖，然后从新程序的入口开始执行，这样就产生了一个新进程，新进程的进程标识符id 与调用进程相同。 exec( )没有建立一个与调用进程并发的子进程，而是用新进程取代了原来进程。所以exec( )调用成功后，没有任何数据返回，这与fork( )不同。exec( )系列系统调用在UNIX系统库unistd.h中，共有execl、execlp、execle、execv、execvp五个，其基本功能相同，只是以不同的方式来给出参数。 #include 实验一进程管理 1．实验目的： （1）加深对进程概念的理解，明确进程和程序的区别； （2）进一步认识并发执行的实质； （3）分析进程争用资源的现象，学习解决进程互斥的方法； （4）了解Linux系统中进程通信的基本原理。 2．实验预备内容 （1）阅读Linux的sched.h源码文件，加深对进程管理概念的理解； （2）阅读Linux的fork()源码文件，分析进程的创建过程。 3．实验内容 （1）进程的创建： 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 源代码如下： #include else{ pid2 = fork(); if(pid2<0){ fprintf(stderr,"childprocess1 failed"); exit(-1); } else if(pid2 == 0){ printf("c\n"); } else{ printf("a\n"); sleep(2); exit(0); } } return 0; } 结果如下： 分析原因： pid=fork(); 操作系统创建一个新的进程（子进程），并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序；上下文和数据，绝大部分就是原进程（父进程）的拷贝，但它们是两个相互独立的进程！因此，这三个进程哪个先执行，哪个后执行，完全取决于操作系统的调度，没有固定的顺序。 （2）进程的控制 修改已经编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 将父进程的输出改为father process completed 2/11 实验一Windows进程管理和进程编程 实验内容1.1 Windows 任务管理器的进程管理 1、背景知识简介 Windows的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息，也显示了最常用的度量进程性能的单位 使用任务管理器 ?可以打开监视计算机性能的关键指示器，快速查看正在运行的程序的状态，或者终止已停止响应的程序 ?也可以使用多个参数评估正在运行的进程的活动，以及查看CPU 和内存使用情况的图形和数据 任务管理器中 ?“应用程序”选项卡：显示正在运行程序的状态，用户能够结束、切换或者启动程序?“进程”选项卡：显示正在运行的进程信息。例如，可以显示关于CPU 和内存使用情况、页面错误、句柄计数以及许多其他参数的信息 ?“性能”选项卡：显示计算机动态性能，包括CPU 和内存使用情况的图表，正在运行的句柄、线程和进程的总数，物理、核心和认可的内存总数(KB) 等 2、实验目的和要求 通过在Windows 任务管理器中对程序进程进行响应的管理操作 熟悉操作系统进程管理的概念 学习观察操作系统运行的动态性能 3、实验环境 需要准备一台运行Windows XP Professional操作系统的计算机 4、实验内容与步骤 1.启动任务管理器。按Alt+Ctrl+Delete，或右键单击任务栏，选择任务管理器。 在Windows XP的任务管理器中，“进程”选项卡增加了一个“用户名”栏目，其中区分了SYSTEM、NETWORK SERVICE、LOCAL SERVICE和用户的不同进程类别。 2.使用任务管理器终止进程。选择进程名，点击右下角的“结束进程”。终止进程时要小 心，有可能导致不希望发生的结果，包括数据丢失和系统不稳定等。点击进程，右键选择“终止进程树”，会结束该进程以及它直接或间接创建的所有子进程。 进程管理模拟系统实验指导书2 一、实验目的 学习进程管理的设计与实现，学习和运用操作系统原理，设计一个操作系统子系统的模拟系统。通过该系统的设计调试可增加对操作系统实现的感知性。同时可发挥团队协作精神和个人创造能力。使同学们对操作系统学习有一个实现的尝试和创新的思维。 二、实验规则 1．每组设计一个模拟系统（共100分） 2．每人设计系统中的一部分（满分60分） 3．集体调试创意（满分40分） 三、实验要求 1．进程管理功能以进程调度为主要功能。以进程控制为辅助功能。 2．体现操作系统原理中进程调度算法和进程控制算法。按照操作系统原理设计。 3．结构化设计。设计时构建出模块结构图并存于文件中。模块化实现，对每一功能，每一操作使用模块、函数、子程序设计方法实现。 4．进程以PCB为代表。队列、指针用图示。每一步功能在桌面上能显示出来。 5．系统应具有排错功能，对可能出现的错误应具有排查功能和纠错能力。 6．界面自行设计，语言自行选择。（可用VC/C++/C/C#语言，也可用你会的其他语言，甚至还可用PPT） 7．每人的设计功能都能表现或说明出来。 8．进程以队列法组织，对不同进程调度算法： FIFO队列或PRI队列或rotate（轮转队列）用同一个进程序列组织，对阻塞队列可设置一个，也可设多个。 9．因为是模拟系统，所以要显示每个功能和操作结果。显示应力求清晰、易读和一目了然（一屏），最好能用汉字，否则可用英语或汉语拼音。 10．操作方便，使用便捷。可视化程度高。 11．设计出系统后，还需要写出（介绍系统采用的语言、支撑平台、小组成员及分工。如何安装、如何启动、如何操作） 12．每组需写一份课程设计报告，内容包括：课程设计内容，课程设计设计思路，课程设计结构图，及分工内容、介绍。 13. 实验结果演示验收后，将可在任何环境下运行的可执行文件和系统说明书一起存盘并交盘。（可合组一张盘），上标：班级、组号、姓名。 14. 实验结束后从中选出优秀作品，介绍给大家。 四、系统功能 1．创建进程：主要创建PCB，并在创建后显示PCB及所在RL队列。内容包括①标识数（按产生顺序产生），②进程名（字母序列），③优先数（随机产生），④进程状态，⑤队列指针（可用数字或图表示），⑥其它（可自定义：如运行时间、家族等）。创建进程的个数可人工设定，或可自动设定，也可两者兼有。 2．撤销进程：撤销进程主要显示PCB的消失和队列的变化。 3．进程队列的组织：进程队列可对创建的所有进程变化队形：可组织成FIFO队列，也可组织成PRI队列；或rotate队列，对队列有插入、移出的功能，也有在队列中某位置插入删除功能。 4．显示功能：模拟系统在整个演示过程中都需要可视化，因此显示功能非常重要，要求对队列、PCB每次操作前后予以显示，以表示操作功能的实施效果。 Linux 进程管理实验 一、实验内容： 1. 利用bochs观测linux0.11下的PCB进程控制结构。 2. 利用bochs观测linux0.11下的fork.c源代码文件，简单分析其中的重要函数。 3. 在fork.c适当位置添加代码，以验证fork函数的工作原理。 二、Linux进程管理机制分析 Linux有两类进程：一类是普通用户进程，一类是系统进程，它既可以在用户空间运行，又可以通过系统调用进入内核空间，并在内核空间运行；另一类叫做内核进程，这种进程只能在内核空间运行。在以i386为平台的Linux系统中，进程由进程控制块，系统堆栈，用户堆栈，程序代码及数据段组成。Linux系统中的每一个用户进程有两个堆栈：一个叫做用户堆栈，它是进程运行在用户空间时使用的堆栈；另一个叫做系统堆栈，它是用户进程运行在系统空间时使用的堆栈。 1.Linux进程的状态： Linux进程用进程控制块的state域记录了进程的当前状态，一个Linux 进程在它的生存期中，可以有下面6种状态。 1.就绪状态(TASK_RUNNING)：在此状态下，进程已挂入就绪队列，进入准备运行状态。 2.运行状态(TASK_RUNNING)：当进程正在运行时，它的state域中的值不改变。但是Linux会用一个专门指针(current)指向当前运行的 任务。 3.可中断等待状态(TASK_INTERRUPTIBLE)：进程由于未获得它所申请的资源而处在等待状态。不管是资源有效或者中断唤醒信号都能使等待的进程脱离等待而进入就绪状态。即”浅睡眠状态”。 4.不可中断等待状态(TASK_UNINTERRUPTIBLE)：这个等待状态与上面等待状态的区别在于只有当它申请的资源有效时才能被唤醒，而其它信号不能。即“深睡眠状态”。 5.停止状态（TASK_STOPPED)：当进程收到一个SIGSTOP信号后就由运行状态进入停止状态，当收到一个SINCONT信号时，又会恢复运行状态。挂起状态。 6.终止状态（TASK_ZOMBIE)：进程因某种原因终止运行，但进程控制块尚未注销。即“僵死状态”。 状态图如下所示： 2.Linux进程控制块： 进程管理实验报告 1 ．实验目的 通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。 【答：进程概念和程序概念最大的不同之处在于： (1)进程是动态的，而程序是静态的。 (2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。没有建立进程的程序不能作为1个独立单位得到操作系统的认可。 (3)1个程序可以对应多个进程，但1个进程只能对应1个程序。进程和程序的关系犹如演出和剧本的关系。 (4)进程和程序的组成不同。从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。而程序是一组有序的指令集合。】2 ．实验内容 (1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。 (2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。 (3) 编写一段程序，使用系统调用fork()来创建一个子进程。子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“new program.”。而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。 （3）运行并查看结果 child’s pid=2894 child’s pid=2994 parent’s pid=2849 child’s pid=2897 child’s pid=2897 parent’s pid=2849 child’s pid=2894 child’s pid=2994 parent’s pid=2849 （4）gedit创建进程2.c 使用gcc 2.c -o 2编译并./2运行程序2.c#include 计算机与信息工程学院实验报告 一、实验内容 1.练习在shell环境下编译执行程序 (注意：①在vi编辑器中编写名为sample.c的c语言源程序 ②用linux自带的编译器gcc编译程序，例如：gcc –o test sample.c ③编译后生成名为test.out的可执行文件； ④最后执行分析结果；命令为：./test) 注意：linux自带的编译程序gcc的语法是：gcc –o 目标程序名源程序名，例如：gcc –o sample1 sample1.c，然后利用命令：./sample 来执行。如果仅用“gcc 源程序名”，将会把任何名字的源程序都编译成名为a.out的目标程序，这样新编译的程序会覆盖原来的程序，所以最好给每个源程序都起个新目标程序名。 2.进程的创建 仿照例子自己编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示“a”，子进程分别显示字符“b”和“c”。观察记录屏幕上的显示结果，并分析原因。 3.分析程序 实验内容要在给出的例子程序基础上，根据要求进行修改，对执行结果进行分析。二、 实验步骤 1. 利用fork()创建一个小程序 （1）编写程序 #include 实验三进程管理 背景知识 Windows所创建的每个进程都从调用CreateProcess() API函数开始，该函数的任务是在对象管理器子系统内初始化进程对象。每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。通常应用程序的框架负责调用ExitProcess() 函数。对于C++ 运行库来说，这一调用发生在应用程序的main() 函数返回之后。 1. 创建进程 CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。表3-4详细地列出了每个参数的类型和名称。 可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。 然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。经常使用的标志是CREA TE_SUSPNDED，告诉主线程立刻暂停。当准备好时，应该使用ResumeThread() API来启动进程。另一个常用的标志是CREATE_NEW_CONSOLE，告诉新进程启动自己的控制台窗口，而不是利用父窗口。这一参数还允许设置进程的优先级，用以向系统指明，相对于系统中所有其他的活动进程来说，给此进程多少CPU时间。 接着是CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。第一个参数是lpEnvironment参数，指明为新进程提供的环境；第二个参数是lpCurrentDirectory，可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录；第三个参数是STARTUPINFO数据结构所必需的，用于在必要时指明新应用程序的主窗口的外观。 CreateProcess() 的最后一个参数是用于新进程对象及其主线程的句柄和ID的返回值缓冲区。以PROCESS_INFORMA TION结构中返回的句柄调用CloseHandle() API函数是重要 实验一、进程调度实验报告 广东技术师范学院实验报告 学院：计算机科学学 院 专业： 计算机科学与 技术（师范） 班级：成绩： 姓名：学号：组别：组员： 实验地点：实验日期：指导教师签名： 实验名称：实验一、进程调度实验 一、实验目的 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解 二、实验类别 综合性实验。综合高级语言编程、进程调度模型、进程调度算法及数据结构等多方面的知识 三、实验内容和步骤 1．编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。 “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。 静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。 动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。例如：在进程获得一次CPU后就将其优先数减少1。或者，进程等待的时间超过某一时限时增加其优先数的值，等等 该题根据老师给的代码用Visual C++运行，结果以及分析如下： 预习情况操作情况考勤情况数据处理情况 结果分析：根据上述输入的三个进程的信息可以得到：优先级最高的是进程cc 最先调度进程cc的状态为运行态，需要执行的时间为10当前就绪队列状态为：进程aa先级比较高，处于就绪队列前面，而进程bb先级是三者中最低的，所以处于就绪队列的最后。而此时这两个进程的状态都为就绪态。 结果分析：当进程cc了一个时间片之后而它已占用CPU时间已达到所需要的运行时间，则将它的优先级减1之后，再将三个进程按优先级的大小排列，从中选择优先级大的进程进入运行状态，则该次进入运行态的是进程aa 按照这种方式一直运行下去： 直到: 软件学院 上机实验报告 课程名称：操作系统 实验项目：实验一：Linux环境下进程管理 实验室：耘慧402 姓名：学号： 专业班级：实验时间： 一、实验目的及要求 1.加深对进程概念的理解，明确进程和程序的区别； 2. 进一步认识并发执行的实质； 3. 分析进程争用资源的现象，学习解决进程互斥的方法； 4. 了解Linux系统中进程通信的基本原理； 二、实验性质 1. 进程的创建:编写一段程序，使用系统调用fork（）创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 2. 进程的控制:修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。如果在程序中使用系统调用lockf （）来给每一个进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。 3. 用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容；利用wait( )来控制进程执行顺序。 三、实验学时 实验性质：验证性 实验学时： 4学时 实验要求：必做 四、实验环境 1.实验环境： Linux系统开发环境 2.知识准备： （1） Linux系统开发环境搭建； （2） Linux环境下GCC编译器的使用； （3）语言中函数定义与调用、指针和类型的定义与使用、结构的定义、动态内存的申请等预备知识。 五、实验内容及步骤 ①实验内容： （1）进程的创建 编写一段程序，使用系统调用fork（）创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 （2）进程的控制 修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 如果在程序中使用系统调用lockf（）来给每一个进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。 （3）用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容；利用wait( )来控制进程执行顺序。 ②实验步骤： 1.进程的创建 1.1 进程 UNIX中，进程既是一个独立拥有资源的基本单位，又是一个独立调度的基本单位。一个进程实体由若干个区（段）组成，包括程序区、数据区、栈区、共享存储区等。每个区又分为若干页，每个进程配置有唯一的进程控制块PCB，用于控制和管理进程。 PCB的数据结构如下： （1）进程表项（Process Table Entry）。包括一些最常用的核心数据： 进程标识符PID、用户标识符UID、进程状态、事件描述符、进程和U区在内存操作系统实验报告--实验一--进程管理
实验一 进程管理
windows进程管理实验报告
进程管理实验报告
实验一 进程管理
进程管理实验报告
实验一进程管理实验
实验三-进程管理
操作系统-进程管理实验报告
实验1 Windows进程管理编程
进程管理模拟实验指导书09
Linux 进程管理实验
进程管理实验报告
操作系统-实验三-进程管理-实验报告
实验三 进程管理
实验一、进程调度实验报告
实验一——Linux环境下的进程管理