父进程和子进程
fork 子进程不继承父进程打开的文件描述符
fork 子进程不继承父进程打开的文件描述符1.引言1.1 概述概述在操作系统中，进程是指正在执行的程序的实例。
当一个进程创建子进程时，子进程会继承父进程的一些属性和资源，以便能够继续执行相同的操作。
然而，在某些情况下，子进程并不会继承父进程的所有属性和资源，其中一个重要的例子就是父进程打开的文件描述符。
文件描述符是用来标识一个文件或者文件流的抽象概念。
当一个进程需要对文件进行操作时，它必须首先打开该文件，并获得一个文件描述符。
父进程通过打开文件来获取文件描述符，而子进程在创建时则不会继承这些父进程已打开的文件描述符。
这种设计有其合理性和必要性。
首先，父进程打开的文件描述符可能会包含一些敏感信息，比如数据库连接信息、加密密钥等。
如果这些信息被子进程继承，有可能会导致安全风险。
其次，大多数情况下，子进程并不需要继承父进程的文件描述符。
子进程是作为独立的实体运行的，通常具有自己独立的文件操作需求。
虽然子进程不继承父进程的文件描述符，但是子进程可以通过其他方式来获取和打开文件。
举例来说，子进程可以使用文件路径来打开需要的文件，或者通过网络传输文件描述符等方式来获取父进程已打开的文件描述符。
因此，对于子进程来说，并不存在无法获取文件描述符的问题。
总之，子进程不继承父进程打开的文件描述符是有意而为的设计。
这一设计使得父子进程之间的资源隔离得以实现，同时也增强了系统的安全性。
在实际应用中，开发人员需要考虑到这一点，并正确处理子进程的文件操作需求。
1.2文章结构文章结构部分的内容可以描述文章的整体框架和组织结构，包括各个章节的主题和内容概要。
可以按照以下方式编写文章结构部分的内容。
文章结构部分：本文主要围绕着fork子进程不继承父进程打开的文件描述符展开讨论，旨在探讨子进程不继承父进程文件描述符的原因以及对应的影响和应用。
在引言部分，我们将通过概述对fork子进程和文件描述符的概念进行简要介绍，并给出本文的目的。
关于父进程和子进程关系，以及fork（）进程数量
关于⽗进程和⼦进程关系，以及fork（）进程数量⽗进程和⼦进程关系：⼦进程拥有⽗进程⼏乎所有资源的拷贝，重新复制存储空间，包括标准输⼊，输出的缓冲空间以及程序。
当程序中出现fork后，⼦进程将从fork语句开始复制程序代码，并且在⼦进程中执⾏。
关于fork()执⾏后，在⼦进程中返回值为0，在⽗进程中返回值为整数即⼦进程的ID。
1）循环fork（）N次，产⽣多少个⼦进程/** fork_test.c* version 3* Created on: 2010-5-29* Author: wangth*/#include <unistd.h>#include <stdio.h>int main(void){int i=0;for(i=0;i<3;i++){pid_t fpid=fork();if(fpid==0)printf("son/n");elseprintf("father/n");}return 0;} 根据以上程序可知，产⽣的⼦进程数量为：1+2+4+……+2N-1执⾏printf的打印次数为：2*（1+2+4+……+2N-1）次2）⼦进程会复制⽗进程的输⼊输出缓冲区，如果⽗进程的输⼊输出缓冲区没有输出的话，⼦进程会复制int main() {pid_t fpid;//fpid表⽰fork函数返回的值//printf("fork!");printf("fork!/n");fpid = fork();if (fpid < 0)printf("error in fork!");else if (fpid == 0)printf("I am the child process, my process id is %d/n", getpid());elseprintf("I am the parent process, my process id is %d/n", getpid());return 0;}3）以下fork（）连续中会产⽣多少个新的⼦进程#include <stdio.h>#include <unistd.h>int main(int argc, char* argv[]){fork();fork() && fork() || fork();fork();return 0;}如果有⼀个这样的表达式：cond1 && cond2 || cond3 这句代码会怎样执⾏呢？1、cond1为假，那就不判断cond2了，接着判断cond32、cond1为真，这⼜要分为两种情况：a、cond2为真，这就不需要判断cond3了b、cond2为假，那还得判断cond3fork调⽤的⼀个奇妙之处在于它仅仅被调⽤⼀次，却能够返回两次，它可能有三种不同的返回值：1、在⽗进程中，fork返回新创建⼦进程的进程ID；2、在⼦进程中，fork返回0；3、如果出现错误，fork返回⼀个负值（题⼲中说明了不⽤考虑这种情况）在fork函数执⾏完毕后，如果创建新进程成功，则出现两个进程，⼀个是⼦进程，⼀个是⽗进程。
深入解析父子线程（父子线程相互独立，子线程使用自己的栈空间，进程要等到所有线程终止运行之后。。。
深⼊解析⽗⼦线程（⽗⼦线程相互独⽴，⼦线程使⽤⾃⼰的栈空间，进程要等到所有线程终⽌运⾏之后。
说起多线程，我们可以说起⼀⼤堆和它相关的有趣话题来，⽐如什么⼦孙线程关系，⽗⼦线程关系，线程同步异步之类的研究话题来，⽽我今天所说的，是关于⽗⼦线程的⼀些有趣现象。
⾸先提出⼀个问题，“在多线程的应⽤程序中，当⽗线程结束之后，⼦线程会不会退出呢？”，本⽂将围绕这个问题，深⼊分析windows中⽗⼦线程的⽣命周期及他们之间的关系。
我们知道，不管你使⽤的是何种编程语⾔，但当我们在windows下编程，且使⽤了平台相关性的库的时候，不管我们使⽤什么函数来创建线程，最终的结果是，我们的代码中都会调⽤CreateThread来创建线程，当然，这个⼯作是由你所使⽤的库封装完成的，你可以不⽤关⼼它是如何⼯作的。
⽽在线程的使命完成之后，必须结束的时候，我们的代码中⼜会调⽤ExitThread或是TeriminateThread来终⽌线程运⾏，其中，前⼀个函数⼀般⽤来终⽌⾃⼰，后⼀个函数可以终⽌任何线程，⼤多被⽤来终⽌其它线程。
在《Windows 核⼼编程》中告诉我们，⼀般情况下，尽量让线程⾃⼰返回⽽不要使⽤ExitThread或是TeriminateThread来强制终⽌线程，也不要让包含线程的进程在线程结束前就终⽌的⽅式来结束线程。
为啥呢？⼀般情况下，对于线程函数的正常返回，这才是最好的处理⽅式，线程函数正常返回，会处理下⾯4件事情：1.线程函数中创建的所有C++对象都通过其析构函数被正常析构。
2.操作系统正确释放线程栈使⽤的内存。
3.操作系统把线程的退出代码设为线程函数的返回值。
4.系统减少线程内核对象的使⽤计数。
在线程终⽌的时候，会处理下⾯⼏件事情：1.线程拥有的所有⽤户对象句柄会被释放。
在Windows中，⼤多对象都是包含了“创建这些对象的线程”的进程拥有。
但⼀个线程有2个⽤户对象：窗⼝和钩⼦。
⼀个线程终⽌时，系统会⾃动销毁由线程创建或安装的任何窗⼝，并卸载由线程创建或安装的任何钩⼦。
操作系统原理试卷
操作系统原理试卷1、父进程创建子进程之后，父子进程间的关系是什么？答案：一个进程创建子进程之后，进程与产生的进程之间的关系是父子关系，分别成为进程和子进程。
子进程一经产生就与你进程并发执行，子进程共享父进程和子进程。
子进程一经产生就与你进程并发执行，子进程共享父进程的正文段和已经打开的文件。
2、简述文件、文件系统的概念答案：文件是具有符号名的、在逻辑上具有完整意义的一组相关信息项的有序序列。
文件系统就是操作系统中实现文件统一管理的一组软件、被管理的的文件以及为实施文件管理所需的一些数据结构的总称。
3、简述作业调度的主要算法答案：作业调度的主要算法包括先来先服务调度算法，短作业优先调度算法，优先级调度算法和高响应比调度算法。
4、简述请求分页存储管理方式中三种内存分配策略的原理答案：固定分配局部置换为每个进程分配一组固定数目的物理块，在进程运行期间物理块数保持不变，当发生缺页中断且需要进行页面置换时，从自己进程的物理块中选择一个页面换出；可变分配全局置换，是先为每个进程分配一定数量的物理块，系统留空闲物理块，当发生缺页中断时，先从空闲物理块中选择空闲空间进行调入页面，当无空闲空间时，从所有内存中选择一个页面进行置换，此种方式会使发生缺页中断的进程物理块数增加，而调出页面的进程物理块数减少；可变分配局部置换，先为进程分配一定数量的物理块，系统预留空闲物理块，当进程发生缺页中断且需要进行页面置换时，从自己的物理块中选择页面换出，只有当某个进程的缺页率上升时，系统增加该进程的物理块数，反之，减少进程分配的物理块数。
5、简述段页式存储管理方式答案：段页式存储管理方式是对用户的逻辑地址空间先分段，再对每段划分成大小相等的页，而内存地址空间会按照页面大小划分成大小相等的物理块，段页式存储管理方式每个用户的进程会具有一张段表和一组页表。
6、简述有哪些程序链接方式答案：程序的链接方式主要包括静态链接、装入时动态链接、运行时动态链接7、简述什么是快表以及快表的作用答案：基本的地址变换机构需要两次访问内存才能够访问到数据。
操作系统习题(附参考答案)
操作系统习题（附参考答案）一、单选题（共100题，每题1分，共100分）1、下列存储器中，速度最快的是（）。
A、内存B、寄存器C、CacheD、磁盘正确答案：B2、时钟中断事件属于（）中断事件。
A、程序B、自愿性C、外部D、输入/输出正确答案：C3、可变分区存储管理系统中，若采用最佳适应分配算法，“空闲区表”中的空闲区可按（）顺序排列。
A、大小从大到小B、大小从小到大C、地址从大到小D、地址从小到大正确答案：B4、从静态的角度看，下列选项中哪一个是进程必须拥有而程序所没有的？（）A、常量数据B、全局变量C、进程控制块D、代码正文正确答案：C5、（）不是管程的组成部分。
A、对局部于管程内的数据结构设置初始值的语句B、对管程内数据结构进行操作的一组过程C、局部于管程的共享数据结构D、管程外过程调用管程内数据结构的说明正确答案：D6、下列关于父进程和子进程的叙述中，正确的是（）。
A、子进程执行完了，父进程才能执行B、父进程创建了子进程，因此父进程执行完了，子进程才能执行C、撤销子进程时，应该同时撤销父进程D、撤销父进程时，应该同时撤销子进程正确答案：D7、某计算机系统中有8台打印机，有K个进程竞争使用，每个进程最多需要3台打印机。
该系统可能会发生死锁的K的最小值是（）。
A、3B、4C、2D、5正确答案：B8、分页虚拟存储管理系统中，若采用FIFO页面置换算法，则当分配的物理页面数增加时，缺页中断的次数（）。
A、减少B、可能增加也可能减少C、增加D、不变正确答案：B9、产生内存抖动的主要原因是（）。
A、内存空间太小B、CPU运行速度太慢C、CPU调度算法不合理D、页面置换算法不合理正确答案：D10、（）存储管理兼顾了段式在逻辑上清晰和页式在存储管理上方便的优点。
A、分页B、段页式C、可变分区D、分段正确答案：B11、发生死锁的必要条件有四个，要预防死锁的发生，可以破坏这四个必要条件，但破坏（）条件是不太实际的。
进程管理实验报告分析(3篇)
第1篇一、实验背景进程管理是操作系统中的一个重要组成部分，它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。
为了加深对进程管理的理解，我们进行了一系列实验，以下是对实验的分析和总结。
二、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。
2. 进一步认识并发执行的实质。
3. 分析进程争用资源的现象，学习解决进程互斥的方法。
4. 了解Linux系统中进程通信的基本原理。
三、实验内容1. 使用系统调用fork()创建两个子进程，父进程和子进程分别显示不同的字符。
2. 修改程序，使每个进程循环显示一句话。
3. 使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号，实现进程的终止。
4. 分析利用软中断通信实现进程同步的机理。
四、实验结果与分析1. 实验一：父进程和子进程分别显示不同的字符在实验一中，我们使用fork()创建了一个父进程和两个子进程。
在父进程中，我们打印了字符'a'，而在两个子进程中，我们分别打印了字符'b'和字符'c'。
实验结果显示，父进程和子进程的打印顺序是不确定的，这是因为进程的并发执行。
2. 实验二：每个进程循环显示一句话在实验二中，我们修改了程序，使每个进程循环显示一句话。
实验结果显示，父进程和子进程的打印顺序仍然是随机的。
这是因为并发执行的进程可能会同时占用CPU，导致打印顺序的不确定性。
3. 实验三：使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号在实验三中，我们使用signal()捕捉键盘中断信号（按c键），然后通过kill()向两个子进程发送信号，实现进程的终止。
实验结果显示，当按下c键时，两个子进程被终止，而父进程继续执行。
这表明signal()和kill()在进程控制方面具有重要作用。
4. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。
子进程结束后返回原路径
子进程结束后返回原路径1.引言1.1 概述子进程的创建和结束是操作系统中的一个重要概念。
在计算机程序中，子进程是通过父进程创建出来的，子进程执行完任务后可能会返回到父进程原先所在的路径。
本文将重点探讨子进程结束后如何返回到原路径的问题。
在操作系统中，进程是指正在执行的程序实例。
每个进程都有自己的执行空间、堆栈和状态。
父进程可以通过创建子进程来完成并行处理等任务。
子进程可以继承父进程的一些资源和状态，也可以有自己独立的变量和代码段。
当子进程执行完任务后，有时候需要返回到父进程原先所在的路径。
这种需求在某些场景下非常常见，比如在父子进程之间进行数据传递或者协同工作时，子进程执行完任务后需要返回到父进程原来的操作路径。
为了实现子进程结束后返回原路径，可以使用一些技术手段。
其中一种常用的方法是通过进程间通信进行协调。
父进程可以在创建子进程前保存自己的路径信息，并在子进程执行完任务后，通过进程间通信将路径信息传递给子进程。
子进程收到路径信息后，可以通过一些系统调用或命令来切换到指定路径。
另一种方法是通过获取父进程的路径信息来完成返回操作。
子进程可以通过一些系统调用或命令获取父进程的路径信息，并在任务执行完毕后使用该路径信息来返回到原路径。
总之，子进程结束后返回原路径是一个重要的问题，对于父子进程之间的协同工作和数据传递具有重要意义。
本文将在接下来的章节中详细讨论子进程的创建和结束，以及子进程结束后如何返回原路径的具体方法和技巧。
1.2文章结构文章结构是指文章的章节组织和部分之间的逻辑连贯性。
在本文中，我们将通过以下章节来组织和展示我们的内容:1. 引言1.1 概述1.2 文章结构1.3 目的2. 正文2.1 子进程的创建和结束2.2 子进程结束后的返回路径3. 结论3.1 总结3.2 后续研究方向通过以上章节的结构，我们将全面地讨论子进程结束后如何返回原路径的问题。
首先，我们会在引言部分对本文的背景和问题进行概述，然后介绍文章的结构和目的，以便读者能够更好地理解本文的内容。
父进程和子进程
⽗进程和⼦进程⽗进程在计算机领域，⽗进程（英语：Parent Process）指已创建⼀个或多个⼦进程的进程。
UNIX在UNIX⾥，除了进程0（即PID=0的交换进程，Swapper Process）以外的所有进程都是由其他进程使⽤系统调⽤fork创建的，这⾥调⽤fork 创建新进程的进程即为⽗进程，⽽相对应的为其创建出的进程则为⼦进程，因⽽除了进程0以外的进程都只有⼀个⽗进程，但⼀个进程可以有多个⼦进程。
操作系统内核以进程标识符（Process Identifier，即PID）来识别进程。
进程0是系统引导时创建的⼀个特殊进程，在其调⽤fork创建出⼀个⼦进程（即PID=1的进程1，⼜称init）后，进程0就转为交换进程（有时也被称为空闲进程），⽽进程1（init进程）就是系统⾥其他所有进程的祖先。
僵⼫进程与孤⼉进程当⼀个⼦进程结束运⾏（⼀般是调⽤exit、运⾏时发⽣致命错误或收到终⽌信号所导致）时，⼦进程的退出状态（返回值）会回报给操作系统，系统则以SIGCHLD信号将⼦进程被结束的事件告知⽗进程，此时⼦进程的进程控制块（PCB）仍驻留在内存中。
⼀般来说，收到SIGCHLD后，⽗进程会使⽤wait系统调⽤以获取⼦进程的退出状态，然后内核就可以从内存中释放已结束的⼦进程的PCB；⽽如若⽗进程没有这么做的话，⼦进程的PCB就会⼀直驻留在内存中，也即成为僵⼫进程。
孤⼉进程则是指⽗进程结束后仍在运⾏的⼦进程。
在类UNIX系统中，孤⼉进程⼀般会被init进程所“收养”，成为init的⼦进程。
为避免产⽣僵⼫进程，实际应⽤中⼀般采取的⽅式是：1. 将⽗进程中对SIGCHLD信号的处理函数设为SIG_IGN（忽略信号）；2. fork两次并杀死⼀级⼦进程，令⼆级⼦进程成为孤⼉进程⽽被init所“收养”、清理。
Linux在Linux内核中，进程和POSIX线程有着相当微⼩的区别，⽗进程的定义也与UNIX不尽相同。
实验一进程创建 Linux实验报告
实验一进程创建【实验目的和要求】1、1.了解进程的概念及意义；2.了解子进程和父进程；3.掌握创建进程的方法。
【实验内容】1、1.子进程和父进程的创建；2.编写附件中的程序实例；3.撰写实验报告。
【实验原理】1、原型：#include <unistd.h>pid_t fork(void);在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。
新进程为子进程，而原进程为父进程。
fork函数创建子进程的过程为：使用fork函数得到的子进程是父进程的一个复制品，它从父进程继承了进程的地址空间，包括进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设定、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端，而子进程所独有的只有它的进程号、资源使用和计时器等。
通过这种复制方式创建出子进程后，原有进程和子进程都从函数fork返回，各自继续往下运行，但是原进程的fork返回值与子进程的fork返回值不同，在原进程中，fork返回子进程的pid,而在子进程中，fork返回0,如果fork返回负值，表示创建子进程失败。
子进程和父进程继续执行fork调用之后的指令。
子进程是父进程的副本。
例如，子进程获得父进程数据空间、堆和栈的副本。
注意，这是子进程所有用的副本。
父进程和子进程并不共享这些存储空间部分。
父进程和子进程共享正文段。
2、原型：#include <unistd.h>pid_t vfork(void);vfork函数的调用序列和返回值与fork相同，但两者的语义不同。
vfork函数用于创建一个新进程，而该进程的目的是exec一个新程序。
vfork不将父进程的地址空间完全复制到子进程中，因为子进程会立即调用exec，它在父进程的空间中运行。
vfork保证子进程先运行，在它调用exit之后父进程才可能被调度运行，当子进程调用这两个函数中的任意一个时，父进程会恢复运行。
父子进程的说法
父子进程的说法
"父子进程"是指在操作系统中，由一个进程创建（通常是通过fork系统调用）的进程关系。
这种关系通常用于实现并发执行或并行计算，允许父进程和子进程在独立的执行空间中运行。
以下是关于父子进程的一些说明：
1.父进程：执行fork系统调用的进程称为父进程。
父进程在创建子进程后，通常会继续执行一些任务，或者等待子进程完成执行。
2.子进程：通过fork系统调用创建的新进程称为子进程。
子进程是父进程的副本，拥有独立的内存空间，但通常会继承父进程的代码段、数据段、文件描述符等信息。
3.进程独立性：父进程和子进程之间是相对独立的，它们可以并发执行，互不影响。
子进程的修改通常不会影响父进程，反之亦然。
4.通信机制：父子进程之间可以通过进程间通信（Inter-Process Communication，IPC）来进行数据交换。
常见的IPC方法包括管道、共享内存、消息队列等。
5.等待子进程：父进程通常会使用wait系统调用等待子进程的结束，并获取子进程的退出状态。
这样可以确保父进程在子进程执行完毕后进行进一步的处理。
在多进程的环境中，父子进程的概念非常重要，它们共同构成了并发执行的基础。
在Unix/Linux等操作系统中，fork系统调用是实现多进程的一种常见方式。
linux多进程编程中，子进程继承父进程哪些东西
linux多进程编程中，⼦进程继承⽗进程哪些东西⼦进程得到⽗进程东西的拷贝，不是它们本⾝。
⽗进程和⼦进程拥有独⽴的地址空间和PID参数⼦进程继承⽗进程环境(environment)变量堆栈连接的共享存储段（共享内存）打开⽂件的描述符(注意对应的⽂件的位置由⽗⼦进程共享，这会引起含糊情况)执⾏时关闭(close-on-exec) 标志 (译者注：close-on-exec标志可通过fnctl()对⽂件描述符设置，POSIX.1要求所有⽬录流都必须在exec 函数调⽤时关闭。
更详细说明，参见《APUE》 W. R. Stevens, 1993, 尤晋元等译(以下简称《⾼级编程》), 3.13节和8.9节)信号(signal)控制设定nice值 (译者注：nice值由nice函数设定，该值表⽰进程的优先级，数值越⼩，优先级越⾼)进程调度类别(scheduler class) (译者注：进程调度类别指进程在系统中被调度时所属的类别，不同类别有不同优先级，根据进程调度类别和nice值，进程调度程序可计算出每个进程的全局优先级(Global process prority)，优先级⾼的进程优先执⾏)进程的资格 (真实(real)/有效(effective)/已保存(saved) ⽤户号(UIDs)和组号(GIDs))进程组ID、添加组ID对话期ID (Session ID) (译者注：译⽂取⾃《⾼级编程》，指：进程所属的对话期 (session)ID，⼀个对话期包括⼀个或多个进程组，更详细说明参见《APUE》 9.5节)当前⼯作⽬录根⽬录 (根⽬录不⼀定是“/”，它可由chroot函数改变)⽂件⽅式创建屏蔽字(file mode creation mask (umask))资源限制控制终端⼦进程所独有进程号不同的⽗进程号(译者注：即⼦进程的⽗进程号与⽗进程的⽗进程号不同，⽗进程号可由getppid函数得到)⾃⼰的⽂件描述符和⽬录流的拷贝(译者注：⽬录流由opendir函数创建，因其为顺序读取，顾称“⽬录流”)⼦进程不继承⽗进程的进程，正⽂(text)，数据和其它锁定内存(memory locks) (译者注：锁定内存指被锁定的虚拟内存页，锁定后，不允许内核将其在必要时换出(page out)，详细说明参见《The GNU C Library Reference Manual》 2.2 版， 1999, 3.4.2节)在tms结构中的系统时间(译者注：tms结构可由times函数获得，它保存四个数据⽤于记录进程使⽤中央处理器 (CPU： CentralProcessing Unit)的时间，包括：⽤户时间，系统时间，⽤户各⼦进程合计时间，系统各⼦进程合计时间)资源使⽤(resource utilizations)设定为0阻塞信号集初始化为空集(译者注：原⽂此处不明确，译⽂根据fork函数⼿册页稍做修改)不继承由timer_create函数创建的计时器不继承异步输⼊和输出⽗进程设置的锁（因为如果是排他锁，被继承的话就⽭盾了）。
进程执行程序的案例分析
进程执行程序的案例分析父进程的行为: 复制，等待执行应用程序的方式有很多，从shell中执行是一种常见的情况。
交互式shell是一个进程(所有的进程都由pid号为1的init进程fork得到)，当在用户在shell中敲入./test执行程序时，shell先fork()出一个子进程,并且wait()这个子进程结束，所以当test执行结束后，又回到了shell等待用户输入(如果创建的是所谓的后台进程，shell则不会等待子进程结束，而直接继续往下执行)。
所以shell进程的主要工作是复制一个新的进程，并等待它的结束。
子进程的行为: "执行"应用程序进程创建后，和父进程具有相同的地址空间，如果不让子进程具有自己的地址空间，则子进程的创建没有任何意义。
在LINUX2.4.0中子进程私有地址空间的建立是通过调用系统调用do_execve实现的。
execve()在子进程中会调用execve()加载test并开始执行。
这是test被执行的关键，下面我们详细分析一下。
execve()是操作系统提供的非常重要的一个系统调用，其实在Linux中并没有exec()这个系统调用，exec只是用来描述一组函数，它们都以exec开头，分别是：#includeint execl(const char*path, const char*arg, ...);int execlp(const char*file,const char *arg, ...);int execle(const char*path,const char*arg, ..., char *const envp[]);int execv(const char*path, char*const argv[]);int execvp(const char*file,char*const argv[]);int execve(const char*path,char*const argv[], char *const envp[]);这几个都是都是libc中经过包装的的库函数，最后通过系统调用execve()实现exec 函数的作用是在当前进程里执行可执行文件，也就是根据指定的文件名找到可执行文件，用它来取代当前进程的内容，并且这个取代是不可逆的，即被替换掉的内容不再保存，当可执行文件结束，整个进程也随之僵死。
进程的控制方法
进程的控制方法进程是计算机中最基本的资源单位，它是程序在执行过程中分配和管理资源的基本单位。
为了合理有效地控制进程，提高计算机系统的性能和可靠性，我们常常需要采取一些控制方法。
本文将介绍几种常见的进程控制方法。
一、进程的创建和终止控制1. 进程的创建进程的创建是指在系统中生成一个新的进程。
常见的进程创建方法有：（1）父进程创建子进程：父进程通过调用系统调用（如fork()）创建一个新的子进程，子进程会继承父进程的资源和状态，然后可以执行不同的程序段。
（2）系统初始化创建进程：系统启动时，会自动创建一些特殊的进程，如init进程（在Linux系统中）。
2. 进程的终止进程的终止是指进程执行完毕或被强制终止。
常见的进程终止方法有：（1）正常终止：进程执行完毕后，会自动终止，并释放占用的资源。
（2）异常终止：进程在执行过程中遇到错误或异常情况，导致无法继续执行，会被强制终止。
二、进程的切换控制进程的切换是指在多道程序环境下，由于资源有限，系统需要在多个进程之间进行切换，以实现并发执行。
常见的进程切换方法有：1. 抢占式调度抢占式调度是指操作系统通过时钟中断等方式，强制挂起正在执行的进程，并将CPU分配给其他可执行的进程。
这种调度方式可以实现公平性和高效性，但需要考虑进程切换的开销。
2. 非抢占式调度非抢占式调度是指进程只有在主动放弃CPU时，才会被操作系统挂起。
这种调度方式可以减少进程切换的开销，但可能导致某些进程长时间占用CPU，影响其他进程的执行。
三、进程的同步和通信控制进程的同步和通信是指多个进程之间通过共享资源或消息传递等方式进行合作和协调。
常见的进程同步和通信方法有：1. 互斥锁互斥锁是一种用于实现进程互斥访问共享资源的机制。
当一个进程需要访问共享资源时，它必须先获得互斥锁，其他进程则需要等待锁的释放。
2. 信号量信号量是一种用于实现进程同步和互斥的机制。
通过对信号量的P 操作和V操作，进程可以实现对临界资源的互斥访问和同步执行。
进程——父子进程共享
进程——⽗⼦进程共享⼀、fork() 1. 在谈fork之前，先简单说⼀下进程的相关知识点。
（1）进程不同于程序是动态运⾏在内存中的实体，占⽤系统资源（CPU、内存等），⽽程序则是存放在磁盘中的静态的资源，占⽤磁盘空间⽽不占⽤系统资源。
进程在内存中运⾏，由CPU分配资源。
（2）与进程相关的两个内存：虚拟内存和物理内存。
所谓虚拟内存就是我们程序员视⾓下的内存，⽐如int a = 10; &a 所得的值就是虚拟内存，是给我们程序员看的连续的地址空间。
（当我们在代码中连续定义⼏个local object时，通过&可以观察到它们的地址是连续的）相对的，物理内存才是实实在在的存在于计算机硬件中的内存（⽐如买内存条时我们可以参考的4G、8G等容量参数），当执⾏ a = 20这条语句时，操作系统就会将 a 的虚拟地址送⼊ CPU的地址转换单元（MMU），如果a还没有实际的物理单元，则为a分配物理内存，写⼊20，反之直接将20写⼊a物理内存单元。
（3）为什么会有虚拟内存？虚拟内存的产⽣源⾃物理内存的稀缺，买过SSD或者内存条的伙伴都知道，250G的SSD也就是250块左右，⽽仅仅8G的内存条就要250块，内存的⼩容量与⾼价格的反差促使猿们必须节省内存的开销。
由此产⽣了虚拟内存技术，32位系统下，CPU会为每个进程分配4G的虚拟地址单元（地址编号为0-4G），分为⽤户空间（通常为0-3G）和内核（kernel）空间（3-4G），⽤户空间存放该进程的堆栈变量、全局变量等，kernel⾥存放该进程的进程控制块（PCB，唯⼀区分每⼀个进程）。
虚拟内存单元只有在被进程访问后才会映射为物理内存单元（见（2）a=20的执⾏过程）。
（4）内存使⽤的⼀⼤机制（虚拟内存能实现的原因）：缺页中断（见⽂章最后）。
2. fork()函数⽤于创建进程，fork执⾏完后系统就产⽣了⼀个新的进程，成为调⽤fork的进程的⼦进程，此时系统中有两个进程，⽗进程和⼦进程。
父子进程实验报告总结
父子进程实验报告总结1. 引言本实验主要是通过使用父子进程的概念进行实践，深入了解进程的创建和管理的相关知识。
通过实验，我们对进程的创建与退出、进程之间的关系等方面有了更加深入的理解。
2. 实验设计在本次实验中，我们使用C语言编写了一个简单的程序来演示父子进程的创建和管理。
具体的实验设计如下：1. 使用`fork()`函数创建子进程；2. 子进程输出自己的进程ID和父进程的进程ID，然后退出；3. 父进程输出自己的进程ID和子进程的进程ID，并等待子进程退出。
3. 实验过程实验过程如下：1. 首先，我们在代码中使用`fork()`函数创建子进程。
2. 然后，通过判断返回值来确定当前代码是在子进程还是在父进程中，并分别输出相应的进程ID。
3. 子进程打印自己的进程ID以及父进程的进程ID，并立即退出。
4. 父进程打印自己的进程ID以及子进程的进程ID，并使用`wait()`函数等待子进程退出。
5. 最后，父进程输出等待到的子进程的进程ID以及退出状态。
4. 实验结果经过实验，我们得到了以下结果：父进程ID：1234，子进程ID：1235子进程ID：1235，父进程ID：1234实验结果符合我们的预期，说明我们的实验设计是正确的。
5. 实验分析通过本次实验，我们对父子进程有了更加深入的理解。
我们观察到父进程创建了子进程后，子进程会执行完自己的代码后退出，而父进程会继续执行剩余的代码。
这说明父进程和子进程是并发执行的，它们各自有自己的上下文和执行流程。
同时，我们使用了`wait()`函数来等待子进程退出。
这样可以使父进程在子进程退出前一直处于阻塞状态，避免了父进程提前退出导致子进程成为僵尸进程的情况。
6. 实验总结通过本次实验，我们对父子进程的创建和管理有了更加深入的理解。
我们学会了使用`fork()`函数来创建子进程，并理解了父子进程之间的关系。
另外，我们还学会了使用`wait()`函数等待子进程退出，以避免子进程变成僵尸进程。
有关Linux下父子进程之间的几个思考与结论
1 . 父进程可以利用wait()/ waitpid()等待子进程的结束,避免僵死子进程的产生,当然也可以循环的wait()/ watipid()来等待所有的子进程的结束;最好可以用法是，在子进程结束时，会向父进程发送的SIGCHLD信号，父进程通过signal()/sigaction()来响应子进程的结束.具体实例可参考：TestFork4.c,关键代码如下：signal(SIGCHLD, sigchld_handler);void sigchld_handler(int sig){pid_t pid;int status;for(; (pid =waitpid(-1, &status, WNOHANG)) >0;){printf("child %d died:%d\n", pid, WEXITSTATUS(status));// pid, status);}//while((pid =waitpid(-1, &status, WNOHANG))>0){}return;}2 . 当父进程结束时，还未结束的子进程就会成为孤儿进程，系统会把init进程作为其父进程；从而使得子进程在父进程结束后，继续运行.3 . 对于父子进程共存时，产生相关信号如SIGINT时，父子进程都能接受到此信号，只是先由父进程响应，再由父进程把此信号传递给子进程；但要注意的地方是：(1）如父进程没有对该信号进程自定义处理，则父子进程都接受信号的默认处理，eg:在没有对SIGINT进程自定义处理时，产生此信号，由父子进程都马上中止；(2）如父进程自定义了信号处理方法，则子进程一样接受此信号和其信号处理方法；此时，若子进程成为孤儿进程，则此时的子进程不会再接受此信号和其信号处理方法.具体实例可参考 TestFork6.c,关键代码如下：signal(SIGINT, sig_handler);for(i =0; i<5; i++){if(fork() ==0){printf("child %d\n", getpid());sleep(5);//此刻，响应SIGINT信号，且信号处理完后唤醒进程printf("after sleep1:child %d\n", getpid());sleep(5);//到此刻，子进程成为孤儿进程，因此不再响应SIGINT 信号printf("after sleep2:child %d\n", getpid());exit(0);}}4 . 在创建子进程时，内核将父进程的很多内容拷贝给子进程，同时在调用fork()后，父子进程共享正文部分（其实也相当于拷贝）；注意拷贝两字，所以子进程中修改的东东对父进程没有作用，除非利用父子进程通信方法；因此，要特别注意子进程的代码编写，如动态空间的释放问题，内存信号修改问题；具体实例可参考：TestFork1.c,关键代码如下：gets(buf);pid =fork();if(pid ==0){printf("child:");strcpy(buf, "xiaofeng");//此处的buf（为主进程中buf的一个副本）与else(主进程）中的buf 无关，因为对其修改不会影响主进程中buf的内容}else{printf("parent:");sleep(5);}printf("%s\n", buf);//此处输出结果处决于该语句位于哪个进程（父/子进程）结果：（hello 为gets(buf)语句）hellochild:xiaofengparent:hello5 . 补充下有关信号的几个结论：(1）信号处理有三种模式,一为默认处理方式；二为信号忽略方式；三为自定义信号处理方法;(2) 当一个进程睡眠在可中断优先级时，进程捕获的信号将中断进程的睡眠//补充,添加多线程Linux下的多线程模型的特点:Linux下的线程实质上是轻量级进程(light weighted process),线程生成时会生成对应的进程控制结构，只是该结构与父线程的进程控制结构共享了同一个进程内存空间。
操作系统进程创建父子进程实验报告
2009-2010学年第一学期专业：网络工程班级：071022学号：07102210姓名：刘辰龙提交日期：2009.12.04实验一、Linux进程创建与进程通信【实验目的】1. 熟悉有关Linux系统调用；2. 学习有关Linux的进程创建，理解进程创建后两个并发进程的执行；3. 通过系统调用wait()和exit()，实现父子进程同步；4. 掌握管道、消息缓冲等进程通信方法并了解其特点和使用限制。
【实验程序及分析】1. 父进程创建子进程实现父进程创建一个子进程，返回后父子进程分别循环输出字符串“The parent process.”及“The child process.”5次，每次输出后使用sleep(1)延时一秒，然后再进入下一次循环。
给出源程序代码和运行结果。
程序代码：#include<stdio.h>main(){int p,i;while((p=fork())==-1); //创建子进程直至成功if(p==0) //子进程返回{for(i=0;i<5;i++){printf("The child process!\n");sleep(1); //延时1秒}}else{ //父进程返回for(i=0;i<5;i++){printf("The parent process!\n");sleep(1); //延时1秒}}}运行结果：2.父子进程同步修改上题程序，使用exit()和wait()实现父子进程同步，其同步方式为父进程等待子进程的同步，即：子进程循环输出5次，然后父进程再循环输出5次。
给出源程序代码和运行结果。
程序代码：#include<stdio.h>main(){int p,i;while((p=fork())==-1); //创建子进程直至成功if(p>0) //返回父进程{wait(0); //父进程等待子进程终止for(i=0;i<5;i++){printf("The parent process!\n");sleep(1); //延时1秒}}else //返回子进程{for(i=0;i<5;i++){printf("The child process!\n");sleep(1);}exit(0); //子进程向父进程发终止信号0 }}运行结果：3. Linux管道通信编写一个程序，实现以下功能。
子进程和父进程的理解
子进程和父进程的理解
子进程和父进程是操作系统中的两个重要概念，它们之间存在着一定的关系和区别。
首先，父进程是指创建子进程的进程，子进程是由父进程创建的新进程。
父进程在创建子进程时会将自身的一些资源（如内存空间、文件描述符等）复制一份给子进程，子进程可以利用这些资源来执行自己的任务。
子进程是父进程的副本，但它们是独立的进程，有自己的进程 ID 和运行环境。
其次，子进程和父进程之间存在着一定的通信机制，可以通过共享内存、管道、信号等方式进行进程间通信。
父进程可以向子进程传递参数和数据，子进程也可以向父进程发送信号和数据。
最后，子进程和父进程在执行过程中有着不同的行为和状态。
子进程可以执行不同的程序或代码段，而父进程则可以选择等待子进程的退出或继续执行自己的任务。
当子进程执行完毕或出现异常时，父进程可以获取子进程的退出状态并进行处理。
总之，子进程和父进程是操作系统中的重要概念，理解它们之间的关系和区别对于编写高效、稳定的程序具有重要意义。
- 1 -。
操作系统测试题(附答案)
操作系统测试题（附答案）一、单选题（共IOO题，每题1分，共100分）1、一次中断后可能引起若干个进程状态的变化，因此中断处理后，由（）决定哪个进程可占用处理器。
A、进程调度B、移臂调度C、页面调度D、作业调度正确答案：A2、某系统正在执行三个进程P1、P2和P3,各进程的计算时间和I/O时间比进例如下表所示。
为提高系统资源利用率，合理的进程优先级设置应为（）o程计算时间I/O时间P190%10%P250%50%P315%85%A、P2>P1=P3B、P1>P2=P3C、P1>P2>P3D、P3>P2>P1正确答案：D3、操作系统采用分页存储管理方式，要求（）oA、每个进程拥有一张页表，且进程的页表驻留在内存中B、每个进程拥有一张页表，但只有执行进程的页表驻留在内存中C、所有进程共享一张页表，以节约有限的内存空间，但页表必须驻留在内存中D、所有进程共享一张页表，只有页表中当前使用的页面必须驻留在内存中正确答案：A4、分区管理要求为每一个作业都分配（）的主存单元。
A、若干地址不连续B、若干连续的页C、若干不连续的帧D、地址连续正确答案：D5、下列关于父进程和子进程的叙述中，正确的是（）oA、子进程执行完了，父进程才能执行B、父进程创建了子进程，因此父进程执行完了，子进程才能执行C、撤销子进程时，应该同时撤销父进程D、撤销父进程时，应该同时撤销子进程正确答案：D6、资源的按序分配策略可以破坏（）条件。
A、不剥夺B、环路等待C、互斥D、请求和保持正确答案：B7、（）用于连接大量的低速和中速I/O设备。
A、数组选择通道B、字节选择通道C、字节多路通道D、数组多路通道正确答案：C8、由磁头进行读写完成信息传送的时间是（）oA、优化时间B、查找时间C、传输时间D、等待时间正确答案：C9、wait、SignaI操作是一种（）。
A、机器指令B、低级进程通信原语C、作业控制命令D、系统调用命令正确答案：B10、建立多进程的主要目的是提高（）的利用率。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
父进程和子进程子进程是父进程的复制品Unix/linux系统中的进程创建是这样的，理解起来有点绕。
父进程先执行fork()系统调用，这个调用的结果是系统中多出了一个跟父进程内容完全一样的进程,这个新进程被称为子进程，当然该进程的PCB 中父进程指针是指向第一个进程的。
前后两个进程各自有自己的地址空间，形式上有点像把一个文件拷贝了一个副本。
虽然资源也相互独立，但拷贝时父进程执行过程已生成的数据，子进程也拷了一份。
说简单点像一个执行到半路的程序突然在系统中多出了一个孪生兄弟，什么都跟自己一样，但要管自己叫老爸。
当然这样的简单复制本身是没什么用处的。
要让它发挥作用，还需要再执行exec( B )系统调用，这个调用可以让当前进程转而执行另一个可执行代码（一个新的程序）。
简单的说进程本来在执行A程序，一旦执行到这个调用，就转而开始执行B程序。
至此，父子两进程就变的不一样了，但不管它们各自执行的什么代码，其父子关系不会改变，在父进程中可以使用子进程的进程ID（在执行fork()时的返回值中得到）来中止子进程的执行。
当然子进程也可以因为自己的执行程序结束而终止执行父进程和子进程先后执行的问题，是这样的，在fork之后，是父进程先执行，然后一个时间片到达之后就是子进程再执行了。
每一个进程都有一个父进程，当进程终止或者结束的时候，都会给父进程发送一个SIGCHLD信号，系统默认是父进程忽略这个信号，如果父进程希望被告知其子进程的这种状态改变，则应该捕获这个信号，捕捉函数一般是wait函数来取得子进程ID和子进程状态。
对于键盘上的Ctrl+按键的操作，一般是产生一个信号，然后进程捕捉这个信号。
另外当然我们可以直接使用这些信号，通过kill命令，把信号发给相应的其他进程。
wait函数是父进程等待子进程结束，也就是说当子进程结束的时候会发送给父进程一个信号SIGCHID，这时候父进程通过wait函数接收到这个信号，这时候父进程就知道子进程结束了。
这个正好用在shell解析器的编写里面，shell解析器作为父进程，而命令行命令作为子进程，当子进程结束的时候就会告诉父进程，这时候父进程就可以提示输入下一个命令了。
一个进程只能为他自己或者他的子进程设置进程组ID，在他的子进程调用了exec函数之后，就不能再改变该子进程的进程组ID了。
Linux进程管理对于电脑使用的玩家的常用软件，然后我就学习及深入的研究Linux进程管理，在这里和大家一起探讨Linux进程管理的使用方法，希望对大家有用。
程序是为了完成某种任务而设计的软件，比如OpenOffice 是程序。
什么是进程呢？进程就是运行中的程序。
一个运行着的程序，可能有多个进程。
比如 所用的WWW服务器是apache服务器，当管理员启动服务后，可能会有好多人来访问，也就是说许多用户来同时请求httpd服务，apache服务器将会创建有多个httpd进程来对其进行服务。
1、程序和进程;进程分类;进程一般分为交互进程、批处理进程和守护进程三类。
值得一提的是守护进程总是活跃的，一般是后台运行，守护进程一般是由系统在开机时通过脚本自动激活启动或超级管理用户root来启动。
比如在Fedora或Redhat中，我们可以定义httpd服务器的启动脚本的运行级别，此文件位于/etc/init.d目录下，文件名是httpd，/etc/init.d/httpd 就是httpd服务器的守护程序，当把它的运行级别设置为3和5时，当系统启动时，它会跟着启动。
[root@localhost ~]# chkconfig --level 35 httpd on由于守护进程是一直运行着的，所以它所处的状态是等待请求处理任务。
比如，我们是不是访问 ， 的httpd服务器都在运行，等待着用户来访问，也就是等待着任务处理。
1.2 进程的属性;进程ID(PID)：是唯一的数值，用来区分进程;父进程和父进程的ID(PPID);启动进程的用户ID(UID)和所归属的组(GID);进程状态：状态分为运行R、休眠S、僵尸Z;进程执行的优先级;进程所连接的终端名;进程资源占用：比如占用资源大小(内存、CPU占用量);1.3 父进程和子进程;他们的关系是管理和被管理的关系，当父进程终止时，子进程也随之而终止。
但子进程终止，父进程并不一定终止。
比如httpd服务器运行时，我们可以杀掉其子进程，父进程并不会因为子进程的终止而终止。
在Linux 进程管理中，当我们发现占用资源过多，或无法控制的进程时，应该杀死它，以保护系统的稳定安全运行;2、Linux进程管理;对于Linux进程管理，是通过Linux进程管理工具实现的，比如ps、kill、pgrep等工具;ps 监视进程工具;ps 为我们提供了进程的一次性的查看，它所提供的查看结果并不动态连续的;如果想对进程时间监控，应该用top工具;ps 的参数说明;ps 提供了很多的选项参数，常用的有以下几个;l 长格式输出;u 按用户名和启动时间的顺序来显示进程;j 用任务格式来显示进程;f 用树形格式来显示进程;a 显示所有用户的所有进程(包括其它用户);x 显示无控制终端的进程;r 显示运行中的进程;ww 避免详细参数被截断;我们常用的选项是组合是aux 或lax，还有参数f的应用;ps aux 或lax 输出的解释;USER 进程的属主;PID进程的ID;PPID 父进程;%CPU 进程占用的CPU百分比;%MEM 占用内存的百分比;NI 进程的NICE值，数值大，表示较少占用CPU时间; VSZ 进程虚拟大小;RSS 驻留中页的数量;WCHANTTY 终端IDSTAT 进程状态D Uninterruptible sleep (usually IO)R 正在运行可中在队列中可过行的;S 处于休眠状态;T 停止或被追踪;W 进入内存交换(从内核2.6开始无效); X 死掉的进程(从来没见过);Z 僵尸进程;< 优先级高的进程N 优先级较低的进程L 有些页被锁进内存;s 进程的领导者(在它之下有子进程);l is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)+ 位于后台的进程组;WCHAN 正在等待的进程资源;START 启动进程的时间;TIME 进程消耗CPU的时间;COMMAND 命令的名称和参数;2.1.2 ps 应用举例;实例一：ps aux 最常用[root@localhost ~]# ps -aux |more可以用| 管道和more 连接起来分页查看;[root@localhost ~]# ps -aux >N 优先级较低的进程L 有些页被锁进内存;s 进程的领导者(在它之下有子进程);l is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)+ 位于后台的进程组;WCHAN 正在等待的进程资源;START 启动进程的时间;TIME 进程消耗CPU的时间;COMMAND 命令的名称和参数;2.1.2 ps 应用举例;实例一：ps aux 最常用[root@localhost ~]# ps -aux |more可以用| 管道和more 连接起来分页查看;[root@localhost ~]# ps -aux >ps001.txt[root@localhost ~]# more ps001.txt这里是把所有进程显示出来，并输出到ps001.txt文件，然后再通过more 来分页查看;实例二：和grep 结合，提取指定程序的进程;[root@localhost ~]# ps aux |grep httpdroot 4187 0.0 1.3 24236 10272 ? Ss 11:55 0:00 /usr/sbin/httpd apache 4189 0.0 0.6 24368 4940 ? S 11:55 0:00 /usr/sbin/httpd apache 4190 0.0 0.6 24368 4932 ? S 11:55 0:00 /usr/sbin/httpd apache 4191 0.0 0.6 24368 4932 ? S 11:55 0:00 /usr/sbin/httpd apache 4192 0.0 0.6 24368 4932 ? S 11:55 0:00 /usr/sbin/httpd apache 4193 0.0 0.6 24368 4932 ? S 11:55 0:00 /usr/sbin/httpd apache 4194 0.0 0.6 24368 4932 ? S 11:55 0:00 /usr/sbin/httpd apache 4195 0.0 0.6 24368 4932 ? S 11:55 0:00 /usr/sbin/httpd apache 4196 0.0 0.6 24368 4932 ? S 11:55 0:00 /usr/sbin/httpd root 4480 0.0 0.0 5160 708 pts/3 R+ 12:20 0:00 grep httpd实例二：父进和子进程的关系友好判断的例子[root@localhost ~]# ps auxf |grep httpdroot 4484 0.0 0.0 5160 704 pts/3 S+ 12:21 0:00 \_ grep httpdroot 4187 0.0 1.3 24236 10272 ? Ss 11:55 0:00 /usr/sbin/httpd apache 4189 0.0 0.6 24368 4940 ? S 11:55 0:00 \_ /usr/sbin/httpdapache 4190 0.0 0.6 24368 4932 ? S 11:55 0:00 \_ /usr/sbin/httpd apache 4191 0.0 0.6 24368 4932 ? S 11:55 0:00 \_ /usr/sbin/httpd apache 4192 0.0 0.6 24368 4932 ? S 11:55 0:00 \_ /usr/sbin/httpd apache 4193 0.0 0.6 24368 4932 ? S 11:55 0:00 \_ /usr/sbin/httpd apache 4194 0.0 0.6 24368 4932 ? S 11:55 0:00 \_ /usr/sbin/httpdapache 4195 0.0 0.6 24368 4932 ? S 11:55 0:00 \_ /usr/sbin/httpdapache 4196 0.0 0.6 24368 4932 ? S 11:55 0:00 \_ /usr/sbin/httpd这里用到了f参数;父与子关系一目了然;2.2 pgreppgrep 是通过程序的名字来查询进程的工具，一般是用来判断程序是否正在运行。