linux进程存在

㈠ linux进程的几种状态

Linux中进程分类

①交互进程：由一个shell启动的进程，交互进程既可以在前台运行，也可以在后台运行。

②批处理进程：这种进程和终端没有联系，是一个进程序列。

③监控进程：也称守护进程，是一个在后台运行且不受任何终端控制的特殊进程，用于执行特定的系统任务。

进程的状态

①可运行状态：此时进程正在运行或者正在运行队列中等待准备运行。

②等待状态：此时进程在等待一个事件的发生或某种系统资源。在Linux系统中等待状态又细分为两种等待状态：可中断的等待状态和不可中断的等待状态。

③暂停状态：处于暂停状态的进程被暂停运行。

④僵死状态：每个进程在运行结束后都会处于僵死状态，等待父进程调用进而释放系统资源，处于该状态的进程已经运行结束，但是它的父进程还没有释放其系统资源。

㈡ linux shell 判断进程是否存在

如果你是通过一个进程的名字作为关键词来查找进程是否存在的话，可使用
ps
-ef
|
grep
"<关键词>"
|
wc
-l
输出为0表示不存在，输出大于0，表示存在，且数字就是这个关键词进程的个数；
如果你是通过进程号PID来查找进程是否存在，可以使用
ps
--no-heading
|
wc
-l
同样，
输出为0表示不存在，输出=1，表示存在，因为进程号不可能重复，所以输出肯定非0即1

㈢ Linux启动一个进程的过程

Linux 中的每个进程都存在于“进程树”中。你可以通过运行 pstree 命令查看进程树。树的根是 init，进程号是 1。每个进程（init 除外）都有一个父进程，一个进程都可以有很多子进程。

所以，假设我要启动一个名为 ls 的进程来列出一个目录。我是不是只要发起一个进程 ls 就好了呢？不是的。

我要做的是，创建一个子进程，这个子进程是我（me）本身的一个克隆，然后这个子进程的“脑子”被吃掉了，变成 ls。

开始是这样的：

然后运行 fork()，生成一个子进程，是我（me）自己的一份克隆：

然后我让该子进程运行 exec("ls")，变成这样：

当 ls 命令结束后，我几乎又变回了我自己：

在这时 ls 其实是一个僵尸进程。这意味着它已经死了，但它还在等我，以防我需要检查它的返回值（使用 wait 系统调用）。一旦我获得了它的返回值，我将再次恢复独自一人的状态。

上文提到的“脑子被吃掉”是什么意思呢？
进程有很多属性：

当你运行 execve 并让另一个程序吃掉你的脑子的时候，实际上几乎所有东西都是相同的！ 你们有相同的环境变量、信号处理程序和打开的文件等等。

唯一改变的是，内存、寄存器以及正在运行的程序，这可是件大事。

为何 fork 并非那么耗费资源（写入时复制）
你可能会问：“如果我有一个使用了 2GB 内存的进程，这是否意味着每次我启动一个子进程，所有 2 GB 的内存都要被复制一次？这听起来要耗费很多资源！”

事实上，Linux 为 fork() 调用实现了写时复制 on write，对于新进程的 2GB 内存来说，就像是“看看旧的进程就好了，是一样的！”。然后，当如果任一进程试图写入内存，此时系统才真正地复制一个内存的副本给该进程。如果两个进程的内存是相同的，就不需要复制了

当子进程终结时，它会通知父进程，并清空自己所占据的内存，并在内核里留下自己的退出信息(exit code，如果顺利运行，为0；如果有错误或异常状况，为>0的整数)。在这个信息里，会解释该进程为什么退出。父进程在得知子进程终结时，有责任对该子进程使用wait系统调用。这个wait函数能从内核中取出子进程的退出信息，并清空该信息在内核中所占据的空间。但是，如果父进程早于子进程终结，子进程就会成为一个孤儿(orphand)进程。孤儿进程会被过继给init进程，init进程也就成了该进程的父进程。init进程负责该子进程终结时调用wait函数。

当然，一个糟糕的程序也完全可能造成子进程的退出信息滞留在内核中的状况（父进程不对子进程调用wait函数），这样的情况下，子进程成为僵尸（zombie）进程。当大量僵尸进程积累时，内存空间会被挤占。

㈣ 22. Linux的进程管理

