搜档网
当前位置:搜档网 › 操作系统实验4-进程管理与控制

操作系统实验4-进程管理与控制

操作系统实验4-进程管理与控制
操作系统实验4-进程管理与控制

第3章进程管理与控制

一、Linux进程管理

1、fork()

创建一个新的子进程。其子进程会复制父进程的数据与堆栈空间,并继承父进程的用户代码、组代码、环境变量、已打开的文件代码、工作目录和资源限制。系统调用格式:

int fork()

如果Fork成功则在父进程会返回新建立的子进程代码(PID),而在新建立的子进程中则返回0。如果fork失败则直接返回-1。

2、wait()

等待子进程运行结束。如果子进程没有完成,父进程一直等待。wait( )将调用进程挂起,直至其子进程因暂停或终止而发来软中断信号为止。如果在wait( )前已有子进程暂停或终止,则调用进程做适当处理后便返回。

系统调用格式:

int wait(int *status)

其中,status是用户空间的地址。它的低8位反应子进程状态,为0表示子进程正常结束,非0则表示出现了各种各样的问题;高8位则带回了exit( )的返回值。exit( )返回值由系统给出。核心对wait( )作以下处理:

(1)首先查找调用进程是否有子进程,若无,则返回出错码;

(2)若找到一处于“僵死状态”的子进程,则将子进程的执行时间加到父进程的执行时间上,并释放子进程的进程表项;

(3)若未找到处于“僵死状态”的子进程,则调用进程便在可被中断的优先级上睡眠,等待其子进程发来软中断信号时被唤醒。

3、exit( )

终止进程的执行。

系统调用格式:

void exit(int status)

其中,status是返回给父进程的一个整数,以备查考。为了及时回收进程

所占用的资源并减少父进程的干预,UNIX/LINUX利用exit( )来实现进程的自我终止,通常父进程在创建子进程时,应在进程的末尾安排一条exit( ),使子进程自我终止。exit(0)表示进程正常终止,exit(1)表示进程运行有错,异常终止。

如果调用进程在执行exit( )时,其父进程正在等待它的终止,则父进程可立即得到其返回的整数。核心须为exit( )完成以下操作:

(1)关闭软中断

(2)回收资源

(3)写记帐信息

(4)置进程为“僵死状态”

4、exec()函数族

fork( )只是将父进程的用户级上下文拷贝到新进程中,而exec( )系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上,以更改新进程的用户级上下文。exec( )系列中的系统调用都完成相同的功能,它们把一个新程序装入内存,来改变调用进程的执行代码,从而形成新进程。如果exec( )调用成功,调用进程将被覆盖,然后从新程序的入口开始执行,这样就产生了一个新进程,新进程的进程标识符id 与调用进程相同。

exec( )没有建立一个与调用进程并发的子进程,而是用新进程取代了原来进程。所以exec( )调用成功后,没有任何数据返回。exec( )系列系统调用在UNIX 系统库unistd.h中,共有execl、execlp、execle、execv、execvp五个,其基本功能相同,只是以不同的方式来给出参数。

(1)execl( )

int execl(char *path, char * arg0, char * arg1,... char *argn,0);

种是直接给出参数的指针

(2)execv( )

int execv(char *path, char *argv);

给出指向参数表的指针

(3) execlp( )

int execlp(const char * file,const char * arg,...,(char *)0);

execlp()会从PATH 环境变量所指的目录中查找符合参数file的文件名,找到后便执行该文件,然后将第二个以后的参数当做该文件的argv[0]、argv[1]……,最后一个参数必须用空指针(NULL)作结束。

二、Linux信号机制

(一)信号的基本概念

每个信号都对应一个正整数常量(称为signal number,即信号编号。定义在系统头文件中),代表同一用户的诸进程之间传送事先约定的信息的类型,用于通知某进程发生了某异常事件。每个进程在运行时,都要通过信号机制来检查是否有信号到达。若有,便中断正在执行的程序,转向与该信号相对应的处理程序,以完成对该事件的处理;处理结束后再返回到原来的断点继续执行。实质上,信号机制是对中断机制的一种模拟,故在早期的UNIX版本中又把它称为软中断。

⑴信号与中断的相似点:

①采用了相同的异步通信方式;

②当检测出有信号或中断请求时,都暂停正在执行的程序而转去执行相应的处理程序;

③都在处理完毕后返回到原来的断点;

④对信号或中断都可进行屏蔽。

⑵信号与中断的区别:

①中断有优先级,而信号没有优先级,所有的信号都是平等的;

②信号处理程序是在用户态下运行的,而中断处理程序是在核心态下运行;

③中断响应是及时的,而信号响应通常都有较大的时间延迟。

⑶信号机制具有以下三方面的功能:

①发送信号。发送信号的程序用系统调用kill( )实现;

②预置对信号的处理方式。接收信号的程序用signal( )来实现对处理方式的预置;

③收受信号的进程按事先的规定完成对相应事件的处理。

2、信号的发送

信号的发送,是指由发送进程把信号送到指定进程的信号域的某一位上。如果目标进程正在一个可被中断的优先级上睡眠,核心便将它唤醒,发送进程就此结束。一个进程可能在其信号域中有多个位被置位,代表有多种类型的信号到达,但对于一类信号,进程却只能记住其中的某一个。进程用kill( )向一个进程或一组进程发送一个信号。

3、对信号的处理

当一个进程要进入或退出一个低优先级睡眠状态时,或一个进程即将从核心态返回用户态时,核心都要检查该进程是否已收到软中断。当进程处于核心态时,即使收到软中断也不予理睬;只有当它返回到用户态后,才处理软中断信号。对

软中断信号的处理分三种情况进行:

①如果进程收到的软中断是一个已决定要忽略的信号(function=1),进程不做任

何处理便立即返回;

②进程收到软中断后便退出(function=0);

③执行用户设置的软中断处理程序。

(二)所涉及的中断调用

1、kill( )

系统调用格式

int kill(pid,sig)

参数定义

int pid,sig;

其中,pid是一个或一组进程的标识符,参数sig是要发送的软中断信号。

(1)pid>0时,核心将信号发送给进程pid。

(2)pid=0时,核心将信号发送给与发送进程同组的所有进程。

(3)pid=-1时,核心将信号发送给所有用户标识符真正等于发送进程的有

效用户标识号的进程。

