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

操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。

进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。

本实验报告将介绍进程管理的基本概念、原理和实验结果。

一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例，它拥有独立的内存空间和执行环境。

线程是进程中的一个执行单元，多个线程可以共享同一个进程的资源。

进程和线程是操作系统中最基本的执行单位。

2. 进程状态进程在运行过程中会经历不同的状态，常见的进程状态包括就绪、运行和阻塞。

就绪状态表示进程已经准备好执行，但还没有得到处理器的分配；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，需要等待某些事件的发生。

3. 进程调度进程调度是操作系统中的一个重要任务，它决定了哪个进程应该获得处理器的使用权。

常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转等。

二、进程管理的原理1. 进程控制块（PCB）PCB是操作系统中用于管理进程的数据结构，它包含了进程的各种属性和状态信息，如进程标识符、程序计数器、寄存器值等。

通过PCB，操作系统可以对进程进行管理和控制。

2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。

进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。

进程的创建和撤销是操作系统中的基本操作之一。

3. 进程同步与通信多个进程之间可能需要进行同步和通信，以实现数据共享和协作。

常见的进程同步与通信机制包括互斥锁、信号量和管道等。

三、实验结果与分析在本次实验中，我们使用了一个简单的进程管理模拟程序，模拟了进程的创建、撤销和调度过程。

通过该程序，我们可以观察到不同调度算法对系统性能的影响。

实验结果显示，先来先服务（FCFS）调度算法在一些情况下可能导致长作业等待时间过长，影响系统的响应速度。

实验报告：Linux进程管理1. 引言本实验报告将详细介绍Linux系统中进程管理的相关知识和操作。

进程管理是操作系统中的一个重要组成部分，它负责控制和调度系统中运行的各个进程，确保系统资源的合理分配和进程的正常运行。

在本实验中，我们将通过一系列步骤来了解Linux系统中进程的创建、监控和控制。

2. 实验环境为了完成本实验，我们需要在一台运行Linux操作系统的计算机上进行操作。

本实验报告基于Ubuntu 20.04 LTS操作系统进行撰写，但是适用于大多数Linux 发行版。

3. 实验步骤步骤一：创建新进程在Linux系统中，可以通过fork()系统调用来创建新的进程。

以下是一个简单的示例代码：#include <stdio.h>#include <unistd.h>int main() {pid_t pid = fork();if (pid == 0) {// 子进程逻辑printf("这是子进程\n");} else if (pid > 0) {// 父进程逻辑printf("这是父进程\n");} else {// 进程创建失败printf("进程创建失败\n");}return0;}步骤二：查看进程信息Linux系统提供了多种命令来查看系统中运行的进程信息。

以下是一些常用的命令：•ps：显示当前终端下的进程列表。

•top：实时显示进程的CPU、内存等资源占用情况。

•pstree：以树状结构显示进程的层次关系。

步骤三：杀死进程有时候我们需要终止一个运行中的进程，可以使用kill命令来发送终止信号给目标进程。

以下是一个示例：kill <PID>请将<PID>替换为目标进程的进程ID。

步骤四：进程优先级调整通过调整进程的优先级，可以影响进程在系统中的调度顺序。

在Linux系统中，可以使用nice命令来调整进程的优先级。

使用Linux终端管理进程和任务Linux终端是一种强大的工具，可以用来管理和监控系统中运行的进程和任务。

本文将介绍如何使用Linux终端来管理进程和任务，以提升系统性能和效率。

一、查看进程在Linux终端中，可以使用ps命令来查看系统中正在运行的进程。

ps命令有多种不同的选项，可以根据需求选择不同的选项来获取进程的详细信息。

1. ps aux该命令可以显示系统中所有用户的进程信息，并以列表形式进行展示。

每个进程的信息包括进程ID（PID）、CPU使用率、内存占用、进程状态等。

例如：```$ ps aux```2. ps -ef该命令显示所有进程的完整信息，包括进程之间的父子关系。

例如：```$ ps -ef```3. ps -u该命令可以按照用户名来筛选进程，并只显示该用户的进程信息。

例如：```$ ps -u username```二、管理进程在Linux终端中，可以使用kill命令来终止运行中的进程。

kill命令可以接受进程ID作为参数，或者使用进程名称来终止进程。

1. 终止进程使用kill命令终止进程时，需要指定进程的PID。

例如，要终止进程ID为123的进程，可以使用以下命令：```$ kill 123```2. 强制终止进程有时候进程可能无法正常终止，这时可以使用kill命令的-9选项强制终止进程。

例如：```$ kill -9 123```三、任务管理除了进程管理，Linux终端还可以方便地管理系统中的任务。

任务是指在终端中运行的命令或程序。

1. 后台运行任务在Linux终端中，可以使用&符号将任务放入后台运行。

例如，要在后台运行一个脚本文件，可以使用以下命令：```$ ./script.sh &```2. 列出后台任务使用jobs命令可以列出当前终端中所有正在运行的后台任务。

例如：```$ jobs```3. 暂停和恢复任务使用Ctrl+Z组合键可以将当前正在运行的任务暂停，使用fg命令可以将任务从后台恢复到前台运行。

《Linux 操作系统设计实践》实验一:进程管理实验目的:（1）加深对进程概念的理解，明确进程和程序的区别.（2）进一步认识并发执行的实质。

（3) 学习通过进程执行新的目标程序的方法.（4）了解Linux 系统中进程信号处理的基本原理。

