锐客网

  1. 首页 > it技术 > >

linux进程

一、进程和线程的概念
1.进程和线程的定义
进程并不只是一段可以运行的代码，也包含了运行代码所需要的资源。
在操作系统来看，进程是资源管理的最小单元，而我们又知道，线程是程序执行的最小单元。
话说回来，Linux系统至少有一个进程，一个程序可以对应多个进程，一个进程只能对应一个程序，一个进程包含一个或多个线程。
所以，一个进程的组成实体实际是两大部分：资源的集合和线程的集合。进程中的线程是动态的对象, 代表了进程指令的执行。资源，包括地址空间、打开的文件、用户信息等等，由进程内的线程共享。线程有自己的私有数据：程序计数器，栈空间以及寄存器。
总结来说，在linux系统下，进程主要具有以下四个要素：
1）有一个程序供其运行。这段程序不一定是进程所专有，可以与其他进程一起使用；
2）有起码的“私有财产”，这就是进程专用的系统堆栈空间；
3）有“身份证”，也就是task_struct结构，也称之为“进程控制块”（PCB）。有了这个数据结构，进程才能成为内核调度的一个基本单位接受内核的调度。同时，这个结构又是进程的“财产登记卡”，记录着进程占用的各项资源。
4）有独立的存储空间，意味着拥有专有的用户空间；还意味着除前述的系统空间堆栈外还有其专有的用户空间堆栈。（PS：进程的系统空间是不能独立的，除了各进程独有的系统堆栈空间外，任何进程都不可能直接改变用户空间的内容）。
以上条件是必要条件，缺少其中一条，都不能称其为“进程”。如果只缺第四条，那就称为“线程”。
在linux系统中，“进程”和“任务”是同一个意思，在内核的代码中常混用这两个名词和概念。例如每个进程都要有一个task_struct数据结构，而其号码却又是pid、唤醒一个睡眠进程的函数名为wake_up_process()。
之所以有这样的情况是因为，linux源自Unix和i386系统结构，而unix中的进程在Intel的技术资料中称为“任务”，严格来说有点区别，但是对于系统的实现来说是一回事。
2.task_struct的定义
操作系统通过一个称作PCB(Process Control Block，进程控制块)的数据结构管理一个进程，也称为tesk_struct结构体，这个结构体包含了一个进程所需的所有信息。它定义在linux-2.6.38.8/include/linux/sched.h文件中。
除了最起码的“财产”，即task_struct数据结构和系统堆栈之外，一个进程还要有一些附加的资源。例如，进程拥有堵路的存储空间，就要有用于虚拟内存管理的mm_struct数据结构以及附属的vm_area数据结构，以及相应的页面目录项和页面表，
但这些都从属于task_struct资源。task_struct数据结构在这方面相当于登记卡的作用，其具体结构源代码如下：
struct task_struct
{
/** offsets of these are hardcoded elsewhere - touch with care
*/volatilelongstate; /* -1 unrunnable, 0 runnable, >0 stopped */unsigned longflags; /* per process flags, defined below */int sigpending;
mm_segment_t addr_limit; /* thread address space:
0-0xBFFFFFFF for user-thead
0-0xFFFFFFFF for kernel-thread
*/structexec_domain *exec_domain;
volatilelong need_resched;
unsigned long ptrace;
intlock_depth; /* Lock depth *//** offset 32 begins here on 32-bit platforms. We keep
* all fields in a single cacheline that are needed for
* the goodness() loop in schedule().
*/long counter;
long nice;
unsigned long policy;
structmm_struct *mm;
int has_cpu, processor;
unsigned long cpus_allowed;


struct list_head run_list;
unsigned long sleep_time;


structtask_struct *next_task, *prev_task;
structmm_struct *active_mm;
/* task state */structlinux_binfmt *binfmt;
int exit_code, exit_signal;
intpdeath_signal; /*The signal sent when the parent dies*/
unsigned long personality;
intdumpable:1;
intdid_exec:1;
pid_t pid;
pid_t pgrp;
pid_t tty_old_pgrp;
pid_t session;
pid_t tgid;
/* boolean value for session group leader */int leader;
/** pointers to (original) parent process, youngest child, younger sibling,
* older sibling, respectively.(p->father can be replaced with
* p->p_pptr->pid)
*/structtask_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
struct list_head thread_group;
/* PID hash table linkage. */structtask_struct *pidhash_next;
structtask_struct **pidhash_pprev;
wait_queue_head_t wait_chldexit; /* for wait4() */structsemaphore *vfork_sem; /* for vfork() */unsigned long rt_priority;
unsigned long it_real_value, it_prof_value, it_virt_value;
unsigned long it_real_incr, it_prof_incr, it_virt_incr;
struct timer_list real_timer;
struct tms times;
unsigned long start_time;
long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS];
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
intswappable:1;
/* process credentials */uid_t uid,euid,suid,fsuid;
gid_t gid,egid,sgid,fsgid;
int ngroups;
gid_t groups[NGROUPS];
kernel_cap_tcap_effective, cap_inheritable, cap_permitted;
intkeep_capabilities:1;
structuser_struct *user;
/* limits */struct rlimit rlim[RLIM_NLIMITS];
unsigned short used_math;
charcomm[16];
/* file system info */int link_count;
structtty_struct *tty; /* NULL if no tty */unsigned intlocks; /* How many file locks are being held *//* ipc stuff */structsem_undo *semundo;
structsem_queue *semsleeping;
/* CPU-specific state of this task */struct thread_struct thread;
/* filesystem information */structfs_struct *fs;
/* open file information */structfiles_struct *files;
/* signal handlers */spinlock_t sigmask_lock; /* Protects signal and blocked */structsignal_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;
};
下面对结构中几个重要的成分做介绍：
1）state（第6行）
该变量表示进程当前运行的状态，具体定义如下：
1#define TASK_RUNNING02#define TASK_INTERRUPTIBLE13#define TASK_UNINTERRUPTIBLE24#define TASK_ZOMBIE4//僵尸进程5#define TASK_STOPPED8
状态TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE均表示进程处于睡眠状态。但是TASK_UNINTERRUPTIBLE表示进程处于“深度睡眠”，而不受“信号”（signal，也称软中断）的打扰，而TASK_INTERRUPTIBLE则可以因信号的到来而被唤醒。内核中提供了不同的函数，让一个进程进入不同深度的睡眠或将进程从睡眠中唤醒。具体地说，函数sleep_on()和wake_up()用于深度睡眠，而interruptible_sleep_on()和wake_up_interruptible()则用于浅度睡眠。深度睡眠一般只用于临界区和关键性的部位，而“可中断”的睡眠那就是通用的了。特别地，当进程在“阻塞性”的系统调用中等待某一事件发生时，应该进入可中断睡眠，否则就不能对别的中断做出反应，别的进程就不能通过发一个信号来“杀掉”这个进程了。
TASK_RUNNING状态并不是表示一个进程正在执行中，或者说这个进程就是“当前进程”，而是表示这个进程可以被调度执行而成为当前进程。当进程处于这样的可执行（或就绪）状态时，内核就将该进程的task_struct结构通过其队列头（见第30行）挂入一个“运行队列”。
TASK_ZOMBIE状态表示进程已经“去世”而户口尚未注销。
TASK_STOPPED主要用于调试的目的，进程接收到 一个SIGSTOP信号后就将运行状态改成TASK_STOPPED而进入“挂起”状态，然后在接收到SIGCONT信号时又恢复继续运行。
2）flags（第7行）
flags反应进程状态相关信息，但并不是运行状态，而是与管理有关的其他信息。


