LINUX实验三指导书—Linux进程控制与通信(计算机)(3课时)

实验三 进程控制与通信

一、【实验目的】

1、加深进程控制和进程通信的基本原理

2、熟练使用Linux 系统下进程控制、进程通信、信号量的系统函数

二、【实验内容】

1、进程并发图如图1所示：设有7个进程，其执行次序如图7-1所示。在Linux 中中使用C 语言利用系统调用命令fork(),execl(),exit(),wait()进程描述，调用execl()函数的时候，模拟调用/bin/echo 命令，向控制台输出依据可鉴别是哪个进程的字符串即可。 P1

P1P2P2P3

P3P4P4P5

P5P6

P6P7P7

图1 进程并发图

2、利用LINUX 通信机制，实现输入字符串的自动分流操作。其中通信方式自选，下面的问题描述以管道为例，示意图如图2；

一共涉及3个管道，4个进程。

● P1：从键盘接收输入字符串，写入管道pipe1

● P2：从ipe1接收字符串，若字符串的长度为偶数，则将其写入管道 pipe2中，否则将其写入管道pipe3中.

● P3：从pipe2中读出字符串，并显示"pipe2: Even length string" ● P4: 从pipe3中读出字符串，并显示"pipe3: Odd length string" 输入exit 程序退出。

P1

P1

图2 管道示意图

3、利用LINUX信号量操作实现读者-写者问题。问题如下：

有一个初始化的数组，读者进程和写者进程均是对此数组进行操作。读者读出数组的数字，读出位置随机设定。写者是随机对数组中的数字进行修改，修改的值也是随机的。读写请求随机产生（比如按键盘上的R和W键)，并动态显示当前的状态（读的时候有多少读者，有多少个写者在等待；写的时候是谁在写，还有多少写者和读者在等待）。每个读者和写者用的时间可以预先设定。互斥约束是：读-读、读-写、写-写都互斥（做成只有读-写、写-写互斥也可以）。

4.（选做）基于SOCKET的通信程序

(1)在同一台机器上建立一个服务器端Server和一个客户端Client

(2)建立Server与Client的连接

(3)Server提供一个计算功能，即进行四则运算（除号用“/"代替）。Client从

键盘接受运算格式串，串的格式为：操作符，操作数1，操作数2，其中操作符为+，-，*，/ 中的一个

(4)例如发送字符串:*，3，5表示要Server计算3*5

(5)Server接收命令串，解析并计算之，结果以字符串形式返回给Client

(6)Client显示结果

(7)输入q结束Client, Client结束后断开与Server 的连接。

三、【实验要求】

1、熟练使用Linux下进程控制、通信、信号量的相关系统函数

2、完成实验内容要求实现的任务

3、撰写实验报告，包括实验目的、实验内容、实验要求、实验代码及运行截图、实验心得+

四、参考教材

罗宇等，《Linux操作系统实验教程》，电子工业出版社

汤小丹等，《计算机操作系统》（第三版），先电子科技大学出版社

《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命令，并观察反映。

Linux系统编程实验六进程间通信

实验六：进程间通信 实验目的： 学会进程间通信方式：无名管道，有名管道，信号，消息队列， 实验要求： （一）在父进程中创建一无名管道，并创建子进程来读该管道，父进程来写该管道（二）在进程中为SIGBUS注册处理函数，并向该进程发送SIGBUS信号（三）创建一消息队列，实现向队列中存放数据和读取数据 实验器材： 软件：安装了Linux的vmware虚拟机 硬件：PC机一台 实验步骤： （一）无名管道的使用 1、编写实验代码pipe_rw.c #include #include #include #include #include #include int main() { int pipe_fd[2];//管道返回读写文件描述符 pid_t pid; char buf_r[100]; char* p_wbuf; int r_num; memset(buf_r,0,sizeof(buf_r));//将buf_r初始化 char str1[]=”parent write1 “holle””; char str2[]=”parent write2 “pipe”\n”; r_num=30; /*创建管道*/ if(pipe(pipe_fd)<0) { printf("pipe create error\n"); return -1; } /*创建子进程*/ if((pid=fork())==0) //子进程执行代码 {

