Linux系统中的进程控制块
在linux 中每一个进程都由task_struct 数据结构来定义. task_struct就是我们通常所说的PCB.她是对进程控制的唯一手段也是最有效的手段. 当我们调用fork() 时, 系统会为我们产生一个task_struct结构。然后从父进程,那里继承一些数据, 并把新的进程插入到进程树中, 以待进行进程管理。因此了解
task_struct的结构对于我们理解任务调度(在linux 中任务和进程是同一概念)的关键。
在进行剖析task_struct的定义之前，我们先按照我们的理论推一下它的结构：
1、进程状态,将纪录进程在等待,运行,或死锁
2、调度信息, 由哪个调度函数调度,怎样调度等
3、进程的通讯状况
4、因为要插入进程树,必须有联系父子兄弟的指针, 当然是task_struct型
5、时间信息, 比如计算好执行的时间, 以便cpu 分配
6、标号,决定改进程归属
7、可以读写打开的一些文件信息
8、进程上下文和内核上下文
9、处理器上下文
10、内存信息
因为每一个PCB都是这样的, 只有这些结构, 才能满足一个进程的所有要求。打开/include/linux/sched.h可以找到task_struct 的定义
struct task_struct {
volatile long state; /*说明了该进程是否可以执行,还是可中断等信息*/
unsigned long flags; /*Flage 是进程号,在调用fork()时给出*/
int sigpending; /*进程上是否有待处理的信号*/
mm_segment_t addr_limit;
/**********************************************************/
/**进程地址空间,区分内核进程与普通进程在内存存放的位置不同*/
/****0-0xBFFFFFFF for user-thead ***********************/
/****0-0xFFFFFFFF for kernel-thread ***********************/
/**********************************************************/
volatile long need_resched;
/**********************************************************/
/**********调度标志,表示该进程是否需要重新调度,************/
/**********若非0,则当从内核态返回到用户态,会发生调度*******/
/**********************************************************/
int lock_depth; /*********************锁深度***************/
long nice; /*************进程的基本时间片******************/
unsigned long policy;
/**********************************************************/
/*进程的调度策略,有三种************************************/
/*实时进程:SCHED_FIFO,SCHED_RR*****************************/
/*分时进程:SCHED_OTHER*************************************/
/**********************************************************/
/**********************************************************/
struct mm_struct *mm; //进程内存管理信息
int processor;
/**********************************************************/
/*若进程不在任何CPU上运行，
/*cpus_runnable 的值是0，否则是1。
/*这个值在运行队列被锁时更新.*/
/**********************************************************/
unsigned long cpus_runnable, cpus_allowed;
struct list_head run_list; /****指向运行队列的指针*********/
unsigned long sleep_time; /*****进程的睡眠时间*************/
struct task_struct *next_task, *prev_task;
/**********************************************************/
/*用于将系统中所有的进程连成一个双向循环链表*/
/*其根是init_task.*/
/**********************************************************/
struct mm_struct *active_mm;
struct list_head local_pages;/**指向本地页面***************/
unsigned int allocation_order, nr_local_pages;
struct linux_binfmt *binfmt;/*进程所运行的可执行文件的格式*/
int exit_code, exit_signal;
int pdeath_signal;/*父进程终止是向子进程发送的信号*********/ unsigned long personality;
/*Linux可以运行由其他UNIX操作系统生成的符合iBCS2标准的程序*/ int did_exec:1;
/**********************************************************/
/*按POSIX要求设计的布尔量,区分进程正在执行从***************/
/*父进程中继承的代码,还是执行由execve装入的新程序代码******/
/**********************************************************/
pid_t pid;/**********进程标识符,用来代表一个进程***********/
pid_t pgrp;/********进程组标识,表示进程所属的进程组********/
pid_t tty_old_pgrp;/*******进程控制终端所在的组标识********/
pid_t session;/*************进程的会话标识*****************/
pid_t tgid;
int leader; /*************标志,表示进程是否为会话主管******/
struct task_struct *p_opptr,*p_pptr,*p_cptr,*p_ysptr,*p_osptr;
struct list_head thread_group; /****线程链表***************/
struct task_struct *pidhash_next;/*用于将进程链入HASH表pidhash
struct task_struct **pidhash_pprev;
wait_queue_head_t wait_chldexit; /*供wait4()使用***********/
struct completion *vfork_done; /* 供vfork() 使用***********/
unsigned long rt_priority;
/****实时优先级，用它计算实时进程调度时的weight值，/*******/
/*it_real_value，it_real_incr用于REAL定时器，单位为jiffies*/
系统根据it_real_value //设置定时器的第一个终止时间。
在定时器到期时，向进程发送SIGALRM信号，同时根据
it_real_incr重置终止时间，it_prof_value，it_prof_incr
用于Profile定时器，单位为jiffies。当进程运行时，
不管在何种状态下，每个tick都使it_prof_value值减一，
当减到0时，向进程发送信号SIGPROF，并根据it_prof_incr重置时间
it_virt_value，it_virt_value用于Virtual定时器，单位为jiffies。
当进程运行时，不管在何种状态下，每个tick都使it_virt_value值减一
当减到0时，向进程发送信号SIGVTALRM，根据it_virt_incr重置初值。
Real定时器根据系统时间实时更新，不管进程是否在运行
Virtual定时器只在进程运行时，根据进程在用户态消耗的时间更新
Profile定时器在进程运行时，根据进程消耗的时
（不管在用户态还是内核态）更新*****************************/
unsigned long it_real_value, it_prof_value, it_virt_value;
unsigned long it_real_incr, it_prof_incr, it_virt_value;
struct timer_list real_timer;//指向实时定时器的指针
struct tms times; //记录进程消耗的时间，
unsigned long start_time;//进程创建的时间
long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS]; //记录进程在每个CPU上所消耗的用户态时间和核心态时间
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
//内存缺页和交换信息：
//min_flt, maj_flt累计进程的次缺页数（Copy on Write页和匿名页）和主缺页数（从映射文件或交换设备读入的页面数）；
//nswap记录进程累计换出的页面数，即写到交换设备上的页面数。
//cmin_flt, cmaj_flt, cnswap记录本进程为祖先的所有子孙进程的累计次缺页数，主缺页数和换出页面数。在父进程
//回收终止的子进程时，父进程会将子进程的这些信息累计到自己结构的这些域中
unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
int swappable:1; //表示进程的虚拟地址空间是否允许换出
/* process credentials *////进程认证信息
//uid,gid为运行该进程的用户的用户标识符和组标识符，通常是进程创建者的uid，gid //euid，egid 为有效uid,gid
//fsuid，fsgid为文件系统uid,gid，这两个ID号通常与有效uid,gid相等，在检查对于文件系统的访问权限时使用他们。
//suid，sgid为备份uid,gid
uid_t uid,euid,suid,fsuid;
gid_t gid,egid,sgid,fsgid;
int ngroups; //记录进程在多少个用户组中
gid_t groups[NGROUPS]; //记录进程所在的组
kernel_cap_t cap_effective, cap_inheritable, cap_permitted;//进程的权能，分别是有效位集合，继承位集合，允许位集合
int keep_capabilities:1;
struct user_struct *user;
/* limits */
struct rlimit rlim[RLIM_NLIMITS]; //与进程相关的资源限制信息
unsigned short used_math; //是否使用FPU
char comm[16]; //进程正在运行的可执行文件名
/* file system info *///文件系统信息
int link_count, total_link_count;
struct tty_struct *tty; /* NULL if no tty 进程所在的控制终端，如果不需要控制终端，则该指针为空*/ unsigned int locks; /* How many file locks are being held */
/* ipc stuff *///进程间通信信息
struct sem_undo *semundo; //进程在信号灯上的所有undo操作
struct sem_queue *semsleeping; //当进程因为信号灯操作而挂起时，他在该队列中记录等待的操作/* CPU-specific state of this task *///进程的CPU状态，切换时，要保存到停止进程的
task_struct中
struct thread_struct thread;
/* filesystem information文件系统信息*/
struct fs_struct *fs;
/* open file information *///打开文件信息
struct files_struct *files;
/* signal handlers *///信号处理函数
spinlock_t sigmask_lock; /* Protects signal and blocked */
struct signal_struct *sig; //信号处理函数，
sigset_t blocked; //进程当前要阻塞的信号，每个信号对应一位
struct sigpending pending; //进程上是否有待处理的信号unsigned long sas_ss_sp;
size_t sas_ss_size;
int (*notifier)(void *priv);
void *notifier_data;
sigset_t *notifier_mask;/* Thread group tracking */
u32 parent_exec_id;
u32 self_exec_id;
/* Protection of (de-)allocation: mm, files, fs, tty */ spinlock_t alloc_lock;
void *journal_info;/* journalling filesystem info */
};
linux进程控制 实验报告
长安大学 操作系统实验报告 实验课程：操作系统 实验名称：linux进程控制 学院：信息学院 专业：软件工程 学号：2406090106 姓名：刘建 日期：2012-5-09
一、实验目的 熟悉进程的创建过程，了解系统调用函数fork() 和execl()。 二、实验内容 1、阅读实例代码fork1，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握系统调用fork( )的用法，返回值的意义。 2、阅读实例代码fork2，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握在程序中运行一个操作系统命令和运行一个程序的方法。 3、修改fork2，使之能把运行的命令和程序作为参数传给fork2。 三、设计思想 1、程序框架
pid = -1 pid = 0pid> 0 2、用到的文件系统调用函数 fork() 和execl() 四、调试过程 1、测试数据设计 （1）fork1 命名程序1： 编写程序1：
编译程序1： 运行程序1： (2)fork2
编写程序2： 运行程序2：
(3)修改fork2 编写修改程序2： 修改后的运行结果： 2、测试结果分析 （1）对于程序1：因为系统调用fork()函数是一次调用两次返回值，而且先生成子进程还是父进程是不确定的，所以第一次执行生成子进程的时候返回的pid = 0，判断pid!=-1，所以输出了I’m the child. I’m the parent. 第二次，执行父进程的时候，返回的是子进程的进程号pid> 0，即pid的值仍然不为-1，所以又输出了一次I’m the child. I’m the parent。 （2）对于程序2：第一次调用fork()函数时，由于执行的是子进程还是父进程是随机的，所以第一次对父进程返回的是子进程的进程号（大于0），即pid> 0，所以输出I’m the parent. Program end.当第二次执行子进程时返回值是0，即pid = 0，所以输出I’m the child. 并调用了execl()函数，查看了指定路径中的文件。
linux实验项目 进程控制操作
重庆电力高等专科学校 实 验 报 告 书 实验名称：Linux文件命令学院：信息工程学院 指导老师：黄泽伟 班级：软件1311 学号：201303100243 姓名：周贵波
实验项目进程控制操作 一、实验目的 1.了解进程的概念。 2.熟悉Linux的前台与后台进程控制操作。 3.掌握利用进程监控工具来维护系统的正常运行。 二、实验环境 安装了Red Hat Linux9.0和windows虚拟机系统的计算机一台。 三、实验内容 1.Linux的前台与后台进程控制操作。 2.系统监视器（system monitor）的使用和系统维护。 四、实验步骤 1.进程的前台工作方式 1)yes ok ←┘ 终端窗口显示___ok___，此时键盘能否输入其它命令____不能___，为什么？ 2)按键：Ctrl+Z，暂停一个前台进程的运行，并转为挂起进程。 3)jobs ←┘记录下看到的结果_____yes ok_________________。 4)fg %1 ←┘作用：把挂起进程转为前台进程执行； 5)再按键：Ctrl+Z 作用与2）相同； 6)jobs ←┘记录下看到的结果________yes ok______________。 7)bg %1 ←┘作用：重新运行挂起进程，但以后台方式运行； 8)此时能否再按键：Ctrl+Z暂停一个后台进程的运行？____不能__,
键盘能否输入其它命令__不能_____，为什么？ 9)用鼠标点击，关闭终端窗口。 2.进程的后台工作方式 除上面把前台进程转到后台进程的过程外，一般在shell提示符下，输入的命令后加上&，即以后台方式运行命令。再次进入终端方式。 1)xclock & ←┘后台进程1，记录其时钟的时间___16:40____ xcalc & ←┘后台进程2 find / -name ?*.jpg‘–print > templist & ←┘后台进程3 2)jobs ←┘有几个后台进程：__2______，记录显示结果： xclock xcalc & ps ←┘记录下看到的结果： 4036 pts/0 00:00:00 bash 4061 pts/0 00:00:00 xcalc 4063 pts/0 00:00:00 ps 3)fg %1 ←┘将时钟进程转到前台运行。 4)按键：Ctrl+Z, 将时钟进程挂起，记录时钟的时间___16:50______。 jobs ←┘观察显示结果____xcalc &________________。 回顾上述操作，经过二～三分钟后，看图形时钟有走动吗？____否___。 5)bg %1 ←┘ 将挂起的时钟进程转到后运行，现在再观察时钟是否会有变化，为什么？ 有后台继续运行 jobs ←┘ kill %2 ←┘杀死计算器进程，看计算器是否消失__否______。 6)ps ←┘ 观察屏幕显示，记录时钟（xclock）进程的进程号pid=__________。 7)kill
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进程控制块：
Linux操作系统进程管理的分析与应用
Linux操作系统进程管理的分析与应用（1）发布时间：2006.05.19 07:12来源：LinuxSir作者：北南南北目录 1、程序和进程； 1.1 进程分类； 1.2 进程的属性； 1.3 父进程和子进程； 2、进程管理； 2.1 ps 监视进程工具； 2.1.1 ps参数说明； 2.1.2 ps 应用举例； 2.2 pgrep 3、终止进程的工具 kill 、killall、pkill、xkill； 3.1 kill 3.2 killall 3.3 pkill 3.4 xkill 4、top 监视系统任务的工具； 4.1 top 命令用法及参数； 4.2 top 应用举例； 5、进程的优先级： nice和renice； 6、关于本文； 7、后记； 8、参考文档； 9、相关文档； 1、程序和进程； 程序是为了完成某种任务而设计的软件，比如OpenOffice是程序。什么是进程呢？进程就是运行中的程序。 一个运行着的程序，可能有多个进程。比如 https://www.sodocs.net/doc/5d19137398.html, 所用的WWW服务器是apache服务器，当管理员启动服务后，可能会有好多人来访问，也就是说许多用户来同时请求httpd服务，
apache服务器将会创建有多个httpd进程来对其进行服务。 1.1 进程分类； 进程一般分为交互进程、批处理进程和守护进程三类。 值得一提的是守护进程总是活跃的，一般是后台运行，守护进程一般是由系统在开机时通过脚本自动激活启动或超级管理用户root来启动。比如在Fedora或Redhat中，我们可以定义httpd 服务器的启动脚本的运行级别，此文件位于/etc/init.d目录下，文件名是httpd， /etc/init.d/httpd 就是httpd服务器的守护程序，当把它的运行级别设置为3和5时，当系统启动时，它会跟着启动。 [root@localhost ~]# chkconfig --level 35 httpd on 由于守护进程是一直运行着的，所以它所处的状态是等待请求处理任务。比如，我们是不是访问 https://www.sodocs.net/doc/5d19137398.html, ，https://www.sodocs.net/doc/5d19137398.html, 的httpd服务器都在运行，等待着用户来访问，也就是等待着任务处理。 Linux操作系统进程管理的分析与应用（2）发布时间：2006.05.19 07:12来源：LinuxSir作者：北南南北 1.2 进程的属性； 进程ID（PID)：是唯一的数值，用来区分进程； 父进程和父进程的ID（PPID)； 启动进程的用户ID（UID）和所归属的组（GID）； 进程状态：状态分为运行R、休眠S、僵尸Z； 进程执行的优先级； 进程所连接的终端名； 进程资源占用：比如占用资源大小（内存、CPU占用量）； 1.3 父进程和子进程； 他们的关系是管理和被管理的关系，当父进程终止时，子进程也随之而终止。但子进程终止，父进程并不一定终止。比如httpd服务器运行时，我们可以杀掉其子进程，父进程并不会因为子进程的终止而终止。 在进程管理中，当我们发现占用资源过多，或无法控制的进程时，应该杀死它，以保护系统的稳定安全运行；
Linux程序设计上机指导书3：Linux进程控制
上机三：Linux进程控制 1.目的 （1）掌握系统调用fork(),exex(),exit()等实现进程创建； （2）掌握进程的终止方式（return、exit、_exit、abort）； （3）掌握僵尸进程的产生和避免，以及wait,waitpid的使用； （4）了解守护进程的创建。 2.内容 主要上机分析代码文件。 systemtest.c 6-3.c 6-4.c 6-8.c 6-9.c 其他略。 3.步骤 1）Linux进程的创建 创建进程可以采用几种方式。可以执行一个程序（这会导致新进程的创建），也可以在程序内调用一个fork 或exec来创建新进程。fork 调用会导致创建一个子进程，而exec 调用则会用新程序代替当前进程上下文。exec系列函数并不创建新进程，调用exec前后的进程ID是相同的。
exec函数的主要工作是清除父进程的可执行代码映像，用新程序的代码覆盖调用exec 的进程代码。如果exec执行成功，进程将从新程序的main函数入口开始执行。调用exec 后，除进程ID保持不变外，还有下列进程属性也保持不变。 (1)进程的父进程ID。 (2)实际用户ID和实际用户组ID。 (3)进程组ID、会话ID和控制终端。 (4)定时器的剩余时间。 (5)当前工作目录及根目录。 (6)文件创建掩码UMASK。 (7)进程的信号掩码。 与exec系统调用不同，system将外部可执行程序加载执行完毕后继续返回调用进程。 【例6.3】设计一个程序，用fork函数创建一个子进程，在子进程中，要求显示子进程号与父进程号，然后显示当前目录下的文件信息，在父进程中同样显示子进程号与父进程号。
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这个文件中。不影响我们前台其它的操作。 进程的状态
2011180021-Linux操作系统-课程设计报告-基于Linux的进程调度模拟程序
河南中医学院 《linux操作系统》课程设计报告 题目：基于Linux的进程调度模拟程序 所在院系：信息技术学院 专业年级：2011级计算机科学与技术完成学生：2011180021 郭姗 指导教师：阮晓龙 完成日期：201X 年06 月22 日 目录 1. 课程设计题目概述3 2. 研究内容与目的4 3. 研究方法5 4. 研究报告6 5. 测试报告/实验报告7 6. 课题研究结论8 7. 总结9
1、课程设计题目概述 随着Linux系统的逐渐推广，它被越来越多的计算机用户所了解和应用. Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheduling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。本文就是对进程调度进行研究、实验的。 本文首先对Linux系统进行了简要的介绍, 然后介绍了进程管理的相关理论知识。其次，又介绍最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法的相关知识，并对进程调度进行最高优先数优先的调度算法和先来先服务算法模拟实验，并对比分析两种算法的优缺点，从而加深对进程概念和进程调度过程/算法的理解 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择某一进程占用处理机。使得系统中的进程能够有条不紊的运行，同时提高处理机的利用率以及系统的性能。所以设计模拟进程调度算法（最高优先数优先的调度算法、先来先服务算法），以巩固和加深处理进程的概念，并且分析这两种算法的优缺点。关键词：linux 进程调度调度算法
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服务器运行时，我们可以杀掉其子进程，父进程并不会因为子进程的终止而终止。 在进程管理中，当我们发现占用资源过多，或无法控制的进程时，应该杀死它，以保护系统的稳定安全运行； 进程管理
【IT专家】Linux中进程的几种状态
本文由我司收集整编，推荐下载，如有疑问，请与我司联系 Linux中进程的几种状态 2015/03/29 4411 1R (task_running) :可执行状态 ?只有在该状态的进程才可能在CPU上运行。而同一时刻可能有多个进程处于可执行状态，这些进程的task_struct结构（进程控制块）被放入对应CPU的可执行队列中（一个进程最多只能出现在一个CPU的可执行队列中）。进程调度器的任务就是从各个CPU的可执行队列中分别选择一个进程在该CPU上运行。 ?很多操作系统教科书将正在CPU上执行的进程定义为RUNNING状态、而将可执行但是尚未被调度执行的进程定义为READY状态，这两种状态在linux下统一为TASK_RUNNING状态。 ? 2S (task_interruptible):可中断的睡眠状态 ?处于这个状态的进程因为等待某某事件的发生（比如等待socket连接、等待信号量），而被挂起。这些进程的task_struct结构被放入对应事件的等待队列中。当这些事件发生时（由外部中断触发、或由其他进程触发），对应的等待队列中的一个或多个进程将被唤醒。 ?通过ps命令我们会看到，一般情况下，进程列表中的绝大多数进程都处于task_interruptible状态（除非机器的负载很高）。毕竟CPU就这么一两个，进程动辄几十上百个，如果不是绝大多数进程都在睡眠，CPU又怎么响应得过来。 ? 3D (task_uninterrupible)不可中断的睡眠状态 ?与task_interruptible状态类似，进程处于睡眠状态，但是此刻进程是不可中断的。不可中断，指的并不是CPU不响应外部硬件的中断，而是指进程不响应异步信号。绝大多数情况下，进程处在睡眠状态时，总是应该能够响应异步信号的。但是uninterruptible sleep状态的进程不接受外来的任何信号，因此无法用kill杀掉这些处于D状态的进程，无论是”kill”, “kill -9″还是”kill -15″，这种情况下，一个可选的方法就是reboot。
Linux进程管理-实验报告
(1) 加深对进程概念的理解，明确进程和程序的区别。 (2) 进一步认识并发执行的实质。 (3) 学习通过进程执行新的U 标程序的方法。 (4) 了解Linux 系统中进程信号处理的基本原理。 Red Hat Linux (1)进程的创建 编写一段程序，使用系统调用fork ()创建两个子进程，当此进程运 行时，在系统中有一个父进程和两个子进程活动，让每一个进程在 屏幕上显示一个字符，父进程显示字符“a” ；子进程分别显示字符 “b”和字符“c” ,试观察记录屏幕上的显示结果，并分析原因。 程序代码： # include
Linux课程设计进程控制
课程设计报告 课程名称Linux操作系统课程设计 指导教师张玲 起止日期2014-03-01 至2014-06-13 实验项目实验二进程控制 学院信息与通信工程学院 专业电子信息工程 学生姓名 班级/学号 成绩 指导老师签字
1. 课程设计概述 本次课设意在利用进程控制相关的系统调用编程进行进程控制实验，观察进程从创建、运行到终止的控制过程，加深对进程概念的理解。 1.1 课程设计的目的 本实验的目的是掌握进程的概念，理解进程的创建、执行、等待、终止的过程。熟悉有关进程控制的命令和系统调用，理解Shell 的工作原理。 1.2 课程设计的内容 1） 进程控制命令 ● 使用进程控制命令ps ，kill 监视和控制进程的活动 2） 编程部分 ● 用fork ，wait ，exec 系统调用编程实现进程控制； ● 编写一个简单的shell 。 1.3 设计原理 进程是一个其中运行着一个或多个线程的地址空间和这些线程所需要的系统资源。 构建的文件构架如图： 图1 实验目录树的结构 2012010948 exp2 exp1 exp3 vis vis2
2.实验步骤 2.1操作 2.1.1进程控制命令（在此终端窗口的操作截图见图1） 1.执行ps命令，查看bash进程的PID： PID就是各进程的身份标识,程序一运行系统就会自动分配给进程一个独一无二的PID。进程中止后PID被系统回收。 2.在后台运行一个yes进程： yes > /dev/null & 3.用ps -f命令观察yes进程的pid和ppid，用ps u命令观察yes进程的状态。 yes进程的父进程是哪个进程？通过查看yes程序的PPID可知其父进程为bash 4.根据命令名搜索特定的进程： ps-ef|grep yes： 5.用kill命令杀掉yes进程： kill 【PID】： 图1 进程控制命令
实验一——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区，其中含有：进程表项指针、真正用户标识符
最新整理Linux操作系统的进程管理详解
L i n u x操作系统的进程管理详解 L i n u x操作系统中进程的管理是很重要的一部分，下面由学习啦小编为大家整理了L i n u x操作系统的进程管理详解的相关知识，希望对大家有帮助! L i n u x操作系统的进程管理详解 对于L i n u x的进程的管理，是通过进程管理工具实现的，比如p s、k i l l、p g r e p等工具; L i n u x操作系统的进程管理/1、 p s监视进程工具; p s为我们提供了进程的一次性的查看，它所提供的查看结果并不动态连续的;如果想对进程时间监控，应该用t o p工具; 1.p s的参数说明; p s提供了很多的选项参数，常用的有以下几个; l长格式输出; u按用户名和启动时间的顺序来显示进程; j用任务格式来显示进程; f用树形格式来显示进程; a显示所有用户的所有进程(包括其它用户); x显示无控制终端的进程; r显示运行中的进程;
w w避免详细参数被截断; 我们常用的选项是组合是a u x或l a x，还有参数f 的应用; p s a u x或l a x输出的解释; U S E R进程的属主; P I D进程的I D; P P I D父进程; %C P U进程占用的C P U百分比; %M E M占用内存的百分比; N I进程的N I C E值，数值大，表示较少占用C P U时间; V S Z进程虚拟大小; R S S驻留中页的数量; W C H A N T T Y终端I D S T A T进程状态 D U n i n t e r r u p t i b l e s l e e p(u s u a l l y I O) R正在运行可中在队列中可过行的; S处于休眠状态; T停止或被追踪;
实验五 Linux进程管理
实验五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个进程；
linux中用信号进行进程时延控制
Linux下使用信号进行进程的运行控制 1linux的信号 信号全称为软中断信号，也有人称作软中断，是Linux系统中的最古老的进程间通讯方式。它们用来向一个或多个进程发送异步事件信号。信号可以从键盘中断中产生，另外进程对虚拟内存的非法存取等系统错误环境下也会有信号产生。信号还被shell程序用来向其子进程发送任务控制命令。 2系统调用介绍 2.1 alarm系统调用 #include
Linux实验五 进程管理命令
实验五进程管理命令 一、实验目的 （1）了解如何监视系统运行状态 （2）掌握查看、删除进程的正确方法 （3）掌握命令在后台运行的用法 （4）掌握进程手工、调度启动的方法 二、常用命令 who 查看当前在线用户 top 监视系统状态 ps 查看进程 kill 向进程发信号 bg 把进程变成后台运行 & 把进程变成后台运行 fg 把后台进程变成前台运行 jobs 显示处于后台的进程。 at 在指定的时刻执行指定的命令或命令序列 batch 在系统负载较低、资源较空闲时执行命令或命令序列以上命令的具体用法请参阅教材、课件和man手册 三、实验内容 1、用top命令察看当前系统的状态，并识别各进程的有关栏目。 2、用ps命令察看系统当前的进程，并把系统当前的进程保存到文件 process中。
3、用ps命令察看系统当前有没有init进程。 4、输入“cat <回车>” 按
实验三 Linux进程的创建与控制
实验三 Linux进程的创建与控制 一、实验目的 （1）加深对进程概念的理解，明确进程和程序的区别。 （2）进一步认识并发执行的实质。 （3）分析进程竞争资源现象，学习解决进程互斥的方法。 （4）了解Linux系统中进程通信的基本原理。 二、实验预备内容 阅读Linux的fork.c源文件，分析进程的创建过程。 三、实验内容 1. 进程的家族关系 在主程序中用3个fork（）调用，最后输出一个字符或字符串，运行此简单的程序，观察并分析运行结果。 2. 进程的创建 编写一段源程序，使系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和字符“c”。观察纪录屏幕上的显示结果，并分析原因。 3. 进程的控制 修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕出现的现象，并分析原因。 如果在程序中使用调用lockf()来给每一个子进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。 四、实验源程序(仅供参考) 1. 用进程的家族关系 main() { fork(); fork(); fork(); printf(“S”); } 查看运行结果并分析进程的创建和调用过程。 2.进程的创建 #include
Linux进程管理
八． Linux 的进程管理 （一）Linux 的进程结构 // 在文件 include/linux/task.h 中 #define NR_TASKS 512 //在文件 /kernal/ seched.c中 struct task_struct *task [ NR_TASKS ] = { &init_task }; //在文件 /include/linux / seched.h 中struct task_struct { … } //Linux的PCB内容 Linux的PCB: struct task_struct { …} 结构 [ 见补充材料 p13] (1) 进程状态 (2) 进程调度信息 (3) 进程标识
(4) 内部通信信息 (5) 进程链接指针 (6) 时间和定时器信息 (7) 文件系统信息 (8) 虚拟内存信息 (9) 进程上下文 1．Linux进程状态 long state; 2．进程调度信息： 进程普通进程——优先级调度 实时进程——先来先服务调度FCFS 时间片轮转调度 RR (1) long counter ; 进程剩余时间片 (2) long priority; 优先级（同时还表示进程 时间片）当counter=0时, priority =〉counter
(3) unsigned long policy； SCHED_ OTHER 普通进程 调度策略 SCHED_ FIFO 实时进程 SCHED_ RR 实时进程 (4)unsigned long rt_priority; 实时优先级（调度程序求权重时用到它） 3．标识号 (1) int pid ; //进程标识号 (2) unsigned short uid,euid,suid,fsuid; //用户标识，有效标识，备份标识，文件系统标识 (3) unsigned short gid,egid,sgid,fsgid; //用户组标识，有效组标识，备份组 标识，文件系统用户组标识 4. 内部通信信息 （IPC —— Inter Process Communication）为使在同一任务上协调工作，进程间必须 作通信即：交流数据
Linux进程管理
Linux进程管理Linux是一个多用户多任务的操作系统。多用户是指多个用户可以在同一时间使用计算机系统；多任务是指Linux可以同时执行几个任务，它可以在还未执行完一个任务时又执行另一项任务。 操作系统管理多个用户的请求和多个任务。大多数系统都只有一个CPU和一个主存，但一个系统可能有多个二级存储磁盘和多个输入/输出设备。操作系统管理这些资源并在多个用户间共享资源，当您提出一个请求时，给您造成一种假象，好象系统只被您独自占用。而实际上操作系统监控着一个等待执行的任务队列，这些任务包括用户作业、操作系统任务、邮件和打印作业等。操作系统根据每个任务的优先级为每个任务分配合适的时间片，每个时间片大约都有零点几秒，虽然看起来很短，但实际上已经足够计算机完成成千上万的指令集。每个任务都会被系统运行一段时间，然后挂起，系统转而处理其他任务；过一段时间以后再回来处理这个任务，直到某个任务完成，从任务队列中去除。 一，进程及作业 Linux系统上所有运行的东西都可以称之为一个进程。每个用户任务、每个系统管理守护进程，都可以称之为进程。Linux用分时管理方法使所有的任务共同分享系统资源。我们所关心的是如何去控制这些进程，让它们能够很好地为用户服务。 进程的一个比较正式的定义是∶在自身的虚拟地址空间运行的一个单独的程序。进程与程序是有区别的，进程不是程序，虽然它由程序产生。程序只是一个静态的指令集合，不占系统的运行资源；而进程是一个随时都可能发生变化的、动态的、使用系统运行资源的程序。而且一个程序可以启动多个进程。 进程和作业的概念也有区别。一个正在执行的进程称为一个作业，而且作业可以包含一个或多个进程，尤其是当使用了管道和重定向命令。 作业控制指的是控制正在运行的进程的行为。比如，用户可以挂起一个进程，等一会儿再继续执行该进程。shell将记录所有启动的进程情况，在每个进程过程中，用户可以任意地挂起进程或重新启动进程。作业控制是许多shell（包括bash和tcsh）的一个特性，使用户能在多个独立作业间进行切换。 例如，当用户编辑一个文本文件，并需要中止编辑做其他事情时，利用作业控制，用户可以让编辑器暂时挂起，返回shell提示符开始做其他的事情。其他事情做完以后，用户可以重新启动挂起的编辑器，返回到刚才中止的地方，就象用户从来没有离开编辑器一样。这只是一个例子，作业控制还有许多其他实际的用途。 二，启动进程 键入需要运行的程序的程序名，执行一个程序，其实也就是启动了一个进程。在Linux系统中每个进程都具有一个进程号，用于系统识别和调度进程。启动一个进程有两个主要途径∶手工启动和调度启动，后者是事先进行设置，根据用户要求自行启动。 1，手工启动
相关文档
- Linux环境编程_进程控制的相关系统调用
- 2011180021-Linux操作系统-课程设计报告-基于Linux的进程调度模拟程序
- 实验三 Linux进程的创建与控制
- LINUX实验三指导书—Linux进程控制与通信(计算机)(3课时)
- Linux进程控制与进程间通信
- Linux虚拟机VMware进程控制实验
- Linux 进程管理实验
- Linux系统中的进程控制块
- Linux进程控制实验报告
- Linux进程控制实验报告1
- Linux程序设计上机指导书3：Linux进程控制
- Linux进程控制函数
- 第6章 linux进程控制开发及多线程编程
- 实验2 进程控制
- 实验5 Linux进程控制编程实验
- Linux课程设计进程控制
- linux进程控制编程
- 实验五Linux进程管理.docx
- 操作系统实验2-Linux进程控制
- linux实验项目 进程控制操作