1#define PF_ALIGNWARN0x00000001/*print alignment warning msgs*/
2#define PF_STARTING0x00000002/*being created*/
3#define PF_EXITING0x00000004/*getting shut down*/
4#define PF_FORKNOEXEC0x00000040/*forked but did not exec*/
5#define PF_SUPERPRIV0x00000100/*uses super-user privileges*/
6#define PF_DUMPCORE0x00000200/*dumped core*/
7#define PF_SIGNALED0x00000400/*killed by signal*/
8#define PF_MEMALLOC0x00000800/*Allocating memory*/
9#define PF_VFORK0x00001000/*wake up parent in mm_release*/
10#define PF_USEDFPU0x00100000/*task used FPU this quantum(SMP)*/
3）sigpending(第8行)
表示进程收到了“信号”但是尚未处理。
4）counter（第23行）
与进程调度有关
5）add_limit
虚拟地址空间的上限，对进程而言是其用户空间的上限，所以是0xbfff ffff; 对内核线程而言则是系统空间额的上限，所以是0xffff ffff
6)binfnt
应用程序的文件格式。
7）pgrp,session,leader
当一个用户登录时，就开始了一个进程组（session），此后创建的进程都属于这同一个session。
8）user
指向一个user_struct结构，该数据结构代表进程所属的用户。
9）rlim
这是一个结构数组，表明进程岁各种资源的使用数量所受的限制。
3.task_struct如何在linux中被管理
task_struct可以以三种方式被管理，他们分别是：树，哈希表和链表，具体如下图，其中圆代表一个个进程的task_struct。