2、signal( )

预置对信号的处理方式,允许调用进程控制软中断信号。

系统调用格式:

signal(int sig, void (*function) ( ))

头文件为:

#include

参数定义

sig:用于指定信号的类型,sig为0则表示没有收到任何信号,余者如下表:

信号

信号名信号意义缺省处理

01 SIGHUP 进程的控制终端和控制进程已结束终止进程

02 SIGINT 用户键入了Ctrl-C键终止进程

03 SIGQUIT 从键盘来的终止(Quit)信号终止进程、Core转储

04 SIGILL 进程执行了非法指令和企图执行数据段终止进程、Core转储

05 SIGTRAP 跟踪陷阱(trace trap),执行Trap执行跟踪代码

终止进程、Core转储

的执行

06 SIGIOT 进程发生错误并调用abort 终止进程、Core转储

07 SIGEMT 进程访问非法地址、地址对齐出错等终止进程、Core转储

08 SIGFPE 浮点运算错误、溢出、除数为0等终止进程、Core转储

09 SIGKILL 强制进程终止(此信号不能屏蔽)终止进程(不能忽视)

10 SIGUSR1 保留给用户自行定义终止进程

11 SIGSEGV 进程访问内存越界,和无权限访问终止进程、Core转储

12 SIGUSR2 保留给用户自行定义信号终止进程

13 SIGPIPE 进程向无读者的管道进行写操作终止进程

14 SIGALRM 时钟定时信号。当某进程希望在某时间后接收

终止进程

信号时发此信号

15 SIGTERM 进程结束信号,由kill命令产生终止进程

16 SIGSTKFLT 进程发现堆栈溢出错误终止进程、Core转储

17 SIGCHLD 子进程终止信号忽视

18 SIGCONT 让暂停的进程继续执行进程暂停时继续运行

19 SIGSTOP 暂停(Stop)进程的执行暂停进程

20 SIGTSTP 用户键入暂停(Ctrl-Z)暂停进程

21 SIGTTIN 后台作业要从用户终端(stdin)读数据暂停进程

22 SIGTTOU 后台作业要写用户终端暂停进程

23 SIGURG 套接字(socket)有“紧急”数据到达忽视

24 SIGXCPU 进程使用CPU超时终止进程、Core转储

25 SIGXFSZ 进程处理文件超长终止进程、Core转储

26 SIGV ALRM 虚拟时钟信号(计算进程占用CPU时间)终止进程

27 SIGPROF 类似SIGALRM/SIGV ALRM(计算进程占用

终止进程

CPU世界以及系统调用的时间)

28 SIGWINCH 窗口大小已改变忽视

29 SIGIO I/O准备就绪,可以进行输入输出操作忽视

30 SIGPWR 系统电源失效终止进程

31 SIGUNUSED 终止进程

function:在该进程中的一个函数地址,在核心返回用户态时,它以软中断信号

的序号作为参数调用该函数,对除了信号SIGKILL,SIGTRAP和SIGPWR以外

的信号,核心自动地重新设置软中断信号处理程序的值为SIG_DFL,一个进程

不能捕获SIGKILL信号。

function 的解释如下:

(1)function=1时,进程对sig类信号不予理睬,亦即屏蔽了该类信号;

(2)function=0时,缺省值,进程在收到sig信号后应终止自己;

(3)function为非0,非1类整数时,function的值即作为信号处理程序的指针。三、Pthread线程管理与控制API

(1) 线程创建和启动函数

函数说明:

#include

int pthread_create(pthread_t *thread, pthread_attr *attr,

void *(*start_routine)(void *), void *arg);

功能:创建线程和启动线程,与进程管理函数fork()的功能相似

参数说明:

thread:创建线程成功时,在该指针致祥的变量中写入新线程的线程标识符;

attr: 线程属性参数指针,可以为NULL;

start_routine:一个函数的地址指针,线程创建成功后,新线程执行该函数指针所指向的函数的代码;

arg:传递给线程启动函数的参数。

返回值:0表示成功;非0表示失败。

(2) 线程退出函数

函数说明:void pthread_exit(void *retval);

参数说明:retval将传给执行pthread_join的线程的thread_return参数。

(3) 线程归并函数

等待线程结束,读取线程的计算结果。

函数说明:

int pthread_join(pthread_t th, void **thread_return);

参数说明:

th:线程标识符,由执行pthread_create函数返回到参数thread中的值;

thread_return:其它线程执行pthread_exit时在retval参数中指明的值被置于该变量指针指向的变量中。

返回值:0表示成功;非0表示失败。

实验3-3 Linux多进程并发程序设计(必做)

【实验目的】

1、掌握进程的概念,明确进程和程序的区别。

2、认识和了解并发执行的实质。

3、分析进程争用资源的现象,学习解决进程互斥的方法。

【实验内容】

1、Linux进程创建与进程并发性(必做题)

编写一段程序,使用系统调用fork( )创建两个子进程,在系统中有一个父进程和两个子进程活动。让每个进程在屏幕上显示一个字符;父进程显示字符“a”,子进程分别显示字符“b” 和“c”。试观察记录屏幕上的显示结果,并分析原因。

3-3-1.c

#include

void main()

{

int p1, p2;

while((p1=fork())== -1);

if(p1==0)

putchar('b');

else

{ while((p2=fork())==-1);

if(p2==0)

putchar('c');

else

putchar( 'a');

}

}

分析:由fork()函数创建了两个子进程,然后父进程和两个子进程并发执行,所以最后三个进程都进行了打印,结果为:“bca”。

2、Linux进程独立地址空间特性(资源拥有者特性)

修改已编写的程序,三个进程将不同字符串(进程名)赋给同名字符数组str,并显示出来,观察程序执行时屏幕上出现的现象,并分析其原因。(必做题)

3-3-2.c

#include

#include

void main()

{

int p1, p2, i;

char str[20];

while((p1=fork())==-1);

if(p1==0)

{

strcpy(str,"son");

for(i=0;i<500;i++)

printf("%s %d\n",str,i);

}

else

{

while((p2=fork())==-1);

if(p2==0)

{

strcpy(str,"daughter");

for(i=0;i<500;i++)

printf("%s %d\n",str,i);

}

else

{

strcpy(str,"father");

for(i=0;i<500;i++)

printf("%s %d\n",str,i);

}

}

}