//1、子进程先关闭了管道的写端 close(pipe_fd[1]); //2、让父进程先运行，这样父进程先写子进程才有内容读sleep(2); //3、读取管道的读端，并输出数据 if(read(pipe_fd[0],buf_r, r_num)<0) { printf(“read error!”); exit(-1); } printf(“%s\n”,buf_r); //4、关闭管道的读端，并退出 close(pipe_fd[1]); } else if(pid>0) //父进程执行代码 { //1、父进程先关闭了管道的读端 close(pipe_fd[0]); //2、向管道写入字符串数据 p_wbuf=&str1; write(pipe_fd[1],p_wbuf,sizof(p_wbuf)); p_wbuf=&str2; write(pipe_fd[1],p_wbuf,sizof(p_wbuf)); //3、关闭写端，并等待子进程结束后退出 close(pipe_fd[1]); } return 0; } /*********************** #include #include #include #include #include #include int main() { int pipe_fd[2];//管道返回读写文件描述符 pid_t pid; char buf_r[100]; char* p_wbuf; int r_num;

实验三 进程通信(一)

操作系统实验报告 实验三、进程通信（一） ——管道及共享内存 一、实验目的 熟悉和掌握LINUX系统的管道通信和共享内存通信。 二、实验内容 (一)、管道通信 1、实验原理： 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统。 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。 利用系统调用pipe()可创建一个简单的管道。 int fd[2]； pipe(fd)； 调用成功，fd[0]存放供读进程使用的文件描述符（管道出口），fd[1]存放供写程使用的文件描述符（管道入口）。 一个进程在由pipe()创建管道后，一般再fork()一个子进程，然后通过管道实现父子进程间的通信，子进程将从父进程那里继承所有打开的文件描述符。则父子两个进程都能访问组成管道的两个文件描述符，这样子进程可以向父进程发送消息（或者相反）。 发送进程利用文件系统的系统调用write(fd[1],buf,size)，把buf中size个字符送入fd[1]，接收进程利用read(fd[0],buf,size)，把从fd[0]读出的size个字符置入buf中。这样管道按FIFO（先进先出）方式传送信息。 2、实验内容： #include main() { int x,fd[2]; char buf[30],s[30]; pipe(fd); while ((x=fork())==-1);

if (x==0) { close(fd[0]); printf("Child Process!\n"); strcpy(buf,"This is an example\n"); write(fd[1],buf,30); exit(0); } else{ close(fd[1]); printf("Parent Process!\n"); read(fd[0],s,30); printf("%s\n",s); printf("x value in Parent Process:%d!\n",x); } } （1）阅读上述父子进程利用管道进行通信的例子，写出程序的运行结果并分析。 程序运行x=fork()后，创建里一个子进程，在子进程里x的返回值为0，在父进程里x的返回值为7684，则子进程会执行if语句里的代码段，先关闭了管道的读入端，再在屏幕上输出“Child Process!”，然后将“This is an example\n”存入buf数组中，通过调用write()函数将buf数组的内容从管道的写入端写入，而父进程会执行else语句里的代码段，先关闭了管道的写入端，再在屏幕上输出“Parent Process!”，然后通过调用read ()函数将buf数组的内容从管道的读入端读入冰存储在s数组里，接着通过printf()函数将s数组里的内容输出到屏幕上，最后在屏幕上输出父进程中x的值。 （2）编写程序：父进程利用管道将一字符串交给子进程处理。子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串。 #include main() { int i,x,fd[2]; char buf[20],s[20],cpy[20],m[20]; strcpy(buf,"This is an example\n"); pipe(fd); write(fd[1],buf,20);

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

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

Linux 进程管理实验

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进程控制块：

实验三 进程通信doc(DOC)

实验三进程通信(二) 实验目的： 1、理解进程通信原理和基本技术 2、了解linux系统进程间通信机构（IPC）； 3、理解linux关于共享内存的概念； 4、掌握linux支持进程间共享内存的系统调用； 5、巩固进程同步概念。 实验内容： （一）闹钟。用c语言编程，实现进程间通过信号进行通信。 用fork（）创建两个进程，子进程在等待5秒后用系统调用kill（）向父进程发送SIGALRM 信号，父进程用系统调用signal（）捕捉SIGALRM信号。参考程序如下： #include #include #include static int alarm_fired = 0; //闹钟未设置 //模拟闹钟 void ding(int sig) { alarm_fired = 1; //设置闹钟 } int main() { int pid; printf("alarm application starting\n"); if((pid = fork( )) == 0) { //子进程5秒后发送信号SIGALRM给父进程 sleep(5); kill(getppid(), SIGALRM); //exit(0); return 0; } //父进程安排好捕捉到SIGALRM信号后执行ding函数 printf("waiting for alarm to go off\n"); (void) signal(SIGALRM, ding); pause(); //挂起父进程，直到有一个信号出现 if (alarm_fired) printf("Ding!\n"); printf("done\n");