1.1 在Linux中，每个执行的程序都称为一个进程，每一个进程都分配一个ID号（pid，进程号）。

1.2 每个进程都可能以两种方式存在，前台和后台。

1.2.1 前台进程：用户目前的屏幕上可以进行操作的，占据了屏幕的进程，例如vim

1.2.2 后台进程：实际上在镇孙操作，但屏幕上无法看到的进程，例如mysql服务、ssh等

1.3 一般来说，系统服务都是以后台方式存在，且常驻系统，直到关机才结束。

ps命令用来查看目前系统中，有哪些正在执行，以及它们执行的情况。可以不加任何参数。

PID：进程识别号

TTY：终端机号

TIME：此进程所消耗的CPU时间

CMD：正在执行御和链的命令或进程名

ps -a 显示当前终端的所有进程信息

ps -u 以用户的格式显示进程信息

ps -x 显示后台进程运行的参数

USER：进程执行用户

PID：进程号

%CPU：占用CPU的百分比

%MEM：占用物理内存的百分比

VSZ：占用虚拟内存的大小，单位KB

RSS：占用物理内存的大小，单位KB

TTY：终端

STAT：当前运行状态

    S（大写）表示休眠，即sleep

    R（大写）表示正在运行

    D（大写）表示短期等待

    Z（大写）表示僵死进程

START：进程执行的开始时间

TIME：这个进程占用CPU的时间

COMMAND：进程的名字，也可以理解为执行该进程的指令

ps -ef 可以以全格式显示当前所有进程

-e显示所有进程

-f以全格式显示，如下面两幅图所示。

可以看到，/usr/sbin/sshd的进程号为7092，其父进程为1号进程，1号进程是systemd进程，而systemd进程的父进程为0号，也就是没有父进程。即，系统启动后的第一个进程就是systemd进程，systemd进程会启动sshd进程。

再仔细看，sshd: root@pts/1是xshell登陆root用户后的进程，进程号为7183，父进程为7092，也即sshd进程。继续用其他用户远程登陆linux，就会增加7092进程的子进程。

当某个进程执行过程中需要停止，或者已经消耗了太多的系统资源时，可以考虑停止这个进程，使用kill命令。

kill [选项] 进程号

killall 进程名称 这个命令通过进程名称杀死进程，支持通配符，当系统因负载过大而很慢时，这个指令就很有用了。假如abc进程有3个子进程，killall abc就会把abc停止，并且停止其所有3个子进程。

常用选项，

    -9 强迫进程立即停止

示例，

4.1 踢掉某个用户

ps -aux | grep sshd

kill 17204 （因为在我这里查到，17204是该用户ssh登陆linux的进程）

4.2 终止远程登陆服务sshd，在适当时候再次重启sshd服务

kill sshd对棚兄应的进程号PID

/bin/systemctl start sshd.service

4.3 终止多个gedit，演示killall

比如用gedit打开多个文本文件，然后进程中会出现gedit

killall gedit就会杀掉gedit进程，同时看到文本文档编辑页面被关掉了。

4.4 强制杀掉一个终端

kill -9 10487 强制杀掉10487进程（比如terminal这样的进程，如果不加-9是不可以杀掉的）

pstree [选项] 这条指令可以更加直观的查看进程信息

常用选项，

-p 显示进程的PID

-u 显示进程的所属用户

示例，

5.1 以树状的形式显示进程的PID

pstree -p

5.2 以树状的形式显示进程的用户id

pstree -u

㈤ linux进程内存相关

3种地址：虚拟地址、物理地址、逻辑地址
物理宽坦地址：内存的电路地址，对应内存地址线上的高低电平，物理可见的。
虚拟地址： 分页机制 的产物，也叫线性地址，是进程能看见的地址。
逻辑地址： 分段机制 的产物，属于inter cpu的历史遗留问判巧李题，linux可以当做不存在。
3种地址的转换：进程访问逻辑地址，linux内核根据分段机制装换成虚拟地址，然后把进程的页表和虚拟地址都告诉cpu，cpu就可以根据分页机制将虚拟地址装换成物理地址，然后访问内存。
linux内核中巧妙地屏蔽里分段机制，就是逻辑地址等于虚拟地址，访问内存只需要利用分页机制把虚拟地址转换成物理地址。