3. 用exec系统调用改变Linux进程映像

设计一个程序,此程序从终端读入命令并执行之,执行完成后,父进程继续等待从终端读入命令。

3-3-3.c:

#include

#include

#include

#include

char command[256];

void main()

{

int rtn; /*子进程的返回数值*/

while(1) {

/* 从终端读取要执行的命令*/

printf( ">" );

fgets( command, 256, stdin );

command[strlen(command)-1] = 0;

if ( fork() == 0 ) {/* 子进程执行此命令*/

execlp( command, NULL );

/* 如果exec函数返回,表明没有正常执行命令,打印错误信息*/

perror( command );

exit( errno );

}

else {/* 父进程,等待子进程结束,并打印子进程的返回值*/

wait ( &rtn );

printf( " child process return %d\n", rtn );

}

}

}

4、编写程序创建进程树如图1和图2所示,在每个进程中显示当前进程识别码和父进程识别码。(必做题)

图一的实现源码: #include main() { int p1,p2,p3; while((p1=fork())==-1); if(p1==0) { while((p2=fork())==-1); if(p2==0) { while((p3=fork())==-1); if(p3==0) { printf("Process ID=%d,%c\n",getpid(), 'd'); } else printf("Process ID=%d,child Process ID=%d,%c\n",getpid(),p3, 'c'); } else printf("Process ID=%d,child Process ID=%d,%c\n",getpid(),p2,'b'); } else printf("Process ID=%d,child Process ID=%d,%c\n",getpid(),p1,'a'); }

a

父进程

子进程

图1 进程树 b c

d

a

d

b

c

e

图2 进程树

【思考题】

1、系统是怎样创建进程的?

答:一旦操作系统发现了要求创建新进程的事件后,便调用进程创建原语Creat()按下述步骤创建一个新进程。

(1)申请空白PCB。为新进程申请获得唯一的数字标识符,并从PCB集合中索取一个空白PCB

(2)为新进程分配资源。为新进程的程序和数据以及用户栈分配必要的内存空间。

(3)初始化进程控制块。包括:初始化标识信息,处理机状态信息,处理机状态控制信息。

(4)将新进程插入就绪队列,如果进程就绪队列能够接纳新进程,便将新进程插入到就绪队列中。

2、当首次调用新创建进程时,其入口在哪里?

答:fork系统调用创建的子进程继承了原进程的context,也就是说fork 调用成功后,子进程与父进程并发执行相同的代码。但由于子进程也继承了父进程的程序指针,所以子进程是从fork()后的语句开始执行(也就是新进程调用的入口)。另外fork在子进程和父进程中的返回值是不同的。在父进程中返回子进程的PID,而在子进程中返回0。所以可以在程序中检查PID的值,使父进程和子进程执行不同的分支。

3、当前运行的程序(主进程)的父进程是什么?

答:init

【实验报告】

1、列出调试通过程序的清单,分析运行结果。

2、给出必要的程序设计思路和方法(或列出流程图)。

3、回答思考题。

4、总结上机调试过程中所遇到的问题和解决方法及感想。

实验3-4 Linux信号机制(必做)

UNIX/LINUX系统的进程间通信机构(IPC)允许在任意进程间大批量地交换数据。本实验的目的是了解和熟悉LINUX支持的信号量机制、管道机制、消息通信机制及共享存储区机制。

【实验目的】

1、了解什么是信号。

2、熟悉LINUX系统中进程之间软中断通信的基本原理。

【实验内容】

1、信号机制任务一

编写一段程序,使用系统调用fork( )创建两个子进程,再用系统调用signal( )让父进程捕捉键盘上来的中断信号(即按ctrl+c键),当捕捉到中断信号后,父进程用系统调用kill( )向两个子进程发出信号,子进程捕捉到信号后,分别输出下列信息后终止:

Child process 1 is killed by parent!

Child process 2 is killed by parent!

父进程等待两个子进程终止后,输出以下信息后终止:

Parent process is killed!

3-4-1.c:

#include

#include

#include

#include

#include

int wait_mark;

void waiting(),stop();

void main()

{

int p1, p2;

signal(SIGINT,stop);

while((p1=fork())==-1);

if(p1>0) /*在父进程中*/

{①

while((p2=fork())==-1);

if(p2>0) /*在父进程中*/

{ ②

wait_mark=1;

waiting(0);

kill(p1,10);

kill(p2,12);

wait(NULL);

wait( NULL);

printf("parent process is killed!\n");

exit(0);

}

else /*在子进程2中*/

{

wait_mark=1;

signal(12,stop);

waiting();

lockf(1,1,0);

printf("child process 2 is killed by parent!\n");

lockf(1,0,0);

exit(0);

}

}

else /*在子进程1中*/

{

wait_mark=1;

signal(10,stop);

waiting();

lockf(1,1,0);

printf("child process 1 is killed by parent!\n");

lockf(1,0,0);

exit(0);

}

}

void waiting()

{

while(wait_mark!=0);

}

void stop()

{

wait_mark=0;

}

实验要求:

⑴、运行程序并分析结果。

⑵、如果把signal(SIGINT,stop)放在①号和②号位置,结果会怎样并分析原因。

答:如果把signal(SIGINT,stop)放在(1)号和(2)号位置后,结果先输出child process 2 is killed by parent!然后输出parent process is killed! 而不会输出child process 1 is killed by parent!因为在fork子进程1后,子进程1中没有设置对SIGINT信号的处理,当按下CTRL+C后,进程1默认为终止,所以没有输出.

⑶、该程序段前面部分用了两个wait(NULL),为什么?

答:设置了两个wait(),是为了等待两个子进程结束标志.

⑷、该程序段中每个进程退出时都用了语句exit(0),为什么?

答:每个进程退出时都用了语句exit(0),一方面要结束进程,另外向父进程返回结束标志0

2、信号机制任务二

运行程序并分析结果,给出程序中5个问题的答案,并给出解释说明。

3-4-2.c:

#include

#include

#include

#include

#include

int flag=1;

void func () { flag = flag + 5; }

main ( )

{

int status;

pid_t pid;

void func ( );

flag = flag + 15; // 问题1:flag=?

signal (SIGUSR1,func);

if (pid=fork () ) { //父进程

flag =flag +5; //问题2:flag=?

kill (pid, SIGUSR1); /* 发送信号*/

wait (&status); /* 等待子进程停止*/ //问题5:status=?

}

else { //子进程

flag = flag + 50; //问题3:flag = ?

sleep (100); /* 等待接受信号*/

printf ("flag=%d\n",flag);//问题4:flag=?

exit (80);

}

}