实验三-进程管理

实验三进程管理 一、实验目的 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

linux进程管理篇

目录：（内容较多，加个目录） |-进程管理 进程常用命令 |- w查看当前系统信息 |- ps进程查看命令 |- kill终止进程 |- 一个存放内存中的特殊目录/proc |- 进程的优先级 |- 进程的挂起与恢复 |- 通过top命令查看进程 计划任务 |- 计划任务的重要性 |- 一次性计划at和batch |- 周期性计划crontab 进程管理的概念 进程和程序区别 1.程序是静态概念，本身作为一种软件资源长期保存；而进程是程序的执行过程，它是动态概念，有一定的生命期，是动态产生和消亡的。 2.程序和进程无一一对应关系。一个程序可以由多个时程公用；另一一方面，一个进程在活动中有可顺序地执行若干个程序 父子进程的关系 1.子进程是由一个进程所产生的进程，产生这个子进程的进程称为父进程 2.在linux系统中，使用系统调用fork创建进程。fork复制的内容包括父进程的数据和堆栈段以及父进程的进程环境。 3.父进程终止子进程自然终止。 前台进程和后台进程 前台进程 在shell提示处理打入命令后，创建一个子进程，运行命令，Shell等待命令退出，然后返回到对用户给出提示符。这条命令与Shell异步运行，即在前台运行，用户在它完成之前不能执行别一个命令

很简单，我们在执行这个查找命令时，无法进行其它操作，这个查找就属于前台进程 后台进程 在Shell提示处打入命令，若后随一个&，Shell创建子进程运行此命令，但不等待命令退出，而直接返回到对用户给出提示。这条命令与Shell同步运行，即在后台运行。“后台进程必须是非交互式的” 再来看这个命令就变成了后台进程，我们用同样的条件进行查找，把查找记过放到hzh/test/init.find这个文件中。不影响我们前台其它的操作。 进程的状态

实验三 进程间通信

实验三进程间通信（2学时） 一、实验目的 (1)了解什么是信号。 (2)熟悉LINUX系统中进程之间软中断通信的基本原理。 (3)熟悉LINUX支持的管道通信方式。 二、实验内容 （1）编写一段程序，使其现实进程的软中断通信。 即：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按 ctrl+c 键）；当捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止： Child Process11 is killed by Parent! Child Process12 is killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止 Parent Process is killed! 要求：运行以下参考程序并分析结果。 <参考程序> #include #include #include #include void waiting(),stop(),alarming(); int wait_mark; main() { int p1,p2; if(p1=fork()) /*创建子进程p1*/ { if(p2=fork()) /*创建子进程p2*/ { //父进程 wait_mark=1; signal(SIGINT,stop); /*接收到^c信号，转stop*/

signal(SIGALRM,alarming);/*接受SIGALRM*/ waiting(); kill(p1,16); /*向p1发软中断信号16*/ kill(p2,17); /*向p2发软中断信号17*/ wait(0); /*同步*/ wait(0); printf("parent process is killed!\n"); exit(0); //会暂时停止目前进程的执行，直到有信号来到或子进程结束。 } else { wait_mark=1; signal(17,stop); signal(SIGINT,SIG_IGN); /*忽略 ^c信号*/ while (wait_mark!=0); lockf(1,1,0); printf("child process2 is killed by parent!\n"); lockf(1,0,0); exit(0); } } else { wait_mark=1; signal(16,stop); signal(SIGINT,SIG_IGN); /*忽略^c信号*/ while (wait_mark!=0); lockf(1,1,0); printf("child process1 is killed by parent!\n"); lockf(1,0,0); exit(0); } } void waiting() { sleep(5); if (wait_mark!=0) kill(getpid(),SIGALRM); } void alarming()

实验五 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的脚本文件： ●按照生成的脚本安排计划任务： ●查看计划任务表，看看计划任务是否已被安排： ●删除计划任务列表，并进行确认。

linux进程管理(一)