linux进程
文章图片
二、进程的生命周期
进程是一个动态的实体，所以他是有生命的。从创建到消亡，是一个进程的整个生命周期。在这个周期中，进程可能会经历各种不同的状态。一般来说，所有进程都要经历以下的3个状态：
就绪态。指进程已经获得所有所需的其他资源，正在申请处理处理器资源，准备开始执行。这种情况下，称进程处于就绪态。
阻塞态。指进程因为需要等待所需资源而放弃处理器，或者进程本不拥有处理器，且其他资源也没有满足，从而即使得到处理器也不能开始运行。这种情况下，进程处于阻塞态。阻塞状态也称休眠状态或者等待状态。
运行态。进程得到了处理器，并不需要等待其他任何资源，正在执行的状态，称之为运行态。只有在运行态时，进程才可以使用所申请到的资源。
在Linux系统中，将各种状态进行了重新组织，由此得到了Linux进程的几个状态：
RUNNING：正在运行或者在就绪队列中等待运行的进程。也就是上面提到的运行态和就绪态进程的综合。一个进程处于RUNNING状态，并不代表他一定在被执行。由于在多任务系统中，各个就绪进程需要并发执行，所以在某个特定时刻，这些处于RUNNING状态的进程之中，只有一个能得到处理器，而其他进程必须在一个就绪队列中等待。即使是在多处理器的系统中，Linux也只能同时让一个处理器执行任务。
UNINTERRUPTABLE:不可中断阻塞状态。处于这种状态的进程正在等待队列中，当资源有效时，可由操作系统进行唤醒，否则，将一直处于等待状态。
INTERRUPTABLE：可中断阻塞状态。与不可中断阻塞状态一样，处于这种状态的进程在等待队列中，当资源有效时，可以有操作系统进行唤醒。与不可中断阻塞状态有所区别的是，处于此状态中的进程亦可被其他进程的信号唤醒。
STOPPED：挂起状态。进程被暂停，需要通过其它进程的信号才能被唤醒。导致这种状态的原因有两种。其一是受到相关信号(SIGSTOP,SIGSTP,SIGTTIN或SIGTTOU)的反应。其二是受到父进程ptrace调用的控制，而暂时将处理器交给控制进程。
ZOMBIE：僵尸状态。表示进程结束但尚未消亡的一种状态。此时进程已经结束运行并释放掉大部分资源，但尚未释放进程控制块。
linux进程
文章图片
Linux进程状态：T (TASK_STOPPED or TASK_TRACED)，暂停状态或跟踪状态。
向进程发送一个SIGSTOP信号，它就会因响应该信号而进入TASK_STOPPED状态（除非该进程本身处于TASK_UNINTERRUPTIBLE状态而不响应信号）。（SIGSTOP与SIGKILL信号一样，是非常强制的。不允许用户进程通过signal系列的系统调用重新设置对应的信号处理函数。）向进程发送一个SIGCONT信号，可以让其从TASK_STOPPED状态恢复到TASK_RUNNING状态。
当进程正在被跟踪时，它处于TASK_TRACED这个特殊的状态。“正在被跟踪”指的是进程暂停下来，等待跟踪它的进程对它进行操作。比如在gdb中对被跟踪的进程下一个断点，进程在断点处停下来的时候就处于TASK_TRACED状态。而在其他时候，被跟踪的进程还是处于前面提到的那些状态。
对于进程本身来说，TASK_STOPPED和TASK_TRACED状态很类似，都是表示进程暂停下来。 而TASK_TRACED状态相当于在TASK_STOPPED之上多了一层保护，处于TASK_TRACED状态的进程不能响应SIGCONT信号而被唤醒。只能等到调试进程通过ptrace系统调用执行PTRACE_CONT、PTRACE_DETACH等操作（通过ptrace系统调用的参数指定操作），或调试进程退出，被调试的进程才能恢复TASK_RUNNING状态。
Linux进程状态：Z (TASK_DEAD - EXIT_ZOMBIE)，退出状态，进程成为僵尸进程。
进程在退出的过程中，处于TASK_DEAD状态。
在这个退出过程中，进程占有的所有资源将被回收，除了task_struct结构（以及少数资源）以外。于是进程就只剩下task_struct这么个空壳，故称为僵尸。之所以保留task_struct，是因为task_struct里面保存了进程的退出码、以及一些统计信息。而其父进程很可能会关心这些信息。比如在shell中，$?变量就保存了最后一个退出的前台进程的退出码，而这个退出码往往被作为if语句的判断条件。当然，内核也可以将这些信息保存在别的地方，而将task_struct结构释放掉，以节省一些空间。但是使用task_struct结构更为方便，因为在内核中已经建立了从pid到task_struct查找关系，还有进程间的父子关系。释放掉task_struct，则需要建立一些新的数据结构，以便让父进程找到它的子进程的退出信息。
父进程可以通过wait系列的系统调用（如wait4、waitid）来等待某个或某些子进程的退出，并获取它的退出信息。然后wait系列的系统调用会顺便将子进程的尸体（task_struct）也释放掉。子进程在退出的过程中，内核会给其父进程发送一个信号，通知父进程来“收尸”。这个信号默认是SIGCHLD，但是在通过clone系统调用创建子进程时，可以设置这个信号。
通过下面的代码能够制造一个EXIT_ZOMBIE状态的进程：
#includevoid main() {if (fork())while(1) sleep(100);
}
编译运行，然后ps一下：
kouu@kouu-one:~/test$ ps -ax | grep a\.out
10410 pts/0S+0:00 ./a.out
10411 pts/0Z+0:00 [a.out]
10413 pts/1S+0:00 grep a.out
只要父进程不退出，这个僵尸状态的子进程就一直存在。那么如果父进程退出了呢，谁又来给子进程“收尸”？ 当进程退出的时候，会将它的所有子进程都托管给别的进程（使之成为别的进程的子进程）。托管给谁呢？可能是退出进程所在进程组的下一个进程（如果存在的话），或者是1号进程。所以每个进程、每时每刻都有父进程存在。除非它是1号进程。
1号进程，pid为1的进程，又称init进程。 linux系统启动后，第一个被创建的用户态进程就是init进程。它有两项使命： 1、执行系统初始化脚本，创建一系列的进程（它们都是init进程的子孙）； 2、在一个死循环中等待其子进程的退出事件，并调用waitid系统调用来完成“收尸”工作； init进程不会被暂停、也不会被杀死（这是由内核来保证的）。它在等待子进程退出的过程中处于TASK_INTERRUPTIBLE状态，“收尸”过程中则处于TASK_RUNNING状态。
Linux进程状态：X (TASK_DEAD - EXIT_DEAD)，退出状态，进程即将被销毁。
而进程在退出过程中也可能不会保留它的task_struct。比如这个进程是多线程程序中被detach过的进程（进程？线程？参见《linux线程浅析》）。或者父进程通过设置SIGCHLD信号的handler为SIG_IGN，显式的忽略了SIGCHLD信号。（这是posix的规定，尽管子进程的退出信号可以被设置为SIGCHLD以外的其他信号。）此时，进程将被置于EXIT_DEAD退出状态，这意味着接下来的代码立即就会将该进程彻底释放。所以EXIT_DEAD状态是非常短暂的，几乎不可能通过ps命令捕捉到。
进程的初始状态
进程是通过fork系列的系统调用（fork、clone、vfork）来创建的，内核（或内核模块）也可以通过kernel_thread函数创建内核进程。这些创建子进程的函数本质上都完成了相同的功能——将调用进程复制一份，得到子进程。（可以通过选项参数来决定各种资源是共享、还是私有。）那么既然调用进程处于TASK_RUNNING状态（否则，它若不是正在运行，又怎么进行调用？），则子进程默认也处于TASK_RUNNING状态。另外，在系统调用调用clone和内核函数kernel_thread也接受CLONE_STOPPED选项，从而将子进程的初始状态置为 TASK_STOPPED。
进程状态变迁
进程自创建以后，状态可能发生一系列的变化，直到进程退出。而尽管进程状态有好几种，但是进程状态的变迁却只有两个方向——从TASK_RUNNING状态变为非TASK_RUNNING状态、或者从非TASK_RUNNING状态变为TASK_RUNNING状态。也就是说，如果给一个TASK_INTERRUPTIBLE状态的进程发送SIGKILL信号，这个进程将先被唤醒（进入TASK_RUNNING状态），然后再响应SIGKILL信号而退出（变为TASK_DEAD状态）。并不会从TASK_INTERRUPTIBLE状态直接退出。
进程从非TASK_RUNNING状态变为TASK_RUNNING状态，是由别的进程（也可能是中断处理程序）执行唤醒操作来实现的。执行唤醒的进程设置被唤醒进程的状态为TASK_RUNNING，然后将其task_struct结构加入到某个CPU的可执行队列中。于是被唤醒的进程将有机会被调度执行。
而进程从TASK_RUNNING状态变为非TASK_RUNNING状态，则有两种途径： 1、响应信号而进入TASK_STOPED状态、或TASK_DEAD状态； 2、执行系统调用主动进入TASK_INTERRUPTIBLE状态（如nanosleep系统调用）、或TASK_DEAD状态（如exit系统调用）；或由于执行系统调用需要的资源得不到满足，而进入TASK_INTERRUPTIBLE状态或TASK_UNINTERRUPTIBLE状态（如select系统调用）。显然，这两种情况都只能发生在进程正在CPU上执行的情况下。
linux进程管理之进程创建（三）
【linux进程】在linux系统中，许多进程在诞生之初都与其父进程共同用一个存储空间。但是子进程又可以建立自己的存储空间，并与父进程“分道扬镳”，成为与父进程一样真正意义上的进程。
linux系统运行的第一个进程是在初始化阶段“捏造出来的”。而此后的线程或进程都是由一个已存在的进程像细胞分裂一样通过系统调用复制出来的，称为“fork（）”或者“clone（）”。
1.fork()
关于fork()和exec()的介绍在之前的一篇博文中做了介绍，
一个现有进程可以调用fork()函数创建一个新进程。由fork创建的新进程被称为子进程（child process）。fork函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。
子进程是父进程的副本，它将获得父进程数据空间、堆、栈等资源的副本。注意，子进程持有的是上述存储空间的“副本”，这意味着父子进程间不共享这些存储空间。
UNIX将复制父进程的地址空间内容给子进程，因此，子进程有了独立的地址空间。在不同的UNIX (Like)系统下，我们无法确定fork之后是子进程先运行还是父进程先运行，这依赖于系统的实现。所以在移植代码的时候我们不应该对此作出任何的假设。
由于在复制时复制了父进程的堆栈段，所以两个进程都停留在fork函数中，等待返回。因此fork函数会返回两次，一次是在父进程中返回，另一次是在子进程中返回，这两次的返回值是不一样的。
调用fork之后，数据、堆栈有两份，代码仍然为一份但是这个代码段成为两个进程的共享代码段都从fork函数中返回，箭头表示各自的执行处。当父子进程有一个想要修改数据或者堆栈时，两个进程真正分裂。
fork函数的特点概括起来就是“调用一次，返回两次”，在父进程中调用一次，在父进程和子进程中各返回一次。
fork的另一个特性是所有由父进程打开的描述符都被复制到子进程中。父、子进程中相同编号的文件描述符在内核中指向同一个file结构体，也就是说，file结构体的引用计数要增加。
2.vfork()
vfork（）会产生一个新的子进程。但是vfork创建的子进程与父进程共享数据段,而且由vfork创建的。子进程将先于父进程运行。
vfork()用法与fork()相似.但是也有区别,具体区别归结为以下几点:
1. fork():子进程拷贝父进程的数据段，代码段. vfork():子进程与父进程共享数据段.
2. fork():父子进程的执行次序不确定.
vfork():保证子进程先运行，在调用exec或exit之前与父进程数据是共享的,在它调用exec或exit之后父进程才可能被调度运行。
3. vfork()保证子进程先运行，在她调用exec或exit之后父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁。
4.当需要改变共享数据段中变量的值，则拷贝父进程。
从这里可见，vfork()和fork()之间的一个区别是：vfork 保证子进程先运行，在她调用exec 或exit 之后父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁。
我们来看下面这段代码：
#include
#include
#includeint main()
{
pid_t pid;
intcnt =0;
pid = fork();
if(pid<0)
printf("error in fork!\n");
elseif(pid ==0)
{
cnt++;
printf("cnt=%d\n",cnt);
printf("I am the child process,ID is %d\n",getpid());
}
else
{
cnt++;
printf("cnt=%d\n",cnt);
printf("I am the parent process,ID is %d\n",getpid());
}
return0;
}