【实验报告】

1、列出调试通过程序的清单,分析运行结果。

2、给出必要的程序设计思路和方法(或列出流程图)。

3、总结上机调试过程中所遇到的问题和解决方法及感想。

实验3-5 Linux多进程程序设计(必做)

【实验目的】

1. 加深对线程概念的理解;

2. 掌握在使用POSIX线程机制进行多线程应用程序的编程方法。

【实验内容】

1.编写程序,创建2个线程,循环输出不同信息,编译执行该程序,分析程序

输出结果,并做出解释。

3-5-1.c:

#include

#include

void *myThread1(void)

{

int i;

for (i=0; i<100; i++)

{

printf("This is the 1st pthread,created by zieckey.\n");

sleep(1);

}

}

void *myThread2(void)

{

int i;

for (i=0; i<100; i++)

{

printf("This is the 2st pthread,created by zieckey.\n");

sleep(1);

}

}

int main()

{

int i=0, ret=0;

pthread_t id1,id2;

ret = pthread_create(&id2, NULL, (void*)myThread1, NULL);

if (ret)

{

printf("Create pthread error!\n");

return 1;

}

ret = pthread_create(&id2, NULL, (void*)myThread2, NULL);

if (ret)

{

printf("Create pthread error!\n");

return 1;

}

pthread_join(id1, NULL);/*等待线程结束*/

pthread_join(id2, NULL); /*等待线程结束*/

return 0;

}

编译执行命令:

$ gcc 3-5-1.c -lpthread –o 3-5-1

$ ./3-5-1

2.多线程合作完成共同任务

两个线程对共享数组a[10000]进行求和汇总,,主线程main对数组进行初始化a[i]=i,并完成前5000项求和保存到变量sum1,新线程完成后5000项求和存入变量sum2,最后主线程main将sum1与sum2相加保存到sum,并输出显示。

3-5-2.c:

#include

#include

#include

static int a[10000];

static sum1,sum2,sum;

void *thread1(void *arg)

{

int i;

sum2=0;

for (i=5000;i<10000; i++) sum2=sum2+a[i];

pthread_exit((void*) sum2);

}

int main(int argc,char* argv[])

{

pthread_t tidp;

int error,i;

int thread_result;

for(i=0;i<10000; i++) a[i]=i;

error = pthread_create(&tidp,NULL, thread1,NULL);

if(error != 0)

{

printf("thread is not created...\n");

return -1;

}

sum1=0;

for (i=0;i<5000; i++) sum1=sum1+a[i];

pthread_join(tidp,& thread_result);

sum=sum1+sum2;

printf("the sum of array[10000] is %d\n",sum);

printf("the part sum of thread1 get is %d\n", thread_result);

return 0;

}

$ gcc 3-5-2.c -lpthread -o 3-5-2

$ ./3-5-2

3.多线程合作互斥问题

计算机操作系统进程调度实验研究报告

计算机操作系统进程调度实验研究报告

————————————————————————————————作者:————————————————————————————————日期:

操作系统实验题:设计一若干并发进程的进程调度程序 一、实验目的 无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 二、实验要求 用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解. 三、实验内容 进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。 每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。 就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。重复以上过程,直到所要进程都完成为止。 四、实验算法流程

操作系统实验-进程控制

实验一、进程控制实验 1.1 实验目的 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法,了解父子进程间的控制和协作关系。练习Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。 1.2 实验说明 1)与进程创建、执行有关的系统调用说明进程可以通过系统调用fork()创建子进程并和其子进程并发执行.子进程初始的执行映像是父进程的一个复本.子进程可以通过exec()系统调用族装入一个新的执行程序。父进程可以使用wait()或waitpid()系统调用等待子进程的结束并负责收集和清理子进程的退出状态。 fork()系统调用语法: #include pid_t fork(void); fork 成功创建子进程后将返回子进程的进程号,不成功会返回-1. exec 系统调用有一组6 个函数,其中示例实验中引用了execve 系统调用语法: #include int execve(const char *path, const char *argv[], const char * envp[]); path 要装入 的新的执行文件的绝对路径名字符串. argv[] 要传递给新执行程序的完整的命令参数列表(可以为空). envp[] 要传递给新执行程序的完整的环境变量参数列表(可以为空).

Exec 执行成功后将用一个新的程序代替原进程,但进程号不变,它绝不会再返回到调用进程了。如果exec 调用失败,它会返回-1。 wait() 系统调用语法: #include #include pid_t wait(int *status); pid_t waitpid(pid_t pid,int *status,int option); status 用 于保留子进程的退出状态 pid 可以为以下可能值: -1 等待所有PGID 等于PID 的绝对值的子进程 1 等待所有子进程 0 等待所有PGID 等于调用进程的子进程 >0 等待PID 等于pid 的子进程option 规 定了调用waitpid 进程的行为: WNOHANG 没有子进程时立即返回 WUNTRACED 没有报告状态的进程时返回 wait 和waitpid 执行成功将返回终止的子进程的进程号,不成功返回-1。 getpid()系统调用语法: #include #include pid_t getpid(void); pid_t getppid(void); getpid 返回当前进程的进程号,getppid 返回当前进程父进程的进程号 2)与进程控制有关的系统调用说明可以通过信号向一个进程发送消息以控制进程的 行为。信号是由中断或异常事件引发的,如:键盘中断、定时器中断、非法内存引

《Linux操作系统》实验五-作业任务和进程管理

《Linux操作系统》 实验报告 实验五:作业任务和进程管理

一、实验目的 (1) 掌握UNIX系统作业、任务和进程管理的任务,了解Linux系统进程管理的图形界面; (2) 了解UNIX的系统进程间通信机制,掌握信号操作和终止进程的命令。 (3) 了解任务和作业管理命令at和batch; (4) 掌握UNIX系统的进程定时启动管理命令crontab; (5) 了解进程的挂起,掌握fg,bg等命令。 二、实验环境 一台装有Windows操作系统PC机,上装有虚拟机系统VMWare,实验过程通过VMWare系统启Linux系统工作。 三、实验内容与实验过程及分析(写出详细的实验步骤,并分析实验结果) 1)进程管理与查询 (1)进程状态查询 1.ps –ef | more #显示所有进程及启动参数 2. ps –ajx | more #以作业方式显示进行信息