linux会为每个进程创建自己的虚拟地址空间，就是进程地址空间，64位系统就是128T的内存空间。需要注意的是，虚拟地址就是假的，一开始不和物理地址对应，也就是说不占用物理内存，只有当虚拟地址有写入操作是，内核会触发缺页，分配真实的物理地址给虚拟地址。物理地址的管理可参考 内核内存管理

从进程空间看，用户态闲置内存有3块，Stack、Memory Mapping Region、Heap，Stack是程序函数调用运行时需要的，不可控，能自由分配的内存就剩Memory Mapping Region、Heap了，linux系统提供的内存分配函数就是针对这两个区域的。
Heap操作函数：int brk(void *addr)、void *sbrk(intptr_t increment)
Memory Mapping Region操作函数：mmap()、munmap()

当然进程可以直接使用系统调用去申请内存，但是如果不管理的话，经过大量的申请和释放，会把进程空间切割的乱七八糟，导致不能申请大块的连续空间，为此就出现了内存管理模块，封装了系统调用，对进程提供malloc和free等高级函数。实际上，除了一些特殊程序，我们也很少用系统调用，一般都是使用内存管理模块提供的malloc和free，关系如下图：

内存管理模块用各种好处，例如不会每次操作都去执行系统调用，减少内存碎片的产生等等。
当然也有很多实现方式，例如常用的glibc的Ptmalloc，google的tcmalloc，facebook的jemalloc等。各有各的应用场景，blablabla....
使用时，gcc默认会链接glibc的，如果想使用其他lib，gcc链接时指定就能覆掘迟盖掉glibc的。

我们重点讲Ptmalloc，从而启发程序员在写程序时多考虑下内存分配情况，可以选择或自己实现适合自己程序的内存管理lib。
Ptmalloc的历史发展，blablabla......，Ptmalloc采取内存池管理，进程malloc时，通过brk（小于128K的内存）、mmap（大内存）从系统获取地址空间，给进程使用，进程free时，不会立即通过brk、munmap将地址空间还给系统，会自己维护起来，叫做空闲内存，这些空闲内存在进程再次malloc时，还会被分出去，并且空闲内存会在特定条件下合并起来还给系统。

内存分配区，管理了一片内存，对外分发和回收，可以理解为一个内存池，分main arena和non main arena。
main arena：最早的分配区，管理着所有可分配的内存，通过brk，mmap等系统调用向系统申请内存。注意只有main arena可以操作Heap。
non main arena：由于多线程的出现，如果多有线程都操作main arena就会有竞争，需要加锁控制，所以出现了non main arena，通过mmap向main arena申请一大块内存，然后自己管理，可以理解为内存分销商。
只有主线程在main arena上申请内存，子线程在non main arena上，non main arena的个数是有上限的，所以non main arena允许多个子线程共用，这样就涉及到加锁，所以程序涉及应避免子线程个数太多。

进程申请到的一块内存叫做一个内存片，arena内部使用chunk数据结构来描述内存片，包括进程正在使用的内存片，和进程free掉的空闲内存片

A：是否main arena内存
M：使用mmap内存
P：上一块是否被使用
size of previous chunk：上一块没有被使用时，表示上块长度，被使用时是上块用来存User data的。
Size of chunk：就是下一块的size of previous chunk，释放时填上本块长度，供下块合并用。

分给进程的内存片arena可以不管，但是进程free回来的，arena需要通过一定方式组织起来，方便进程再次使用。组织方式有下面几种：

bins是个数组，包含128个bin，每个bin是个链表，分small bin和large bin两种，各64个，small bin中chunk大小固定，两个相邻的small bin中的chunk大小相差8bytes，large bin中chunk大小是一定范围内的，其中的chunk按大小排列。
空闲chunk按大小选择合适的bin，按新旧顺序挂到链表上，优先分配旧的chunk。

不大于max_fast （默认值为64B）的chunk被释放后，首先会被放到fast bins 中，fast bins中的chunk并不改变它的使用标志P。这样也就无法将它们合并，当需要给用户分配的chunk小于或等于max_fast时，ptmalloc首先会在fast bins中查找相应的空闲块。在特定的时候，ptmalloc会遍历fast bins中的chunk，将相邻的空闲chunk进行合并，并将合并后的chunk加入unsorted bin中。