运行结果为：
cnt=1
I am the child process,ID is5077
cnt=1
I am the parent process,ID is5076


为什么不是2 呢？因为我们一次强调fork （）函数子进程拷贝父进程的数据段代码段，所以
cnt++;
printf("cnt= %d\n",cnt); return0
将被父子进程各执行一次，但是子进程执行时使自己的数据段里面的（这个数据段是从父进程那copy 过来的一模一样）count+1，同样父进程执行时使自己的数据段里面的count+1，他们互不影响，与是便出现了如上的结果。
那么再来看看vfork （）吧。如果将上面程序中的fork （）改成vfork（），运行结果是什么样子的呢？
cnt=1
I am the child process,ID is4711
cnt=1
I am the parent process,ID is4710
段错误


本来vfock（）是共享数据段的，结果应该是2，为什么不是预想的2 呢？
上面程序中的fork （）改成vfork（）后，vfork （）创建子进程并没有调用exec 或exit，所以最终将导致死锁。
那么，对程序做下面的修改，
#include
#include
#includeint main()
{
pid_t pid;
intcnt =0;
pid = vfork();
if(pid<0)
printf("error in fork!\n");
elseif(pid ==0)
{
cnt++;
printf("cnt=%d\n",cnt);
printf("I am the child process,ID is %d\n",getpid());
_exit(0);
}
else
{
cnt++;
printf("cnt=%d\n",cnt);
printf("I am the parent process,ID is %d\n",getpid());
}
return0;
}