3. ps –el | more #以长格式显示所有进程信息 4.pstree –p 5.pstree -a

(2)终止进程的执行 1.终止某一已知PID进程:ps –9 PID(1)#PID由用户自己选择 2.在当前终端上执行命令:man ps 3、换一终端在其运行:ps –e | grep man #确定进程PID

4.终止进程执行:kill –9 PID #PID是上命令查询的结果 4.终止所的同名进程 终止上例中的man命令:killall man或 killall –9 man 分别至少在2个不同终端上登录,然后在其中的一个终端上分别执行以下命令,并观察和分析原因。 killall bash killall –9 bash 执行killall -9 bash命令时,终端窗口关闭 (3) 进程的挂起及前后台调度 在一个终端上起动命令man man,在不退出man命令的情况下按下组合键Ctrl+Z,观察反映。 答:先退出当前页面,返回进入终端时的页面 先后执行命令jobs和fg命令,并观察反映。

操作系统实验报告--实验一--进程管理

实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 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;

第二章 操作系统进程(练习题标准答案)

第二章操作系统进程(练习题答案)

————————————————————————————————作者:————————————————————————————————日期: 2

第二章进程管理 1.操作系统主要是对计算机系统全部 (1) 进行管理,以方便用户、提高计算机使 用效率的一种系统软件。它的主要功能有:处理机管理、存储管理、文件管理、 (2) 管 理和设备管理等。Windows和Unix是最常用的两类操作系统。前者是一个具有图形界面的 窗口式的 (3) 系统软件,后者是一个基本上采用 (4) 语言编制而成的 的系统软件。在 (5) 操作系统控制下,计算机能及时处理由过程控制反馈的信息 并作出响应。 供选答案: (1): A. 应用软件 B. 系统软硬件 C. 资源 D. 设备 (2): A. 数据 B. 作业 C. 中断 D. I/O (3): A. 分时 B. 多任务 C. 多用户 D. 实时 (4): A. PASCAL B. 宏 C. 汇编 D. C (5): A. 网络 B. 分时 C. 批处理 D. 实时 答案:CBBDD 2.操作系统是对计算机资源进行的 (1) 系统软件,是 (2) 的接口。 在处理机管理中,进程是一个重要的概念,它由程序块、 (3) 和数据块三部 分组成,它有3种基本状态,不可能发生的状态转换是 (4) 。 虚拟存储器的作用是允许程序直接访问比内存更大的地址空间,它通常使用 (5) 作为它的一个主要组成部分。 供选答案: (1): A. 输入和输出 B. 键盘操作 C. 管理和控制 D. 汇编和执行 (2): A. 软件和硬件 B. 主机和外设 C. 高级语言和机器语言 D. 用户和计算机 (3): A. 进程控制块 B. 作业控制块 C. 文件控制块 D. 设备控制块 (4): A. 运行态转换为就绪态 B. 就绪态转换为运行态 C. 运行态转换为等待态 D. 等待态转换为运行态 (5): A. 软盘 B. 硬盘 C. CDROM D. 寄存器 答案:CDADB 3.在计算机系统中,允许多个程序同时进入内存并运行,这种方法称为 D。 A. Spodling技术 B. 虚拟存储技术 C. 缓冲技术 D. 多道程序设计技术 4.分时系统追求的目标是 C。 A. 高吞吐率 B. 充分利用内存 C. 快速响应 D. 减少系统开销 5.引入多道程序的目的是 D。

实验三-进程管理

实验三进程管理 一、实验目的 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 int execl(const cha r *pathname, const char *arg, …); int execlp(const char *, const char *arg, …); int execle(const char *pathname, const char *arg, …, const char *envp[ ]); int execv(const char *pathname, char *const argv[ ]); int execvp(const char *, char *const argv[ ]); 参数: path参数表示你要启动程序的名称包括路径名。 arg参数表示启动程序所带的参数,一般第一个参数为要执行命令名,不是带路径且arg必须以NULL结束。 返回值:成功返回0,失败返回-1 注:上述exec系列函数底层都是通过execve系统调用实现. 1)带l 的exec函数:execl,execlp,execle,表示后边的参数以可变参数的形式给出且都以一个空指针结束。 #include

操作系统期末试题及答案