进行malloc时，如果在fast bins中没有找到合适的chunk，则ptmalloc会先在unsorted bin中查找合适的空闲chunk，如果unsorted bin不能满足分配要求。malloc便会将unsorted bin中的chunk加入bins中。然后再从bins中继续进行查找和分配过程。从这个过程可以看出来，unsorted bin可以看做是bins的一个缓冲区，增加它只是为了加快分配的速度。

前面的bin中都是回收回来的内存，top chunk才是内存的初始来源，每个arena都有一个top chunk，用来管理Heap的，Heap会在arena第一次分配内存时初始化，会分配一块(chunk_size + 128K) align 4K的空间（132K）作为初始的Heap，top chunk占据整个空间，每次分配会在低地址出切出一片，如下图：

回收时，只有和top chunk相连的内存才能和top chunk合并，才能进而还给系统。

子线程Heap：在main arena中mmap出64M的空间，叫做sub-heap，再在sub-heap上初始化Heap。
主线程的Heap才是真Heap，使用进程Heap，使用brk申请内存。

子线程的heap不够用时，会在申请新的sub-heap，和老的sub-heap单向链表连起来，top chunk会搬到新sub-heap上。

描述mmap出来的内存，单独管理，free时按阈值来决定是否munmap，有动态调整阈值功能，防止太频繁的mmap和munmap。本文不关注。

即最后一次small request中因分割而得到的剩余部分，它有利于改进引用局部性，也即后续对 small chunk 的 malloc 请求可能最终被分配得彼此靠近。
当用户请求 small chunk而无法从small bin和unsorted bin得到时，会在large bin中找最合适的chunk，然后做切割，返回给用户的User chunk，剩下的是Remainder chunk添加到unsorted bin中。这一Remainder chunk就将成为last remainder chunk。

下一块为高地址，前一块为低地址。

Glibc内存管理 华庭（庄明强）

㈥ “图文结合”Linux 进程、线程、文件描述符的底层原理

开发十年经验总结，阿里架构师的手写Spring boot原理实践文档

阿里架构师的这份：Redis核心原理与应用实践，带你手撕Redis

Tomcat结构原理详解

说到进程，恐怕面试中最常见的问题就是线程和进程的关系了，那么先说一下答案： 在 Linux 系统中启瞎，进程和线程几乎没有区别 。

Linux 中的进程其实就是一个数据结构，顺带可以理解文件描述符、重定向、管道命令的底层工作原理，最后我们从操作系统的角度看看为什么说线程和进程基本没有区别。

首先，抽象地来说，我们的计算机就是这个东西：

这个大的矩形表示计算机的 内存空间 ，其中的小矩形代表 进程 ，左下角的圆形表示 磁盘 ，右下角的图形表示一些 输入输出设备 ，比如鼠标键盘显示器等等。另外，注意到内存空间被划分为了两块，上半部分表示 用户空间 ，下半部分表示 内核空间 。

用户空间装着用户进程需要使用的资源，比如你在程序代码里开一个数迅盯组，这个数组肯定存在用户空间；内核空间存放内核进程需要加载的系统资源，这一些资源一般是不允许用户访问的。但是注意有的用户进程会共享一些内核空间的资源，比如一些动态链接库等等。

我们用 C 语言写一个 hello 程序，编译后得到一个可执行文件，在命令行运行就可以打印出一句 hello world，然后程序退出。在操作系统层面，就是新建了一个进程，这个进程将我们编译出来的可执行文件读入内存空间，然后执行，最后退出。

你编译好的那个可执行程序只是一个文件，不是进程，可执行文件必须要载入内存，包装成一个进程才能真正跑起来。进程是要依靠操作系统创建的，每个进程都有它的固有属性，比如进程号（PID）、进程状态、打开的文件等等，进程创建好之后，读入你的程序，你的程序才被系统执行。

那么，操作系统是如何创建进程的呢？ 对于操作系统，进程就是一个数据结构 ，我们直接来看 Linux 的源码：

task_struct 就是 Linux 内核对于一个进程的描述，也可以称为“进程描述符”。源码比较复杂，我这里就截取了一小部分比较常见的。

我们主要聊聊 mm 指针和 files 指针。 mm 指向的是进程的虚拟内存，也就是载入资源和可执行文件的地方； files 指针指向一个数组，这个数组里装着所有该进程打开的文件的指针。