进程介绍 程序和进程 程序是为了完成某种任务而设计的软件，比如OpenOffice是程序。什么是进程呢？进程就是运行中的程序。 一个运行着的程序，可能有多个进程。比如自学it网所用的WWW服务器是apache服务器，当管理员启动服务后，可能会有好多人来访问，也就是说许多用户来同时请求httpd服务，apache服务器将会创建有多个httpd进程来对其进行服务。 进程分类 进程一般分为交互进程、批处理进程和守护进程三类。 值得一提的是守护进程总是活跃的，一般是后台运行，守护进程一般是由系统在开机时通过脚本自动激活启动或超级管理用户root来启动。比如在 Redhat中，我们可以定义httpd 服务器的启动脚本的运行级别，此文件位于/etc/init.d目录下，文件名是httpd，/etc/init.d/httpd 就是httpd服务器的守护程序，当把它的运行级别设置为3和5时，当系统启动时，它会跟着启动。 [root@localhost ~]# chkconfig --level 35 httpd on 进程的属性： 进程ID（PID)：是唯一的数值，用来区分进程； 父进程和父进程的ID（PPID)； 启动进程的用户ID（UID）和所归属的组（GID）； 进程状态：状态分为运行R、休眠S、僵尸Z； 进程执行的优先级； 进程所连接的终端名； 进程资源占用：比如占用资源大小（内存、CPU占用量）； 父进程和子进程： 他们的关系是管理和被管理的关系，当父进程终止时，子进程也随之而终止。但子进程终止，父进程并不一定终止。比如httpd服务器运行时，我们可以杀掉其子进程，父进程并不会因为子进程的终止而终止。 在进程管理中，当我们发现占用资源过多，或无法控制的进程时，应该杀死它，以保护系统的稳定安全运行； 进程管理

进程间通信实验报告

进程间通信实验报告 班级：10网工三班学生姓名：谢昊天学号：1215134046 实验目的和要求： Linux系统的进程通信机构 (IPC) 允许在任意进程间大批量地交换数据。本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制。 实验内容与分析设计： （1）消息的创建，发送和接收。 ①使用系统调用msgget (), msgsnd (), msgrev (), 及msgctl () 编制一长度为1k 的消息的发送和接收程序。 ②观察上面的程序，说明控制消息队列系统调用msgctl () 在此起什么作用？ （2）共享存储区的创建、附接和段接。 使用系统调用shmget(),shmat(),sgmdt(),shmctl(),编制一个与上述功能相同的程序。（3）比较上述（1），（2）两种消息通信机制中数据传输的时间。 实验步骤与调试过程： 1.消息的创建，发送和接收： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)在SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER 。SERVER每接收到一个消息后显示一句“(server)received”。 (3)CLIENT端使用Key为75的消息队列，先后发送类型从10到1的消息，然后退出。最后的一个消息，既是 SERVER端需要的结束信号。CLIENT每发送一条消息后显示一句“(client)sent”。 (4)父进程在 SERVER和 CLIENT均退出后结束。 2.共享存储区的创建,附接和断接： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)SERVER端建立一个KEY为75的共享区,并将第一个字节置为-1。作为数据空的标志.等待其他进程发来的消息.当该字节的值发生变化时,表示收到了该消息,进行处理.然后再次把它的值设为-1.如果遇到的值为0,则视为结束信号,取消该队列,并退出SERVER.SERVER 每接收到一次数据后显示”(server)received”. (3)CLIENT端建立一个为75的共享区,当共享取得第一个字节为-1时, Server端空闲,可发送请求. CLIENT 随即填入9到0.期间等待Server端再次空闲.进行完这些操作后, CLIENT退出. CLIENT每发送一次数据后显示”(client)sent”. (4)父进程在SERVER和CLIENT均退出后结束。 实验结果： 1．消息的创建，发送和接收： 由 Client 发送两条消息，然后Server接收一条消息。此后Client Server交替发送和接收消息。最后一次接收两条消息。Client 和Server 分别发送和接收了10条消息。message 的传送和控制并不保证完全同步,当一个程序不再激活状态的时候,它完全可能继续睡眠,造成上面现象。在多次send message 后才 receive 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. 实验指导

Linux进程管理-实验报告

(1) 加深对进程概念的理解，明确进程和程序的区别。 (2) 进一步认识并发执行的实质。 (3) 学习通过进程执行新的U 标程序的方法。 (4) 了解Linux 系统中进程信号处理的基本原理。 Red Hat Linux (1)进程的创建 编写一段程序，使用系统调用fork ()创建两个子进程，当此进程运 行时，在系统中有一个父进程和两个子进程活动，让每一个进程在 屏幕上显示一个字符，父进程显示字符“a” ；子进程分别显示字符 “b”和字符“c” ,试观察记录屏幕上的显示结果，并分析原因。 程序代码： # include int main() { int pl ,p2 ; while((p 1 =fork())==-1); if(pl==0) putchar(b); else { while((p2=fork())==-1); if(p2==0) putchar( c 1); else putchar( a r ); } return 0; ) 运行结果：bca 分析：第一个while 里调用fork()函数一次，返回两次。子进程P1 得到的返回值是0,父进程得到的返回值是新子进程的进程ID (正 整数)；接下来父进程和子进程P1两个分支运行，判断P1二二0,子 进程P1符合条件，输出%";接下来else 里面的while 里再调用 fork()函数一次，子进程P2得到的返回值是0,父进程得到的返回值 是新子进程的进程ID (正整数)；接下来判断P2=：0,子进程P2符 合条件，输出，接下来父进程输出“a” ,程序结束。 (2)进程的控制 ① 修改已编写的程序，将每个进程输出一个字符改为每个进程输出 一 《Linux 实验目的: 实验环境: 实验内容: 操作系统设计实践》实验一：进程管理