实验环境：Red Hat Linux实验内容:（1）进程的创建编写一段程序,使用系统调用fork（）创建两个子进程，当此进程运行时，在系统中有一个父进程和两个子进程活动，让每一个进程在屏幕上显示一个字符，父进程显示字符“a”；子进程分别显示字符“b”和字符“c”，试观察记录屏幕上的显示结果，并分析原因。

程序代码：#include〈stdio。

h〉int main（）{int p1 ,p2 ；while(（p1=fork（)）==—1）；if(p1==0)putchar(’b’);else{while（(p2=fork())==-1)；if(p2==0)putchar(’c’);elseputchar('a’)；}return 0;}运行结果：bca分析：第一个while里调用fork（) 函数一次，返回两次.子进程P1得到的返回值是0，父进程得到的返回值是新子进程的进程ID（正整数）；接下来父进程和子进程P1两个分支运行,判断P1==0，子进程P1符合条件，输出“b”；接下来else里面的while里再调用fork(）函数一次，子进程P2得到的返回值是0，父进程得到的返回值是新子进程的进程ID(正整数）；接下来判断P2==0，子进程P2符合条件，输出“c”,接下来父进程输出“a”，程序结束.（2)进程的控制①修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因.程序代码：＃include〈stdio。

h〉int main(）｛int p1，p2；while((p1=fork（））==-1）;if(p1==0）printf（”Child1 is running!\n”）;else{while((p2=fork（)）==—1）;if(p2==0）printf（”Child2 is running！\n");elseprintf("Father is running！\n");}return 0;}运行结果：Child1 is running！Child2 is running！Father is running!分析:本实验和上一个实验一样,只是将每个进程输出一个字符改为每个进程输出一句话。

linux操作系统实验五实验五进程管理子系统——进程控制实验类别：设计型实验时数：6学时开课单位：计算机学院实验地点：健翔校区计算中心一、实验目的◆掌握进程的概念，深入理解进程的含义。

认识并理解并发环境中进程执行的实质问题，了解构成并发机制的进程创建过程。

能够使用系统调用完成进程创建，形成多个进程并发的环境。

◆了解在进程创建后通过对进程控制的系统调用，可实现对进程的有效控制。

掌握在进程执行中对进程进行睡眠、同步、撤销等控制方法。

◆进一步认识并发执行的实质，分析进程竞争资源的现象，学习解决进程互斥的方法。

二、实验环境操作系统：任何Unix/Linux及Sun Solaris 或windows 系列应用系统：gcc编译器。

若OS为windows系列，则还需相应的模拟环境三、预备知识1、L INUX系统中进程的含义在LINUX中，进程既是一个独立拥有资源的基本单位，又是一个独立调度的基本单位。

进程是并发环境中的实体，每个进程用一个task_struct的数据结构来表示，用来管理系统中的进程，因而task_struct就是LINUX系统中的PCB。

另外，系统内核中还有一个task向量表，是指向系统中每一个task_struct数据结构的指针的数组，因而task向量表就是LINUX系统中的PCB表。

2、L INUX中的进程创建除了init进程外，LINUX中的所有进程都是由其他进程创建的。

LINUX 中提供了系统调用fork和clone，可被进程用来创建子进程。

但系统调用fork 和clone其实都是调用内核函数do_fork()，通过克隆当前进程来创建子进程的。

四、实验内容本实验要求在LINUX/UNIX环境下用C语言编写三个多进程并发执行的程序，基本涉及了LINUX/UNIX进程管理子系统中较为常用的有关进程控制的系统调用。

实验内容如下：(1)使用fork()系统调用创建进程，使父、子进程分别运行不同的代码（要求子进程在父进程之前运行）：子进程：①以长格式显示当前目录的情况；②分屏显示file1的内容。

《Linux操作系统》实验指导书无锡科技职业学院嵌入式教研室实验一 Redhat Enterprise Linux系统的安装一．实验目的：1．掌握安装Linux系统时收集计算机硬件信息的方法。

2．掌握Linux硬盘的分区方法和硬盘分区的大小。

3．掌握Linux系统安装的过程和在安装过程中各选项的设置及硬件设备的配置。

4．通过学习项目五Linux安装的内容，学会如何安装Linux二．实验环境：PC机一台；已安装了windows 系统；vmware虚拟机；Redhat Enterprise Linux5镜像文件。

三．实验要求：通过安装向导将安装分为两步：1、基本安装，2、配置及具体安装。

在第一阶段重点如何分区，在第二阶段重点掌握如何设置密码及安装桌面环境。

实验二Linux常用命令的使用一．实验目的：1．掌握Linux系统启动和退出方法。

2．掌握Linux系统命令获得帮助的方法。

3．掌握Linux系统中的命令格式及命令使用的方法。

4．掌握Linux系统中常用基本命令的作用和命令中各选项的作用。

二．实验环境安装了Linux系统的计算机一台。

三．实验要求：1．掌握启动计算机进入Linux系统和正常退出Linux系统的方法。

2．掌握Linux系统命令的基本格式。

3．全用man和help命令获得命令帮助信息。

4．练习使用clear、date、echo、cat、ls、shutdown、reboot等命令。

四．实验内容：1．启动计算机，使用用户root进入Linux。

2．练习使用向上与向下光标查看命令历史表。

3．练习将多个命令在一行显示；练习将一个命令在多行显示。

mkdir yangye;lscp /root/yy\/home4．在/root目录下创建文件aa1,aa2,aaa,aab,aaaa,aabc等。

touch aa1 aa2 aaa aab aaaa aabc5．使用通配符查看/root目录下以aa开头的文件。

实验五L i n u x进程管理(总5页)本页仅作为文档封面，使用时可以删除This document is for reference only-rar21year.March实验五 Linux进程管理一.实验目的：1．进行系统进程管理。

2．周期性任务安排二.实验内容：1．进程状态查看；2．控制系统中运行的进程；3．安排一次性和周期性自动执行的后台进程；三.实验练习：任务一进程管理实验内容：1、查看系统中的进程；2、控制系统中的进程；3、安排计划任务。

实验步骤：1.使用ps命令查看和控制进程显示本用户的进程：显示所有用户的进程：。

在后台运行cat命令：查看进程cat ：杀死进程cat：。

再次查看进程cat，看看是否被杀死。

注：ps命令包括较丰富的可选参数，常见的可选参数包括如下几个。

-A：显示所有用户启动的进程。

-a：显示所有其他用户的进程。

-u:：显示进程拥有者、进程启动时间等更详细的信息。

-x：显示不是终端提供的进程信息。

-r：只显示正在运行的进程。

-m：显示线程信息。

-w：宽行显示进程信息。

-l：用长格式显示进程信息。

-t:：只显示由终端/dev/tty提交的信息。

2.使用top命令查看和控制进程用top命令动态显示当前的进程。

只显示用户user01的进程（利用u键）。

利用k键，杀死指定进程号的进程。

top参数：-b 以批量模式运行，但不能接受命令行输入；-c 显示命令行，而不仅仅是命令名；-d N 显示两次刷新时间的间隔，比如 -d 5，表示两次刷新间隔为5秒；-i 禁止显示空闲进程或僵尸进程；-n NUM 显示更新次数，然后退出。

比如 -n 5，表示top更新5次数据就退出；-p PID 仅监视指定进程的ID；PID是一个数值；-q 不经任何延时就刷新；-s 安全模式运行，禁用一些效互指令；-S 累积模式，输出每个进程的总的CPU时间，包括已死的子进程；交互式命令键位：space 立即更新；c 切换到命令名显示，或显示整个命令（包括参数）；f,F 增加显示字段，或删除显示字段；h, 显示有关安全模式及累积模式的帮助信息；k 提示输入要杀死的进程ID，目的是用来杀死该进程（默人信号为15）i 禁止空闲进程和僵尸进程；l 切换到显法负载平均值和正常运行的时间等信息；m 切换到内存信息，并以内存占用大小排序；n 提示显示的进程数，比如输入3，就在整屏上显示3个进程；o,O 改变显示字段的顺序；r 把renice 应用到一个进程，提示输入PID和renice的值；s 改变两次刷新时间间隔，以秒为单位；t 切换到显示进程和CPU状态的信息；A 按进程生命大小进行排序，最新进程显示在最前；M 按内存占用大小排序，由大到小；N 以进程ID大小排序，由大到小；P 按CPU占用情况排序，由大到小S 切换到累积时间模式；T 按时间／累积时间对任务排序；W 把当前的配置写到~/.toprc中；3.挂起和恢复进程执行命令cat。

实验5：进程管理及操作实验5进程管理及操作实验目的1.了解进程号，进程组号，会话号。

2.清楚进程两个生成子进程函数之间的差别实验内容a)修改程序getpgid_example.c，使结果没有父进程为1的情况。

并说明原因b)有3个进程，其中一个为父进程，其余为父进程的子进程，分别打印这三个进程的进程号，父进程号，进程组号。

c)有3个进程，其中一个为父进程，其余为父进程的子进程，其中一个子进程运行"ls-l"指令，另一个子进程在暂停5s后异常退出，父进程不阻塞自己，并等待子进程的退出信息，待收到该信息，父进程返回。

d)请修改提供的源码，实现简单的myshell，实验结果实验总结#include#include#include#include#include#include#define normal 0 /*一般的命令*/#define out_redirect 1 /*输出重定向*/#define in_redirect 2 /*输入重定向*/#define have_pipe 3 /*命令中有管道*/void print_prompt(); /*打印提示符*/void get_input(char *); /*得到输入的命令*/void explain_input(char *,int *,char a[100][256]); /*对输入命令进行解析*/ void do_cmd(int ,char a[100][256]); /*执行命令*/ int find_command(char *); /*查找命令中的可执行程序*/int main(int argc,char **argv){int i;int argcount = 0;char arglist[100][256];char **arg = NULL;char *buf = NULL;buf = (char *)malloc(256);if (buf == NULL){perror("malloc failed");exit(-1);}while(1){/*将buf所指向的空间清零*/memset(buf,0,256);print_prompt();get_input(buf);/*若输入的命令为exit或logout则退出本程序*/if (strcmp(buf,"exit\n") == 0 || strcmp(buf,"logout\n") == 0) break;for (i=0;i<100;i++){arglist[i][0] = '\0';}argcount = 0;explain_input(buf,&argcount,arglist);do_cmd(argcount,arglist);}/*将buf所指向的内存释放*/if (buf != NULL){free(buf);buf = NULL;}exit(0);}void print_prompt(){printf("myshell$$");}/*获取用户输入*/void get_input(char *buf){int len = 0;int ch;ch = getchar();while (len <256 && ch != '\n'){buf[len++] = ch;ch = getchar();}if (len ==256){printf("commond is too long \n"); exit(-1); /*输入的命令过长则退出程序*/ }buf[len] = '\n';len++;buf[len] = '\0';}/*解析buf中的命令，将结果存入arglist中，命令以回车符号\n 结束*//*如输入命令为“ls -l /tmp”，则arglist［0］，arglist［1］，arglist［2］分别为ls,-l和/t mp*/void explain_input(char *buf,int *argcount,char arglist[100][256]) {char *p = buf;char *q = buf;int number = 0;while(1){if (p[0] == '\n')break;if (p[0] == ' ')p++;else {q = p;number = 0;while ((q[0] != ' ') && (q[0] != '\n')){number++;q++;}//strncpy(arglist[*argcount],p,number+1);arglist[*argcount][number] = '\0';*argcount = *argcount + 1;p = q;}}}void do_cmd (int argcount,char arglist[100][256]){int flag = 0;int how = 0; /*用于指示命令中是否含有>,<,|*/int background = 0; /*标识命令中是否有后台运行标识符*/ int status;int i;int fd;char *arg[argcount+1];char *argnext[argcount+1];char *file;pid_t pid;/*将命令取出*/for (i=0;i<argcount;i++){< p="">arg[i] = (char *)arglist[i];}arg[argcount] = NULL;/*查看命令行是否有后台运行符*/for (i=0;i<argcount;i++){< p="">if (strncmp(arg[i],"&",1) == 0){if (i == argcount - 1){background = 1;arg[argcount-1] = NULL;break;}else {printf("wrong command\n");return;}}}for (i=0;arg[i] != NULL;i++){ if (strcmp(arg[i],">") == 0){flag++;how = out_redirect;if (arg[i+1] == NULL)flag++;}if (strcmp(arg[i],"<") == 0){flag++;how = in_redirect;if (i == 0)flag++;}if (strcmp(arg[i],"|") == 0){flag++;how = have_pipe;if (arg[i+1] == NULL)flag++;if (i == 0)flag++;}}/*flag大于1，说明命令中含有多个>,<,|符号，本程序是不支持这样的命令的，或者命令格式不对，如“ls -l /tmp >”*/ if (flag > 1){printf("wrong command\n");return;}if (how == out_redirect){/*命令只含有一个输出重定向符号>*/ for (i=0;arg[i] != NULL;i++){if (strcmp(arg[i],">") == 0){file = arg[i+1];arg[i] = NULL;}}}if (how == in_redirect){/*命令只含有一个输入重定向符号<*/ for (i=0;arg[i] != NULL;i++){if (strcmp(arg[i],"<") == 0){file = arg[i+1];arg[i] = NULL;}}}if (how == have_pipe){/*命令只含有一个管道符号|*//*把管道符号后面的部分存入argnext中，管道后面的部分是一个可执行的Shell命令*/ for (i=0;arg[i] != NULL;i++){if (strcmp(arg[i],"|") == 0){arg[i] = NULL;int j;for (j=i+1;arg[j] != NULL;j++){argnext[j-i-1] =arg[j];}argnext[j-i-1] = arg[j];break;}}}if ((pid = fork()) < 0) {printf("fork error\n");return;}switch(how) {case 0:/*pid为0说明是子进程，在子进程中执行输入的命令*/ /*输入的命令中不含>,<和|*/if (pid == 0){if (!(find_command(arg[0]))){printf("%s:command not found\n",arg[0]);exit(0);}execvp(arg[0],arg);exit(0);}break;case 1:if (pid == 0){if (!(find_command(arg[0]))){printf("%s:command not found\n",arg[0]);exit(0);}fd = open(file,O_RDWR|O_CREAT|O_TRUNC,0644); execvp(arg[0],arg);exit(0);}break;case 2:/*输入的命令中含有重定向符<*/if (pid == 0){if (!(find_command(arg[0]))){printf("%s:command not found\n",arg[0]);exit(0);}dup2(fd,0);execvp(arg[0],arg);exit(0);}break;case 3:/*输入的命令中含有管道*/if (pid == 0){int pid2;int status2;int fd2;if ((pid2 = fork()) < 0){printf("fork2 error\n");return;}else if (pid2 == 0){if (!(find_command(arg[0]))){printf("%s:command not found\n",arg[0]);exit(0);}fd2 = open("/tmp/youdonotknowfile",O_WRONLY|O_CREAT|O_TRUNC ,0644); dup2(fd2,1);execvp(arg[0],arg);exit(0);}if (waitpid(pid2,&status2,0) == -1)printf("wait for child process error\n");if (!(find_command(argnext[0]))){printf("%s:command not found\n",argnext[0]);exit(0);}fd2 = open("/tmp/youdonotknowfile",O_RDONLY);dup2(fd2,0);execvp(argnext[0],argnext);if (remove("/tmp/youdonotknowfile"))printf("remove error\n");exit(0);}break;default:break;}/*若命令中有&,表示后台执行，父进程直接返回，不等待子进程结束*/if (background == 1){printf("[process id %d]\n",pid);return;}/*父进程等待子进程结束*/if (waitpid(pid,&status,0) == -1)printf("wait for child process error\n");}int find_command(char *command){DIR *dp;struct dirent *dirp;char *path[] = {"./","/bin","/usr/bin",NULL};/*使当前目录下的程序可以运行，如命令"./fork"可以被正确解释和执行*/ if (strncmp(command,"./",2) == 0)command = command + 2;/*分别在当前目录、/bin和/usr/bin目录查找要执行的程序*/ int i = 0;while (path[i] != NULL){if ((dp = opendir(path[i])) == NULL)printf("can not open /bin \n");while((dirp = readdir(dp))!= NULL){if (strcmp(dirp->d_name,command) == 0){closedir(dp);return 1;}}closedir(dp);i++;}return 0;}</argcount;i++){<></argcount;i++){<>。

实验报告5Linux进程管理实验五 Linux进程管理四、实验过程（实验步骤、记录、数据、分析、结果）（⼀）进程查看、终⽌、挂起及暂停等操作1、使⽤ps命令查看和控制进程1）显⽰本⽤户进程#ps2）显⽰所有⽤户的进程#ps–au3）在后台运⾏cat命令#cat&4）查看进程cat#ps aux |grep cat5）杀死进程cat#kill -9 cat6）再次查看进程cat，看看是否被杀死。

2、使⽤top命令查看和控制进程1）⽤top命令动态显⽰当前的进程。

2）只显⽰某⼀⽤户的进程（u）3）杀死指定进程号的进程（k）3、挂起和恢复进程1）执⾏命令cat2）按【ctrl+z】挂起进程3）输⼊jobs命令，查看作业4）输⼊bg，把cat切换到后台执⾏5）输⼊fg，把cat切换到前台执⾏6）按【ctrl+c】结束进程（⼆）通过at命令实现计划任务1、5分钟后执⾏/bin/date#at now+5minutesat>/bin/dateat>(提⽰：输⼊【ctrl+d】job任务号at 年-⽉-⽇⼩时：分钟如何查看结果？使⽤atq可以查询到已添加的at计划任务2、查找系统中任何以c为后缀名的⽂档，将结果保存到$HOME/findc⽂件中，指定时间为2016年12⽉01⽇早上8点#at 8am 12/01/16at>find / -name ‘*.c’>$HOME/findcat>job任务号at 年-⽉-⽇⼩时：分钟如何查看结果？使⽤atq可以查询到已添加的at计划任务3、2题的命令写到$HOME/findjob中，使⽤at命令执⾏，并将结果保存到$HOME/findfc⽂件中，指定时间为当前时间后5分钟#vi $HOME/findjob内容如下：find / -name ‘*.c’>$HOME/findfc存盘退出#at –f $HOME/findjob now+5minutes4、at命令实现在3天后统计/etc/inittab⽂件的⾏数，将统计结果发送⾄$HOME/initline⽂件中#at now+3daysat>wc–l /etc/inittab>>$HOME/initlineat>5．列出现有的所有at任务，并记下相关信息6、删除某at任务，并进⾏查看是否删除（三）通过cron命令实现计划任务1、使⽤cron命令实现12⽉每天下午2点系统进⾏维护状态，重新启动系统#vi $HOME/shutcron输⼊内容：00 14 * 12 * /sbin/shutdown–r存盘退出#crontab $HOME/shutcron2、使⽤cron命令实现在12⽉1号星期四的17点30分查看/etc/passwd内容，并将查看结果送⾄$HOME/passtext #vi $HOME/checkcron输⼊内容：30 17 1 12 4 more /etc/passwd>$HOME/passtext存盘退出#crontab $HOME/checkcron3、查看当前的crontab⽂件#crontab -l4、⽤户user的crontab⽂件#crontab –u user –r。

实验内容：进程管理一、实验目的1、掌握Linux中进程的创建方法及执行情况；2、加深对进程、进程树等概念的理解；3、掌握Linux中如何加载子进程自己的程序；4、掌握父进程通过创建子进程完成某项任务的方法；5.、掌握系统调用exit()和_exit()调用的使用。

6、分析进程竞争资源的现象，学习解决进程互斥的方法；进一步认识并发执行的实质二、实验内容（一）进程的创建1、编写一段程序，使用系统调用fork( )创建两个子进程。

当此程序运行时，在系统中有一个父进程和两个子进程活动。

让每一个进程在屏幕上显示一个字符。

#include<stdio.h>main(){int p,x;p=fork();if(p>0){x=fork();if(x>0)printf("father\n");elseprintf("child2");}elseprintf("child1");}输出结果：child1child2father2、运行以下程序，分析程序执行过程中产生的进程情况。

#include <stdio.h>main(){int p,x;p=fork();if (p>0)fork();else{fork();fork();}sleep(15);}实验步骤：编译连接gcc –o forktree forktree.c后台运行./forktree &使用pstree –h 查看进程树运行结果：├─gnom e-terminal─┬─bash─┬─forktree─┬─forktree─┬─forkt ree───forktree││││└─forktree│││└─forktree││└─pstree 分析：程序运行，系统首先创建一个进程forktree,执行到p=fork()创建一个子进程forktree，子进程获得处理机优先执行，父进程等待；执行else，当执行到第一个fork()函数时，子进程创建了一个进程forktree，称之为孙进程，孙进程获得处理机往下执行，子进程等待；执行到第二个fork()函数时，孙进程又创建一个进程forktree，称之为重孙进程，重孙进程很快执行完，将处理机还给孙进程，孙进程很快执行完，将处理机还给子进程；子进程继续往下执行，执行到第二个fork()函数，又创建一个进程forktree，称之为第二孙进程，并获得处理机执行，此进程很快执行完，将处理机还给子进程，子进程也很快执行完，将处理机还给父进程，父进程P>0执行if语句，运行fork()函数，又创建一个进程forktree，称之为第二子进程，此进程获得处理机执行很快运行完，将处理机还给父进程，父进程运行sleep(15)语句，休眠15秒，用pstree命令查询进程树。

实验五Linux进程管理和打印管理一. 一.实验目的：1．1．进行系统进程管理。

2．2．配置Linux下的打印服务器，实现局域网内的Linux和Windows客户端共享使用服务器的打印机。

二. 二.实验内容：1．1．进程状态查看；2．2．控制系统中运行的进程；3．3．安排一次性和周期性自动执行的后台进程；4．4．配置Linux打印服务器；5．5．配置Linux客户端；6．6．配置Windows客户端。

三. 三.实验练习：任务一进程管理实验内容：查看系统中的进程；控制系统中的进程；安排计划任务。

实验步骤：1. 1.使用ps命令查看和控制进程●●显示本用户的进程：#ps。

●●显示所有用户的进程：#ps -au。

●●在后台运行cat命令：#cat &。

●●查看进程cat ：# ps aux |grep cat。

●●杀死进程cat：#kill –9 cat。

●●再次查看查看进程cat，看看是否被杀死。

2. 2.使用top命令查看和控制进程●●用top命令动态显示当前的进程。

●●只显示用户user01的进程（利用u键）。

●●利用k键，杀死指定进程号的进程。

3. 3.挂起和恢复进程●●执行命令cat。

●●按Ctrl+z键，挂起进程cat。

●●输入jobs命令，查看作业。

●●输入bg，把cat切换到后台执行。

●●输入fg，把cat切换到前台执行。

●●按Ctrl+c键，结束进程cat。

4.4.安排计划任务●●查看crontab命令的帮助信息：#crontab -help。

●●查看用户的计划任务列表：#crontab –l。

●●生成一个crontab的脚本文件：#echo “* /10 * * * 1” /root/bin/backup” >cronfile。

●●按照生成的脚本安排计划任务：#crontab cronfile。

●●查看计划任务表，看看计划任务是否已被安排：#crontab –l。

●●删除计划任务列表，并进行确认。

实验5Linux进程控制编程实验实验5 Linux进程控制编程实验1、实验目的（1）熟悉多用户、多任务环境，通过实验，进一步牢固掌握进程的概念；（2）掌握Linux环境下进程的创建；（3）掌握Linux环境下进程的执行和传参要求；（4）熟悉进程间的通信。

2、实验要求1、实验必须在在Linux环境下进行操作。

2、文件名按照下面规则命名：源程序文件名最后要加学号后4位尾数。

如：f+学号最后4位.c3、实验报告中需要说明实验中在Linux环境下进行的实际操作；4、实验报告中应给出实际操作命令、所编写的程序、以及计算机输出的程序运行结果。

5、按照规定格式打印实验报告。

3、实验内容注意：（1）下面xxxx是自己学号的后4位尾数。

1、编写一个程序pxxxx.c，由它作为父进程去创建一个子进程。

并且父进程和子进程分别输出自己的进程号，同时输出你学号后4位尾数。

2、本题有两小题。

（1）运行下面程序，观察运行结果，并以下面的形式画出运行结果的进程树。

p1→p11→p111|→p12|→p13它表示进程p1创建了子进程p11、p12、p13；而p11又创建了子进程p11。

//pxxxx.c#include#includeint main(void){ int result,i;for(i=0;i<3;i++){result = fork();if(result == -1){perror("fork"); _exit(1);}if(result == 0){printf(" father's PID =%d --> child's PID =%d \n" ,getppid(),getpid() );}//waitpid(result,NULL,0);}printf("Now this is parent process, my PID = %d .\n",getpid());}（2）将循环控制变量i的值修改为2，并且去掉waitpid语句的注释，再编译并运行程序，观察运行结果并画出运行结果的进程树。

Linux中的进程1．目的及内容通过对Linux进程操作，了解Linux操作系统中进程等概念。

2．实验环境Red Hat Linux操作系统。

3、背景知识Linux是一个多用户多任务的操作系统。

多用户是指多个用户可以在同一时间使用计算机系统；多任务是指Linux可以同时执行几个任务，它可以在还未执行完一个任务时又执行另一项任务。

Linux把正在运行的程序称为进程。

每当运行一个程序，我们就启动了一个进程。

但进程又与程序不同。

从某种意义上讲，一个进程的含义比一个程序的含义多，因为一个程序只是一个指令集，而一个进程却是动态的，因为它在运行中使用着系统的资源。

由于Linux是多任务系统，许多进程可以同时运行，Linux通过为每个进程分配一个进程标识符（PID）来识别和跟踪进程。

对Linux操作系统的一个用户，可随时启动一个进程，还可以监控自己的进程并查看其它的进程，如果必要，还可以终止你的进程。

下面给出了有关进程的一些基本操作。

⑴找出谁在系统上Linux中，who命令的目的是找到谁已登录到系统中了。

who命令列出目前已登录的用户的登录名、终端线路和登录时间。

[wang@www/wang]$whoroot tty1 Jun 2 10:02wang tty2 Jun 2 10:02⑵报告进程状态Linux中，ps命令报告进程的状态，并可以用它确定哪个进程正在运行、进程是否完成了、进程是否被挂起、进程已运行了多久、进程正在使用的资源、进程的相对优先权等信息。

该命令还能看到所有在系统上运行的进程的详细列表。

Ps命令格式如下：ps [选项]ps列表显示四个默认标题，这些标题是PID，TTY，TIME和COMMAND。

表8.1解释了这些标题。

下面给出了用ps命令报告进程状态的操作。

下列命令显示所有正在执行的进程：[wang@www/wang]$psPID TTY TIME CMD439 tty2 00:00:00 bash559 tty2 00:00:00 ps下列命令将列出当前正在运行的进程的基本信息：[wang@www/wang]$ps xPID TTY START TIME COMMAND439 tty2 S 0:00 -bash561 tty2 R 0:00 ps x下列命令将列出所有用户的进程信息：[wang@www/wang]$ps auUSER PID %CPU %MEM VSZ RSS TTY STA T START TIME COMMAND root 419 0.0 0.8 2032 1140 tty2 S 15:19 0:00 login-wang wang 439 0.0 0.7 1868 1020 tty2 S 15:20 0:00 -bashwang 621 0.0 0.6 2552 880 tty2 R 16:01 0:00 ps⑶结束进程当需要中断一个前台进程的时候，通常是使用<Ctrl+c>组合键；但是对于一个后台进程这个组合键是不能达到目的的。

管理进程和任务计划一、实验目的实验案例一：优化Linux系统中的服务实验案例二：管理进程并设置计划运行的任务二、实验环境实验案例一：优化Linux系统中的服务公司在文件服务器中新安装了RHEL5操作系统，由于默认启动的服务器程序较多，系统运行缓慢。

现需要对系统服务进行适当优化，减少一些不必要的自启动服务，并设置系统在开机后直接进入字符模式实验案例二：管理进程并设置计划运行的任务为了更好的了解和控制Linux服务器的有序运行，需要管理员熟悉进程管理和计划任务设置的相关操作，以完成相应的服务运行维护任务三、需求描述实验案例一：优化Linux系统中的服务设置Linux系统每次开机后自动进入字符模式界面使用ntsysv工具同时调整2、3、4、5级别中的服务状态，关闭一下系统服务：anacron、bluetooth、hidd、IP6tables、iptables、isdn、mcstrans、mdmonitor、nfslock、portmap、restorecond、rpcgssd、rpcidmapd、sendmail、settroubleshoot、yum-updatesd使用chkconfig工具调整个别服务的启动状态：将cups、gpm、nvcserver服务在运行级别3中的自启动状态设为关闭；将sftpd、sshd服务在运行级别3、5中的自启动状态设为开启查看当前系统中内存等资源的使用情况，重新启动系统登录到字符模式后，确认当前的运行级别状态，再次查看系统资源的占用情况使用initiative命令切换到图形模式，再次确认运行级别并查看内存等资源的使用情况，比较优化服务前后及在不同运行级别中的差异实验案例二：管理进程并设置计划运行的任务管理系统中的进程◆确认vsftpd、sshd服务程序的启动状态，使用service命令关闭vsftpd服务◆启动系统中的bluetooth服务，然后使用kill命令终止它的运行◆查找系统中cpu占用率超过%80的进程，并强行终止进程设置计划的系统管理任务◆走周一的早上7：50时自动清空FTP服务器公共目录“/var/ftp/pub”中的数据◆在每天晚上的10：30时自动执行任务，完成一下操作：显示当前系统时间并查看已挂载磁盘分区的磁盘使用情况，将输出结果追加保存到文件“/var/log/df.log”中，以便持续观察硬盘空间的变化◆查看所设置的计划任务表四、实验步骤实验案例一：优化Linux系统中的服务（1）修改“/etc/inittab”文件，将默认运行级别修改为3（2）运行ntsysv工具后，在交互式操作界面中将上述服务名称前面的“［*］”变为“［］”（3）使用chkconfig工具，结合“——level”选项分别调整cups、ncserver、vsftpd、sshd、saslauthd服务在指定运行级别中的自启动状态（4）使用free或top命令（输出界面的上方）查看内存等资源的使用情况，重启到字符模式后再次查看内存等资源的占用情况，并比较前后的区别（5）切换到图形模式后，再次查看内存等资源的使用情况（资源占用介于前两者之间）（6）在以后的学习过程中，可以选择字符模式（运行级别3）作为实验环境，以减少对系统资源的占用实验案例二：管理进程并设置计划运行的任务Step1管理系统中的进程（1）确认vsftpd、sshd服务程序的启动状态，使用service命令关闭sftpd服务（2）启动系统中的bluetooth服务，确认服务状态，并使用ps命令查看相关进程的详细信息（3）使用kill命令终止bluetooth服务程序中进程的运行，再次确认服务状态，最后使用server命令关闭bluetooth服务程序（4）从http://users./.au/CPUburn/download/cpuburn-in.tar.gz网址中下载CPU测试工具，解压后将“CPUburn-in”程序复制到“/sbin/”目录中，然后从另一个终端执行“cpuburn-in 10”命令进行10分钟的cpu 高负载测试。

linux进程管理的实验报告Linux进程管理的实验报告引言：Linux操作系统是一种开源的操作系统，以其稳定性和高度可定制性而受到广泛使用。

在Linux系统中，进程管理是一个重要的组成部分，它负责控制和管理系统中运行的进程。

本实验报告旨在探讨Linux进程管理的相关概念和实践。

一、进程的基本概念进程是指在计算机系统中正在运行的一个程序实例。

每个进程都有自己的内存空间、寄存器和状态。

在Linux系统中，每个进程都有一个唯一的进程标识符（PID），用于标识和管理进程。

二、进程的创建和终止在Linux系统中，进程的创建是通过fork()系统调用来实现的。

fork()系统调用会创建一个新的进程，新进程是原进程的一个副本，包括代码、数据和堆栈等。

新进程和原进程共享相同的代码段，但是拥有独立的数据和堆栈。

进程的终止可以通过exit()系统调用来实现。

当一个进程调用exit()系统调用时，它会释放所有的资源，并通知操作系统该进程已经终止。

此外，父进程可以通过wait()系统调用来等待子进程的终止，并获取子进程的退出状态。

三、进程的调度和优先级在Linux系统中，进程的调度是由调度器负责的。

调度器根据进程的优先级和调度策略来确定下一个要运行的进程。

Linux系统中有多种调度策略，如先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（Round Robin）等。

进程的优先级用一个数字表示，范围从-20到19，其中-20表示最高优先级，19表示最低优先级。

较高优先级的进程会被优先调度，以保证其能够及时响应用户的请求。

四、进程的状态转换在Linux系统中，进程可以处于不同的状态，如运行态、就绪态和阻塞态等。

进程的状态转换是由操作系统根据进程的行为和外部事件来控制的。

当一个进程被创建时，它处于就绪态，等待被调度执行。

当进程获得CPU资源并开始执行时，它进入运行态。

当进程需要等待某个事件发生时，如等待用户输入或等待某个文件读写完成，它会进入阻塞态。

实验进程管理（一）进程的创建实验实验目的1、掌握进程的概念，明确进程的含义2、认识并了解并发执行的实质实验内容1、编写一段程序，使用系统调用fork()创建两个子进程。

当此程序运行时，在系统中有一个父进程和两个子进程活动。

让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程分别显示字符'b'和字符'c'。

试观察记录屏幕上的显示结果，并分析原因。

2、修改上述程序，每一个进程循环显示一句话。

子进程显示'daughter…'及'son ……'，父进程显示'parent ……'，观察结果，分析原因。

实验准备（1）阅读LINUX的fork.c源码文件（见附录二），分析进程的创建过程。

（2）阅读LINUX的sched.c源码文件(见附录三)，加深对进程管理概念的认识。

实验指导一、进程UNIX 中，进程既是一个独立拥有资源的基本单位，又是一个独立调度的基本单位。

一个进程实体由若干个区（段）组成，包括程序区、数据区、栈区、共享存储区等。

每个区又分为若干页，每个进程配置有唯一的进程控制块PCB，用于控制和管理进程。

PCB 的数据结构如下：1、进程表项（Process Table Entry）。

包括一些最常用的核心数据：进程标识符PID、用户标识符UID、进程状态、事件描述符、进程和U区在内存或外存的地址、软中断信号、计时域、进程的大小、偏置值nice、指向就绪队列中下一个PCB 的指针P_Link、指向U 区进程正文、数据及栈在内存区域的指针。

2、U 区（U Area）。

用于存放进程表项的一些扩充信息。

每一个进程都有一个私用的U区，其中含有：进程表项指针、真正用户标识符u-ruid(read user ID)、有效用户标识符u-euid(effective user ID)、用户文件描述符表、计时器、内部I/O参数、限制字段、差错字段、返回值、信号处理数组。

linux操作系统实验报告Linux 操作系统实验报告一、实验目的本次实验的主要目的是深入了解和熟悉Linux 操作系统的基本操作、命令行使用、文件系统管理以及进程管理等方面的知识和技能。

通过实际操作和实践，提高对 Linux 操作系统的掌握程度，为今后在相关领域的学习和工作打下坚实的基础。

二、实验环境本次实验使用的是虚拟机软件 VirtualBox 安装的 Ubuntu 2004 LTS操作系统。

虚拟机配置为 2GB 内存，20GB 硬盘空间。

实验在Windows 10 操作系统的主机上进行。

三、实验内容及步骤（一）用户和权限管理1、创建新用户使用｀sudo adduser ＜username>｀命令创建新用户，例如创建用户名为｀testuser` 的新用户。

2、设置用户密码使用｀sudo passwd ＜username>｀命令为新用户设置密码。

3、切换用户使用｀su ＜username>｀命令切换到新用户。

4、用户权限管理修改｀／etc/sudoers` 文件，为新用户赋予特定的权限，例如允许执行特定的管理员命令。

（二）文件和目录操作1、查看文件和目录使用｀ls` 命令查看当前目录下的文件和目录，使用｀ls l` 命令查看详细信息，包括文件权限、所有者、大小和修改时间等。

2、创建、删除文件和目录使用｀touch ＜filename>｀命令创建新文件，使用｀mkdir ＜directoryname>｀命令创建新目录。

使用｀rm ＜filename>｀命令删除文件，使用｀rmdir ＜directoryname>｀命令删除空目录，使用｀rm r ＜directoryname>｀命令删除非空目录。

3、复制、移动文件和目录使用｀cp ＜source> ＜destination>｀命令复制文件或目录，使用｀mv ＜source> ＜destination>｀命令移动文件或目录。

进程是为了使多个程序可以并发的执行，提高系统的资源利用和吞吐量
1.linux中每个进程都有一个识别号PID
2.系统第一个启动进程是init，PID是1，是唯一一个由系统内核直接运行的进程，新的进程都是系统调用fork来产生，除了init之外，每个进程都有一个父进程。

3每个进程有实际用户识别号(运行此进程的用户识别号)，实际组识别号(运行此进程的组识别号)。

4.进程的类型，交互进程，由一个Shell启动的进程。

批处理进程，不与特定的终端相关联，提交到等待队列中顺序执行的进程。

守护进程，在linux启动后，需要运行在后台的进程
5.进程的启动方式，手动启动，调度启动。

6.进程管理，ps查看进程，-a显示所有进程，-e，在命令后显示环境变量，-u显示用户名和启动时间的信息，-x显示没有控制终端的进程，-f显示进程树，-w宽行输出，
7.kill，杀死进程。

killall也可以杀死进程，而kill命令后指定要杀死的进程PID，而killall指定进程的终止信号。

作业控制:
1.作业控制是指当前正在运行的进程的行为，也称为进程控制，
2.cmd &amp;后台运行
ctrl+d终止一个正在前台的进程
ctrl+c终止一个正在前台的进程(强行)
ctrl+z把一个前台进程挂起
jobs显示后台和被挂起进程
bg重新启动一个挂起的任务
fg把一个后台运行的作业放在前台的运行。