先说 files ，它是一个文件指针数组。一般来说，一个进程会从 files[0] 读取输入，将输出写入 files[1] ，将错误信息写入 files[2] 。

举个例子，以我们的角度 C 语言的 printf 函数是向命令行打印字符，但是从进程的角度来看，就是向 files[1] 写入数据；同理， scanf 函数就是进程试图从 files[0] 这个文件中读取数据。

每个进程被创建时， files 的前三位被填入默认值，分别指向标准输入流、标准输出流、标准错误流。我们常悄昌空说的“文件描述符”就是指这个文件指针数组的索引 ，所以程序的文件描述符默认情况下 0 是输入，1 是输出，2 是错误。

我们可以重新画一幅图：

对于一般的计算机，输入流是键盘，输出流是显示器，错误流也是显示器，所以现在这个进程和内核连了三根线。因为硬件都是由内核管理的，我们的进程需要通过“系统调用”让内核进程访问硬件资源。

PS：不要忘了，Linux 中一切都被抽象成文件，设备也是文件，可以进行读和写。

如果我们写的程序需要其他资源，比如打开一个文件进行读写，这也很简单，进行系统调用，让内核把文件打开，这个文件就会被放到 files 的第 4 个位置，对应文件描述符 3：

明白了这个原理， 输入重定向 就很好理解了，程序想读取数据的时候就会去 files[0] 读取，所以我们只要把 files[0] 指向一个文件，那么程序就会从这个文件中读取数据，而不是从键盘：

同理， 输出重定向 就是把 files[1] 指向一个文件，那么程序的输出就不会写入到显示器，而是写入到这个文件中：

错误重定向也是一样的，就不再赘述。

管道符其实也是异曲同工，把一个进程的输出流和另一个进程的输入流接起一条“管道”，数据就在其中传递，不得不说这种设计思想真的很巧妙：

到这里，你可能也看出“Linux 中一切皆文件”设计思路的高明了，不管是设备、另一个进程、socket 套接字还是真正的文件，全部都可以读写，统一装进一个简单的 files 数组，进程通过简单的文件描述符访问相应资源，具体细节交于操作系统，有效解耦，优美高效。

首先要明确的是，多进程和多线程都是并发，都可以提高处理器的利用效率，所以现在的关键是，多线程和多进程有啥区别。

为什么说 Linux 中线程和进程基本没有区别呢，因为从 Linux 内核的角度来看，并没有把线程和进程区别对待。

我们知道系统调用 fork() 可以新建一个子进程，函数 pthread() 可以新建一个线程。 但无论线程还是进程，都是用 task_struct 结构表示的，唯一的区别就是共享的数据区域不同 。

换句话说，线程看起来跟进程没有区别，只是线程的某些数据区域和其父进程是共享的，而子进程是拷贝副本，而不是共享。就比如说， mm 结构和 files 结构在线程中都是共享的，我画两张图你就明白了：

所以说，我们的多线程程序要利用锁机制，避免多个线程同时往同一区域写入数据，否则可能造成数据错乱。

那么你可能问， 既然进程和线程差不多，而且多进程数据不共享，即不存在数据错乱的问题，为什么多线程的使用比多进程普遍得多呢 ？

因为现实中数据共享的并发更普遍呀，比如十个人同时从一个账户取十元，我们希望的是这个共享账户的余额正确减少一百元，而不是希望每人获得一个账户的拷贝，每个拷贝账户减少十元。

当然，必须要说明的是， 只有 Linux 系统将线程看做共享数据的进程 ，不对其做特殊看待 ，其他的很多操作系统是对线程和进程区别对待的，线程有其特有的数据结构，我个人认为不如 Linux 的这种设计简洁，增加了系统的复杂度。

在 Linux 中新建线程和进程的效率都是很高的，对于新建进程时内存区域拷贝的问题，Linux 采用了 -on-write 的策略优化，也就是并不真正复制父进程的内存空间，而是等到需要写操作时才去复制。 所以 Linux 中新建进程和新建线程都是很迅速的 。

㈦ linux查看某个进程是否存在

使用 ps 命令，比如：
ps -au 看的是所有用户进程
ps -aux 会看到所有的后台进程，包括一些系统的进程，就很多了
如果你只想找到某个指定进程
ps -ef | grep python 就会看到所有跟python有关的进程，其它进程，你换个名字就好了，
搜到有，那这个进程就存在，没有也有搜索不到