如果没有_exit（0）的话，子进程没有调用exec 或exit，所以父进程是不可能执行的，在子进程调用exec 或exit 之后父进程才可能被调度运行。
所以我们加上_exit(0); 使得子进程退出，父进程执行，这样else 后的语句就会被父进程执行，又因在子进程调用exec 或exit之前与父进程数据是共享的,所以子进程退出后把父进程的数据段count改成1 了，子进程退出后，父进程又执行，最终就将count变成了2。
运行结果：
cnt=1
I am the child process,ID is4711
cnt=2
I am the parent process,ID is4710


3.扩展
有这样一段代码：
#include
#include
#include intmain(void) {
intvar;
var=88;
if((pid = vfork()) <0) {
printf("vfork error");
exit(-1);
} elseif(pid ==0) {/* 子进程 */var++;
return0;
}
printf("pid=%d, glob=%d, var=%d\n", getpid(), glob,var);
return0;
}
上述代码一运行就挂掉了，但如果把子进程的return改成exit(0)就没事。这是为什么呢？
首先说一下fork和vfork的差别：
fork 是 创建一个子进程，并把父进程的内存数据copy到子进程中。
vfork是 创建一个子进程，并和父进程的内存数据share一起用。
这两个的差别是，一个是copy，一个是share。
你 man vfork 一下，你可以看到，vfork是这样的工作的，
1）保证子进程先执行。 2）当子进程调用exit()或exec()后，父进程往下执行。
那么，为什么要干出一个vfork这个玩意？ 原因在man page也讲得很清楚了：
Historic Description
Under Linux, fork(2) is implemented using copy-on-write pages, so the only penalty incurred by fork(2) is the time and memory required to duplicate the parent’s page tables, and to create a unique task structure for the child. However, in the bad old days a fork(2) would require making a complete copy of the caller’s data space, often needlessly, since usually immediately afterwards an exec(3) is done. Thus, for greater efficiency, BSD introduced the vfork() system call, which did not fully copy the address space of the parent process, but borrowed the parent’s memory and thread of control until a call to execve(2) or an exit occurred. The parent process was suspended while the child was using its resources. The use of vfork() was tricky: for example, not modifying data in the parent process depended on knowing which variables are held in a register.
意思是这样的—— 起初只有fork，但是很多程序在fork一个子进程后就exec一个外部程序，于是fork需要copy父进程的数据这个动作就变得毫无意了，这样干显得很重（因为拷贝了所有内容）。
所以，BSD搞出了个父子进程共享的 vfork，这样成本比较低。因此，vfork本就是为了exec而生。
为什么return会挂掉，exit()不会？
从上面我们知道，结束子进程的调用是exit()而不是return，如果你在vfork中return了，那么，这就意味main()函数return了，注意因为函数栈父子进程共享，所以整个程序的栈就跪了。
如果你在子进程中return，那么基本是下面的过程：
1）子进程的main() 函数 return了，于是程序的函数栈发生了变化。
2）而main()函数return后，通常会调用 exit()或相似的函数（如：_exit()，exitgroup()）
3）这时，父进程收到子进程exit()，开始从vfork返回，但是父进程的栈都被子进程给return干废掉了，父进程无法执行
（注：栈会返回一个诡异一个栈地址，对于某些内核版本的实现，直接报“栈错误”就给跪了，然而，对于某些内核版本的实现，于是有可能会再次调用main()，于是进入了一个无限循环的结果，直到vfork 调用返回 error）
好了，现在再回到 return 和 exit，return会释放局部变量，并弹栈，回到上级函数执行。exit直接退掉。如果你用c++ 你就知道，return会调用局部对象的析构函数，exit不会。（注：exit不是系统调用，是glibc对系统调用 _exit()或_exitgroup()的封装）
可见，子进程调用exit() 没有修改函数栈，所以，父进程得以顺利执行。
关于fork的优化
很明显，fork太重，而vfork又太危险，所以，就有人开始优化fork这个系统调用。优化的技术用到了著名的写时拷贝（COW）。
也就是说，对于fork后并不是马上拷贝内存，而是只有你在需要改变的时候，才会从父进程中拷贝到子进程中，这样fork后立马执行exec的成本就非常小了。所以，Linux的Man Page中并不鼓励使用vfork() ——
“ It is rather unfortunate that Linux revived this specter from the past. The BSD man page states: “This system call will be eliminated when proper system sharing mechanisms are implemented. Users should not depend on the memory sharing semantics of vfork() as it will, in that case, be made synonymous to fork(2).””
于是，从BSD4.4开始，他们让vfork和fork变成一样的了
但在后来，NetBSD 1.3 又把传统的vfork给捡了回来，说是vfork的性能在 Pentium Pro 200MHz 的机器（这机器好古董啊）上有可以提高几秒钟的性能。详情见——“NetBSD Documentation: Why implement traditional vfork()”
今天的Linux下，fork和vfork还是各是各的，不过，还是建议你不要用vfork，除非你非常关注性能。
4.图说
在最后，放两张fork()和vfork()的图，我们自己体会。。。
fork():