《操作系统》期末试卷 姓名 一、选择题(15*2分=30分) 1、在操作系统中,JCB是指(A ) A.作业控制块B.进程控制块C.文件控制块D.程序控制块 2、并发进程之间(D) A.彼此无关 B.必须同步 C.必须互斥 D.可能需要同步或互斥 3 A 4 ?A 5、(D A 6 A 7 A. 8 A. C. 9、设有。 A.2 10 A. 11 A 12、() A C 13 A 14、(B A.固定分区 B.分段 C.分页 D.可变分区 15、在进程管理中,当()时,进程从阻塞状态变为就绪状态。 A.进程被进程调度程序选中B.等待某一事件C.等待的事件发生D.时间片用完 二、填空题(20*1分=20分) 1、在单用户环境下,用户独占全机,此时程序的执行具有_封闭性______和_可再现性_。 2、对于信号量,在执行一次P操作时信号量-1_;当其值为__<0__时,进程应阻塞。在执行V操作时信号量的值应当_信号量+1_; 当其值为__<=0__时,应唤醒阻塞队列中的进程。 3、进程的三种基本状态分别是、进程的三种基本状态分别是__运行______,_就绪_和__阻塞(等待)__。 4、多道程序环境下的各道程序,宏观上它们是_并行__运行,微观上是_串行_运行。 5、在单CPU系统中有(n>1)个进程,在任一时刻处于就绪的进程最多是__n-1__个,最少是___0____个。

6、分区管理方案不能实现虚存的原因是_作业地址空间不能大于存储空间_。 7、段页式存储管理中,是将作业分_段__,__段_____内分___页____。分配以__页_____为单位。在不考虑使用联想存储器快表 的情况下,每条访问内存的指令需要____3___访问内存。其中第_2___次是查作业的页表。 三、简答题(4*5分=20分) (2) ????????????进程A???????????????????????????????进程B ???????????...??????????????????????????????????... ????????P(mutex);????????????????????????????P(mutex);

第二章-操作系统进程(练习题答案)

第二章进程管理 1.操作系统主要是对计算机系统全部 (1) 进行管理,以方便用户、提高计算机使 用效率的一种系统软件。它的主要功能有:处理机管理、存储管理、文件管理、 (2) 管 理和设备管理等。Windows和Unix是最常用的两类操作系统。前者是一个具有图形界面的 窗口式的 (3) 系统软件,后者是一个基本上采用 (4) 语言编制而成的 的系统软件。在 (5) 操作系统控制下,计算机能及时处理由过程控制反馈的信息 并作出响应。 供选答案: (1): A. 应用软件 B. 系统软硬件 C. 资源 D. 设备 (2): A. 数据 B. 作业 C. 中断 D. I/O (3): A. 分时 B. 多任务 C. 多用户 D. 实时 (4): A. PASCAL B. 宏 C. 汇编 D. C (5): A. 网络 B. 分时 C. 批处理 D. 实时 答案:CBBDD 2.操作系统是对计算机资源进行的 (1) 系统软件,是 (2) 的接口。 在处理机管理中,进程是一个重要的概念,它由程序块、 (3) 和数据块三部 分组成,它有3种基本状态,不可能发生的状态转换是 (4) 。 虚拟存储器的作用是允许程序直接访问比内存更大的地址空间,它通常使用 (5) 作为它的一个主要组成部分。 供选答案: (1): A. 输入和输出 B. 键盘操作 C. 管理和控制 D. 汇编和执行 (2): A. 软件和硬件 B. 主机和外设 C. 高级语言和机器语言 D. 用户和计算机 (3): A. 进程控制块 B. 作业控制块 C. 文件控制块 D. 设备控制块 (4): A. 运行态转换为就绪态 B. 就绪态转换为运行态 C. 运行态转换为等待态 D. 等待态转换为运行态 (5): A. 软盘 B. 硬盘 C. CDROM D. 寄存器 答案:CDADB 3.在计算机系统中,允许多个程序同时进入内存并运行,这种方法称为 D。 A. Spodling技术 B. 虚拟存储技术 C. 缓冲技术 D. 多道程序设计技术 4.分时系统追求的目标是 C。 A. 高吞吐率 B. 充分利用内存 C. 快速响应 D. 减少系统开销 5.引入多道程序的目的是 D。

实验五 Linux进程管理

实验五Linux进程管理一.实验目的: 进行系统进程管理。 二.实验内容: 1.进程状态查看; 2.控制系统中运行的进程; 3.安排一次性和周期性自动执行的后台进程; 三.实验练习: 任务一进程管理 实验内容: 查看系统中的进程;控制系统中的进程;安排计划任务。实验步骤: 1.使用ps命令查看和控制进程 ●显示本用户的进程: ●显示所有用户的进程:。 ●在后台运行cat命令: ●查看进程cat : ●杀死进程cat:。 ●再次查看查看进程cat,看看是否被杀死。 2.使用top命令查看和控制进程 ●用top命令动态显示当前的进程。 ●只显示用户user01的进程(利用u键)。 ●利用k键,杀死指定进程号的进程。 3.挂起和恢复进程 ●执行命令cat。

●按Ctrl+z键,挂起进程cat。 ●输入jobs命令,查看作业。 ●输入bg,把cat切换到后台执行。 ●输入fg,把cat切换到前台执行。 ●按Ctrl+c键,结束进程cat。 4. 熟悉并使用at命令 5.安排计划任务 某系统管理员需每天做一定的重复工作,请按照下列要求,编制一个解决方案: (1)在下午4 :50删除/abc目录下的全部子目录和全部文件; (2)从早8:00~下午6:00每小时读取/xyz目录下x1文件中的全部数据加入到/backup目录下的bak01.txt文件内; (3)每逢星期一下午5:50将/data目录下的所有目录和文件归档并压缩为文件:backup.tar.gz; (4)在下午5:55将IDE接口的CD-ROM卸载(假设:CD-ROM的设备名为hdc); (5)在早晨8:00前开机后启动启动www服务器。 ●查看crontab命令的帮助信息: ●查看用户的计划任务列表: ●生成一个crontab的脚本文件: ●按照生成的脚本安排计划任务: ●查看计划任务表,看看计划任务是否已被安排: ●删除计划任务列表,并进行确认。

实验一 进程管理

实验一进程管理 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)进一步认识并发执行的实质; (3)分析进程争用资源的现象,学习解决进程互斥的方法; (4)了解Linux系统中进程通信的基本原理。 2.实验预备内容 (1)阅读Linux的sched.h源码文件,加深对进程管理概念的理解; (2)阅读Linux的fork()源码文件,分析进程的创建过程。 3.实验内容 (1)进程的创建: 编写一段程序,使用系统调用fork() 创建两个子进程。当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示字符“a”,子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果,并分析原因。 源代码如下: #include #include #include #include #include int main(int argc,char* argv[]) { pid_t pid1,pid2; pid1 = fork(); if(pid1<0){ fprintf(stderr,"childprocess1 failed"); exit(-1); } else if(pid1 == 0){ printf("b\n"); } 1/11

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

linux实验五_进程管理命令

实验五进程管理命令 一、实验目的 (1)了解如何监视系统运行状态 (2)掌握查看、删除进程的正确方法 (3)掌握命令在后台运行的用法 (4)掌握进程手工、调度启动的方法 二、常用命令 w h o 查看当前在线用户 t o p 监视系统状态 p s 查看进程 k i ll 向进程发信号 b g 把进程变成后台运行 &把进程变成后台运行 f g 把后台进程变成前台运行 j o bs 显示处于后台的进程。 a t 在指定的时刻执行指定的命令或命令序列 b a t c h 在系统负载较低、资源较空闲时执行命令或命令序列 以上命令的具体用法请参阅教材、课件和m an手册 三、实验内容 1、用t o p命令察看当前系统的状态,并识别各进程的有关栏目。 2、用p s命令察看系统当前的进程,并把系统当前的进程保存到文件p r oc es s中。 用p s au x>p ro c es s命令写入

3、用p s命令察看系统当前有没有in i t进程。 用p s –a ux|gr ep i n i t查看 4、输入“c at<回车>” 按-z 键,出现什么情况?输入f g命令出现什么情况? 按-z 键转入后台运行,fg把后台命令移回前台 按-c 键,出现什么情况?按-c 键终止命令 5、输入“f in d /-na me l s*>te mp&”,该命令的功能是什么? 查看该进程; 查找所有硬盘中ls开头的文件,并把文件名定向到temp中 输入ki l la ll f in d命令后,再查看该进程。 6、输入“f in d /-na me l s*>te mp&” 输入jo b s命令,出现什么情况? 查看这个shell中放在后台运行的程序或命令 输入f g命令出现什么情况? 调出后台运行的程序放到前台 7、指定上午XX(小时):X X(分钟)执行某命令 在上午10:20分执行m kd i r命令

操作系统复习-进程管理

2.1 进程与线程 进程是指令的集合(错,程序是指令的集合,进程是程序的一次执行过程) 优先级是进程调度的重要依据,一旦确定就不能改变(错) 在单CPU的系统中,任意时刻都有一个进程处于运行状态(错,可以空转) 进程申请CPU得不到满足时,其状态变为阻塞(错!等待CPU的进程处于就绪状态) 进程获得CPU运行是通过调度得到的(对) 线程是一种特殊的进程(对) 进程是程序在一个数据集合上运行的过程,是系统进行资源分配和调度的独立单位(对)进程是PCB结构、程序和数据的集合(对) 撤销父进程时,应同时撤销子进程(错!进程撤销可采用两种策略,一种是只撤销指定进程,另一种是撤销指定进程和其子孙进程) 线程的切换,可能会引起进程的切换(对) 引入线程后,处理机只在线程中切换(错!!) 线程是比进程更小的能独立运行的基本单位(错,这句话的成立需要一定的前提条件) 线程的引入增加了程序执行的时空开销(错,应为减少) 一个进程一定包含多个线程(错) 一个进程创建的若干线程共享该进程的程序段和数据段,但是它们有各自的运行栈区(对)中断是进程切换的必要条件,而不是充分条件。(对) 进程的基本特点:动态性,并发性,独立性,异步性,结构性。 在多道程序设计环境下,操作系统分配资源以进程为基本单位 在引入线程的操作系统中,资源分配的基本单位是进程,CPU分配的基本单位是线程。 在引入线程的操作系统中,进程是资源分配的基本单位,线程是调度的基本单位 从运行状态到就绪状态是由于时间片用完或出现了比现在进程优先级更高的进程(调度程序决定) 从就绪状态到运行状态是调度程序决定的 从阻塞状态到就绪状态是协作程序决定的 从运行状态到阻塞状态是进程自身决定的(只有这个是主动的) 对进程的管理和控制使用原语。(原语包括创建原语,撤销原语,阻塞原语,唤醒原语等)一个进程被唤醒意味着进程变为就绪状态(该进程可能重新占用CPU)。(唤醒原语的功能是将被被唤醒进程从阻塞队列中移到就绪队列中) 降低进程优先级的合理时机是进程的时间片用完。 进程调度主要负责选一个进程占有CPU。 建立多线程的主要目的是提高CPU的利用率。 进程调度的方式有抢占式,非抢占式两种。 (?)以下 C 不会引起进程创建。A.用户登录 B.作业调度 C.设备分配 D.应用请求 进程与程序的联系与区别: 联系:进程是程序的一次执行过程,没有程序就没有进程 区别: 1.进程是程序的执行,所以进程属于动态概念,程序是一组指令的有序集合,是静态的概念 2.进程的存在是暂时的,程序的存在是永久的(相对而言)

操作系统实验二

操作系统实验实验二进程管理 学号 1215108019 姓名克帆 学院信息学院 班级 12电子2

实验目的 1、理解进程的概念,明确进程和程序的区别。 2、理解并发执行的实质。 3、掌握进程的创建、睡眠、撤销等进程控制方法。 实验容与要求 基本要求:用C语言编写程序,模拟实现创建新的进程;查看运行进程;换出某个进程;杀死进程等功能。 实验报告容 1、进程、进程控制块等的基本原理。 进程是现代操作系统中的一个最基本也是最重要的概念,掌握这个概念对于理解操作系统实质,分析、设计操作系统都有其非常重要的意义。为了强调进程的并发性和动态性,可以给进程作如下定义:进程是可并发执行的程序在一个数据集合上的运行过程,是系统进行资源分配和调度的一个独立单位。 进程又就绪、执行、阻塞三种基本状态,三者的变迁图如下: 由于多个程序并发执行,各程序需要轮流使用CPU,当某程序不在CPU上运行时,必须保留其被中断的程序的现场,包括:断点地址、程序状态字、通用寄存器的容、堆栈容、程序当前状态、程序的大小、运行时间等信息,以便程序再次获得CPU时,能够正确执行。为了保存这些容,需要建立—个专用数据结构,我们称这个数据结构为进程控制块PCB (Process Control Block)。 进程控制块是进程存在的惟一标志,它跟踪程序执行的情况,表明了进程在当前时刻的状态以及与其它进程和资源的关系。当创建一个进程时,实际上就是为其建立一个进程控制块。 在通常的操作系统中,PCB应包含如下一些信息: ①进程标识信息。为了标识系统中的各个进程,每个进程必须有惟一的标识名或标 识数。 ②位置信息。指出进程的程序和数据部分在存或外存中的物理位置。 ③状态信息。指出进程当前所处的状态,作为进程调度、分配CPU的依据。 ④进程的优先级。一般根据进程的轻重缓急其它信息。 这里给出的只是一般操作系统中PCB所应具有的容,不同操作系统的PCB结构是不同的,我们将在2.8节介绍Linux系统的PCB结构。

操作系统实验二(进程管理)

操作系统进程管理实验 实验题目: (1)进程的创建编写一段程序,使用系统调用fork( )创建两个子进程。当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果,并分析原因。 (2)进程的控制修改已编写的程序,将每个进程输出一个字符改为每个进程输出一句话,在观察程序执行时屏幕上出现的现象,并分析原因。 (3)编制一段程序,使其实现进程的软中断通信。要求:使用系统调用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)进程的管道通信编制一段程序,实现进程的管道通信。使用系统调用pipe( )建立一条管道线;两个进程P1和P2分别向管道各写一句话:Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息,显示在屏幕上。要求父进程先接收子进程P1发来的消息,然后再接收子进程P2发来的消息。 实验源程序及报告: (1)、进程的创建 #include int main(int argc, char *argv[]) { int pid1,pid2; /*fork first child process*/ if ( ( pid1=fork() ) < 0 ) { printf( "ProcessCreate Failed!"); exit(-1); }