㈧ Linux进程详解

ps是Linux 中最基础的浏览系统中的进程的命令。能列出系统中运行的进程，包括进程号、命令、CPU使用量、内存使用量等。接下来解读一下Linux操作系统的进程和Windows“Ctrl+Alt+delete”直接的差异。

在进行了解进程命令之前需要知道进程的一些状态

ps工具标识进程的5种状态码:

Linux操作系统进程执行的状态转换图如图所示:

下面来看一下 ps命令
ps --help命令可以查看ps命令的使用说明

或者使用 man ps命令 查询ps的详细说明

在 man手册 关于ps的解读中，总结了一下几个参数的含义：

以上的参数是可以拼接使用的，那就了解一些常用的参数组合
ps aux命令

ps -ef命令

查看进程状态这两个是命令是最常用的，使用 ps aux 可以查看进程的详细运行状态等。使用 ps -ef 不仅可以显示自身的PID，也可以显示PPID(父进程)。但是显示不了进程的运行状态

top命令
top命令是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，类似于Windows的任务管理器

man手册关于top的解释

关闭进程，重启进程
在上一片文章中 linux的目录结构 里面说过，在目录/etc/init.d/目录下包含许多系统各种服务的启动和停止脚本。假设进程占用内存较大或者进程异常，我们是重启这个进程restart。如下图所示：

我们重启了mysqld这个进程，可以看出进程号已经改变(从15743到15964)，说明进程已经重启。

Linux下有3个特殊的进程，idle进程(PID=0), init进程(PID=1)和kthreadd(PID=2)

我们来看一下进程状态[下面是删减版,进程数量太多，列举一部分]

可以看到很多进程的PPID号是1和2。也就是init进程和kthreadd进程。

在使用Windows系统的过程中，都碰到过应用程序卡死的情况。应对此问题，我们一般都是等待失去响应的程序恢复，或者是直接使用任务管理器将其强制关闭，然后再重新打开。

在Linux中,遇到特别耗费资源的进程，当然需要使用 top命令 查看进程占用率高的进程。或者使用 free -m命令 查看内存剩余。假设需要强杀进程来释放空间。我们涉及到Linux中信号📶的知识，在这里简单的描述一下，信号的详解会在接下来的文章里面叙述。
free -m命令查看内存空间

在linux中存在着64种信号
使用 kill -l命令 查看信号列表

在前面说过进程会被这些个信号> (进程收到SIGSTOP, SIGSTP, SIGTIN, SIGTOU信号强制停止运行) 那问题就在于如何发信号给这些个进程。
使用kill命令发信号

我们从上面可以看到 mysqld进程被重启了 。

关于Linux的这一块进程的知识还有很多，后面的文章跟大家分享僵尸进程，孤儿进程等等知识，以及守护进程(daemon进程).

㈨ linux什么是进程

您好，方法
linux是一个多用户多任务的操作系统，多用户是指多个用户可以在同一个时间用计算机，多任务是指linux可以同时执行那个多个任务，它可以在还未执行完一个任务时又执行另一个任务。
每当运行一个任务时，系统就会启动一个进程，进程是一个程序在其自身的虚拟地址空间中的一次执行活动，之所以要创建进程，就是为了使多个程序可以并发的执行。从而提高系统的资源利用率和吞吐量。
程序只是一个静态的指令集合，儿进程是一个程序的动态执行过程，它具有生命期，是动态的产生和消亡的。
方法2
1、进程是资源申请，调度和独立运行的单位，它使用系统中的运行资源，而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，它不占用系统的运行资源，
2、进程和程序无意义对应的关系，一方面一个程序可以由多个进程公用，即一个程序在运行过程中可以产生多个进程，另一个方面，一个进程在生命期内可以顺序的执行若干个程序。
3、在linux系统中总是又很多的进程同时运行，系统根据进程号pid区分不同的进程，系统启动后的第一个进程是init，它的pid是1，init是唯一一个由系统内核直接运行的进程。
4、新的进程可以用系统调用fork（）来产生，就是从一个已经存在的旧进程中分出一个新进程来，旧进程就是新进程的父进程。

㈩ linux怎么判断一个进程是否存在

pidof + 进程名
如果进程存在，就会打印出该进程的pid。