linux进程
文章图片
linux进程
文章图片
linux进程
文章图片
linux进程管理之轻量级进程（四）
在Linux中，轻量级进程可以是进程，也可以是线程。我们所说的线程，在Linux中，其实是轻量级进程之间共享代码段，文件描述符，信号处理，全局变量时；
如果不共享，就是我们所说的进程。
进程是资源管理的最小单位，线程是程序执行的最小单位。在操作系统设计上，从进程演化出线程，最主要的目的就是减小多进程上下文切换开销。
最初的进程定义都包含程序、资源及其执行三部分，其中程序通常指代码，资源在操作系统层面上通常包括内存资源、IO资源、信号处理等部分，
而程序的执行通常理解为执行上下文，包括对CPU的占用，后来发展为线程。在线程概念出现以前，为了减小进程切换的开销，操作系统设计者逐渐修正进程
的概念，逐渐允许将进程所占有的资源从其主体剥离出来，允许某些进程共享一部分资源，例如文件、信号，数据内存，甚至代码，这就发展出轻量进程的概念。
Linux内核在2.0.x版本就已经实现了轻量进程，应用程序可以通过一个统一的clone()系统调用接口，用不同的参数指定创建轻量进程还是普通进程。


linux进程
文章图片

    推荐阅读


    上一篇：笔记笔记，好记性不如烂笔头

    下一篇：主动撕去小鲜肉标签，消失两年拍摄《武动乾坤》，杨洋未来可期