操作系统习题集------进程管理

习题集 - 2 - 进程管理 1. 在优先级调度中,__________类进程可能被“饿死”,即长时间得不到调度。 A.短进程 B.长进程 C.低优先级进程 D.大内存进程 解: C。优先级调度算法(PRI)的基本思想是:内核为每个进程赋予一个优先级,进程按照优先级的大小顺序在就绪队列中排队,内核将CPU分配给就绪队列头部的第一个进程——优先级最大的进程。因此,进程的优先级越低,在就绪队列中的排队位置就越靠近队列尾,获得运行之前的等待时间就越长。低优先级的进程必须等待所有高优先级进程运行结束后才会被调度运行。如果不断有高优先级的进程加入就绪队列,那么低优先级进程就会一直等待下去。这就是所谓的“饿死”现象。 2. 在下面的系统调用中,__________不会导致进程阻塞。 A.读/写文件 B.获得进程PID C.申请内存 D.发送消息 解: B。当正在执行的进程需要使用某种资源或等待某个事件时,如果资源已被其他进程占用或事件尚未出现,该进程不能获得所需的资源而无法继续运行,于是,进程将被阻塞。进程在阻塞状态中等待资源被释放,或等待事件的发生。所以,进程在执行系统调用时,如果需要使用某种资源,就可能导致进程阻塞。“读/写文件”需要使用设备和文件缓冲区;“申请内存”需要分配内存资源;“发送消息”需要使用消息缓冲区。 3. 下面关于临界区的叙述中,正确的是__________ A.临界区可以允许规定数目的多个进程同时执行 B.临界区只包含一个程序段 C.临界区是必须互斥地执行的程序段 D.临界区的执行不能被中断 解: C。临界段(临界区)的概念包括两个部分:①临界资源:必须互斥访问的资源。例如,需要独占使用的硬件资源,多个进程共享的变量、结构、队列、栈、文件等软件资源。②临界区:访问临界资源的、必须互斥地执行的程序段。即,当一个进程在某个临界段中执行时,其他进程不能进入相同临界资源的任何临界段。