操作系统实验三(进程通信)

暨南大学本科实验报告专用纸 一、实验目的 学习如何利用管道机制或消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。提高学生分析问题和解决问题的能力，并学习撰写规范的科学研究报告。 二、实验环境及设备 （一）实验室名称：计算机实验室 （二）主要仪器设备：PC 机、Linux 操作系统环境 三、实验内容 编写一段程序，使用管道来实现父子进程之间的进程通信。子进程项父进程发送自己的进程表示符，以及某字符串。父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。 四、实验调试分析 1、实验函数说明 （1）pipe 头文件 ：#include 定义函数： int pipe(int pipedes[2]); 函数说明： pipe()会建立管道,并将文件描述词由参数 pipedes 数组返回。 pipedes[0]为管道里的读取端，所以pipe 用read 调用的 pipedes[1]则为管道的写入端。 返回值: 若成功则返回零,否则返回-1,错误原因存于 errno 中。 错误代码: EMFILE 进程已用完文件描述词最大量 ENFILE 系统已无文件描述词可用。 EFAULT 参数 pipedes 数组地址不合法。 （2）sprintf 函数功能：把格式化的数据写入某个字符串 进程A pipedes[1] pipedes[0] 进程B 写 读

头文件：#include 函数原型：int sprintf( char *buffer, const char *format [, argument] … ); 返回值：字符串长度（strlen） （3）flock 头文件： #include 定义函数： int flock(int fd,int operation); 函数说明： flock()会依参数operation所指定的方式对参数fd所指的文件做各种锁定或解除锁定的动作。此函数只能锁定整个文件，无法锁定文 件的某一区域。 参数 operation有下列四种情况: LOCK_SH 建立共享锁定。多个进程可同时对同一个文件作共享锁定。 LOCK_EX 建立互斥锁定。一个文件同时只有一个互斥锁定。 LOCK_UN 解除文件锁定状态。 LOCK_NB 无法建立锁定时，此操作可不被阻断，马上返回进程。通常与LOCK_SH 或LOCK_EX 做OR(|)组合。 单一文件无法同时建立共享锁定和互斥锁定，而当使用dup()或fork()时文件描述词不会继承此种锁定。 返回值返回0表示成功，若有错误则返回-1，错误代码存于errno。 2、实验调试 实验过程中，由于将字符串"is sending a message to parent!"以字符数组的形式存储的，故只申请了31个字符空间，没有多申请一个字符空间存储末尾的'\0'，在程序运行时就会出现错误结果，错误结果如下图所示，理论上应该不会出现错误的，因为在write、read函数中都有限制向管道中写入、读出多少个字符的。但在运行时却出乎意料的出错了，要是申请的空间大于字符个数，就不会出现错误了。在实验过程中还遇到了另一个问题——字符串"is sending a message to parent!"被两次输出。怀疑是该字符串被两次的写入了管道，因为查看程序时只发现一个地方有输出该字符串，该字符串是从管道读出的且只输出一次，该字符串在写入管道时也是只写了一次。总之向管道中写入一次字符串，也读出一次，但是输入该字符串时且输出了两次连续的该字符串，由于实验过程中一直调试该错误程序，没有保留当时的程序，所以没有找到当时错误的原因。

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命令

实验一——Linux环境下的进程管理之欧阳光明创编

软件学院 欧阳光明（2021.03.07） 上机实验报告 课程名称：操作系统 实验项目：实验一：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区在内存或外存的地址、软中断信号、计时域、进程的大小、偏置值nice、指向就绪队列中下一个PCB的指针P_Link、指向U区进程正文、数据及栈在内存区域的指针。 （2）U区（U Area）。用于存放进程表项的一些扩充信息。 每一个进程都有一个私用的U区，其中含有：进程表项指针、真正用户标识符