实验报告5Linux进程管理

实验五 Linux进程管理 四、实验过程(实验步骤、记录、数据、分析、结果)(一)进程查看、终止、挂起及暂停等操作 1、使用ps命令查看和控制进程 1)显示本用户进程 #ps 2)显示所有用户的进程 #ps–au 3)在后台运行cat命令 #cat& 4)查看进程cat #ps aux |grep cat

5)杀死进程cat #kill -9 cat 6)再次查看进程cat,看看是否被杀死。 2、使用top命令查看和控制进程 1)用top命令动态显示当前的进程。

2)只显示某一用户的进程(u) 3)杀死指定进程号的进程(k) 3、挂起和恢复进程 1)执行命令cat 2)按【ctrl+z】挂起进程 3)输入jobs命令,查看作业 4)输入bg,把cat切换到后台执行5)输入fg,把cat切换到前台执行6)按【ctrl+c】结束进程

(二)通过at命令实现计划任务 1、5分钟后执行/bin/date #at now+5minutes at>/bin/date at>(提示:输入【ctrl+d】 job任务号at 年-月-日小时:分钟 如何查看结果? 使用atq可以查询到已添加的at计划任务 2、查找系统中任何以c为后缀名的文档,将结果保存到$HOME/findc文件中,指定时间为2016年12月01日早上8点 #at 8am 12/01/16 at>find / -name ‘*.c’>$HOME/findc at> job任务号at 年-月-日小时:分钟 如何查看结果? 使用atq可以查询到已添加的at计划任务 3、2题的命令写到$HOME/findjob中,使用at命令执行,并将结果保存到 $HOME/findfc文件中,指定时间为当前时间后5分钟 #vi $HOME/findjob 内容如下: find / -name ‘*.c’>$HOME/findfc 存盘退出

实验报告三进程管理及进程通信

实验三进程管理及进程通信 实验环境: Linux操作系统 实验目的: (1)利用Linux提供的系统调用设计程序,加深对进程概念的理解。 (2)体会系统进程调度的方法和效果。 (3)了解进程之间的通信方式以及各种通信方式的使用。 实验方法: 用vi 编写c 程序(假定程序文件名为prog1.c)编 译程序 $ gcc -o prog1.o prog1.c 或 $ cc -o prog1.o prog1.c 运行 $./prog1.o 实验内容及步骤: 实验1 编写程序。显示进程的有关标识(进程标识、组标识、用户标识等)。经过5 秒钟后,执行另一个程序,最后按用户指示(如:Y/N)结束操作。 编程截图:

运行结果: 实验2 参考例程1,编写程序。实现父进程创建一个子进程。体会子进程与父进程分 别获得不同返回值,进而执行不同的程序段的方法。 例程1:利用fork()创建子进程 /* 用fork()系统调用创建子进程的例子*/ main() { int i; if (fork()) /*父进程执行的程序段*/ i=wait(); /* 等待子进程结束*/{ printf("It is parent process.\n"); printf("The child process,ID number %d, is finished.\n",i); } else{

Printf(“It is child process.\n”); Sleep(10); Exit(); } } 运行结果: 思考: 子进程是如何产生的?又是如何结束的?子进程被创建后它的运行环境是怎样建立的? 答:是由父进程用fock()函数创建形成的,通过exit()函数自我结束,子进程被创建后核心 将其分配一个进程表项和进程标识符,检查同时运行的进程数目,并且拷贝进程表项的数据,由子进程继承父进程所有文件。 实验3 参考例程2,编写程序。父进程通过循环语句创建若干子进程。探讨进程的家族树 以及子进程继承父进程的资源的关系。 例程2:循环调用fork()创建多个子进程。 /*建立进程树*/ #include main() { int i; printf(“My pid is %d, my father’s pid is %d\n”,getpid() ,getppid()); for(i=0; i<3; i++) if(fork()==0) printf(“%d pid=%d ppid=%d\n”, i,getpid(),getppid()); else { j=wait(0); Printf(“%d:The chile %d is finished.\n”,getpid(),j);

相关主题