Linux进程理解与实践（一）基本概念和编程概述（fork，vfork，cow）

进程 and 程序

什么是程序?

程序是完成特定任务的一系列指令集合。

什么是进程?

[1]从用户的角度来看:进程是程序的一次执行过程

[2]从操作系统的核心来看:进程是操作系统分配的内存、CPU时间片等资源的基本单位。

[3]进程是资源分配的最小单位

[4]每一个进程都有自己独立的地址空间与执行状态。

[5]像UNIX这样的多任务操作系统能够让许多程序同时运行，每一个运行着的程序就构成了一个进程

进程数据结构

进程由三部分组成:PCB、程序段和数据段。

进程控制块PCB：用于描述进程情况及控制进程运行所需的全部信息。

代码段：是进程中能被进程调度程序在CPU上执行的程序代码段。

数据段：一个进程的数据段，可以是进程对应的程序加工处理的原始数据，也可以是程序执行后产生的中间或最终数据

进程和程序的区别

进程是动态的(进程存在的唯一标志:PCB, CPU通过PCB来控制进程)，程序是静态的

进程的生命周期是相对短暂的，而程序是永久的。

一个进程只能对应一个程序，一个程序可以对应多个进程。

进程三态

进程因创建而就绪，因调度而执行；因时间片用完而重新就绪；

执行中因I/O请求而阻塞；

I/O完成而就绪

注意：阻塞以后不能直接执行，必须进入就绪状态。

运行态：进程占用CPU，并在CPU上运行；

 就绪态：进程已经具备运行条件，但是CPU还没有分配过来；

 阻塞态：进程因等待某件事发生而暂时不能运行；

 进程在一生中，都处于上述3中状态之一。

知道了进程的三种基本状态，但是在操作系统具体实现中，设计者可以根据实际情况设计不同的状态，于是就有了以下几种状态：

Linux内核中的进程状态

运行状态（TASK_RUNNING）

可中断睡眠状态（TASK_INTERRUPTIBLE）

不可中断睡眠状态（TASK_UNINTERRUPTIBLE）

暂停状态（TASK_STOPPED）

僵死状态（TASK_ZOMBIE）

进程调度

进程调度的任务

保存处理机的现场信息

按某种算法选取进程

把处理器分配给进程

进程编程相关术语

进程标志:

每个进程都会分配到一个独一无二的数字编号，我们称之为“进程标识”(process identifier),或者就直接叫它PID.

是一个正整数，取值范围从2到32768

当一个进程被启动时，它会顺序挑选下一个未使用的编号数字做为自己的PID

1号进程是特殊进程init

0号进程空闲进程

关于0,1的解释:

进程0：Linux引导中创建的第一个进程，完成加载系统后，演变为进程调度、交换及存储管理进程;

进程1：init 进程，由0进程创建，完成系统的初始化. 是系统中所有其它用户进程的祖先进程;

Linux内核通过一个被称为进程描述符的task_struct结构体来管理进程，这个结构体包含了一个进程所需的所有信息。

进程创建

不同的操作系统所提供的进程创建原语的名称和格式不尽相同，但执行创建进程原语后，操作系统所做的工作却大致相同，都包括以下几点：

(1)给新创建的进程分配一个内部标识，在内核中建立进程结构。

(2)复制父进程的环境

(3)为进程分配资源， 包括进程映像所需要的所有元素（程序、数据、用户栈等），

(4)复制父进程地址空间的内容到该进程地址空间中。

(5)置该进程的状态为就绪，插入就绪队列。

进程撤销

进程终止时操作系统做以下工作：

(1)关闭软中断:因为进程即将终止而不再处理任何软中断信号；

(2)回收资源：释放进程分配的所有资源，如关闭所有已打开文件，释放进程相应的数据结构等；

(3)写记帐信息：将进程在运行过程中所产生的记帐数据（其中包括进程运行时的各种统计信息）记录到一个全局记帐文件中；

(4)置该进程为僵死状态:向父进程发送子进程死的软中断信号，将终止信息status送到指定的存储单元中；

(5)转进程调度:因为此时CPU已经被释放，需要由进程调度进行CPU再分配。

fork系统调用

复制一个进程映象

使用fork函数得到的子进程从父进程的继承了整个进程的地址空间，包括：进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设置、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端等。

子进程与父进程的区别：

1、父进程设置的锁，子进程不继承

2、各自的进程ID: 父子进程ID不同

3、子进程的未决警告被清除；

4、子进程的未决信号集设置为空集;

fork系统调用

[cpp] view
plaincopy

1. #include <unistd.h>
2. pid_t fork(void);

创建一个子进程

返回值:

如果成功创建一个子进程，对于父进程来说返回子进程ID

如果成功创建一个子进程，对于子进程来说返回值为0

如果为-1表示创建失败

怎样理解fork函数一次调用，二次返回？

问题的本质是：两次返回，是在各自的进程空间中返回的。

子进程和父进程各有自己的内存空间 （fork：代码段、数据段、堆栈段、PCB进程控制块的copy）。

子进程对的count的改变并不会影响到父进程，因为他们有着自己的数据段。

[cpp] view
plaincopy

1. //示例: 父子进程中数据的关系(其实基本没关系)
2. int main(int argc, char *argv[])
3. {
4. signal(SIGCHLD, SIG_IGN);
5. int count = 10;
6. pid_t pid = fork();
7. if (pid == -1)
8. err_exit("fork error");
9. else if (pid == 0)  //子进程
10. {
11. ++ count;
12. cout << "In child: pid = " << getpid() << ", ppid = " << getppid() << endl;
13. cout << "count = " << count << endl;
14. }
15. else if (pid > 0)   //父进程
16. {
17. ++ count;
18. cout << "In parent: pid = " << getpid() << ", child pid = " << pid << endl;
19. cout << "count = " << count << endl;
20. }
21. exit(0);
22. }

[cpp] view
plaincopy

1. //深入理解: Hello World 为什么会打印8次
2. int main(int argc, char *argv[])
3. {
4. signal(SIGCHLD, SIG_IGN);
5. fork();  //每个fork创建一个子进程，然后复制父亲的进程，继续向下执行，所以就像一个二叉树，有4层，所以一共执行了8次 hello wold
6. fork();
7. fork();
8. cout << "Hello World" << endl;
9. exit(0);
10. }

[cpp] view
plaincop

1. //示例: 产生N个子进程
2. int main(int argc, char *argv[])
3. {
4. signal(SIGCHLD, SIG_IGN);
5. int processCount;
6. cin >> processCount;
7. for (int i = 0; i < processCount; ++i)
8. {
9. pid_t pid = fork();
10. if (pid < 0)
11. err_exit("fork error");
12. else if (pid == 0)
13. {
14. cout << "Child ..." << endl;
15. exit(0);
16. }
17. }
18. exit(0);
19. }

写时复制(copy on write)

COW初窥：

在Linux程序中，fork()会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，Linux中引入了“写时复制“技术，也就是只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。

那么子进程的物理空间没有代码，怎么去取指令执行exec系统调用呢？

在fork之后exec之前两个进程用的是相同的物理空间（内存区），子进程的代码段、数据段、堆栈都是指向父进程的物理空间，也就是说，两者的虚拟空间不同，但其对应的物理空间是同一个。当父子进程中有更改相应段的行为发生时，再为子进程相应的段分配物理空间，如果不是因为exec，内核会给子进程的数据段、堆栈段分配相应的物理空间（至此两者有各自的进程空间，互不影响），而代码段继续共享父进程的物理空间（两者的代码完全相同）。而如果是因为exec，由于两者执行的代码不同，子进程的代码段也会分配单独的物理空间。

COW详述：

现在有一个父进程P1，这是一个主体，那么它是有灵魂也就身体的。现在在其虚拟地址空间（有相应的数据结构表示）上有：正文段，数据段，堆，栈这四个部分，相应的，内核要为这四个部分分配各自的物理块。即：正文段块，数据段块，堆块，栈块。

1. 现在P1用fork()函数为进程创建一个子进程P2，

内核：

（1）复制P1的正文段，数据段，堆，栈这四个部分，注意是其内容相同。

（2）为这四个部分分配物理块，P2的：正文段－＞P1的正文段的物理块，其实就是不为P2分配正文段块，让P2的正文段指向P1的正文段块，数据段－＞P2自己的数据段块（为其分配对应的块），堆－＞P2自己的堆块，栈－＞P2自己的栈块。

如下图所示：从左到右大的方向箭头表示复制内容。

2.写时复制技术：内核只为新生成的子进程创建虚拟空间结构，它们复制于来自父进程的虚拟空间结构，但是不为这些段分配物理内存，它们共享父进程的物理空间，当父子进程中有更改相应段的行为发生时，再为子进程相应的段分配物理空间。

3. vfork()：这个做法更加火爆，内核连子进程的虚拟地址空间结构也不创建了，直接共享了父进程的虚拟空间，当然了，这种做法就顺水推舟的共享了父进程的物理空间

小结: 进程是一个主体，那么它就有灵魂与身体，系统必须为实现它创建相应的实体， 灵魂实体与物理实体。这两者在系统中都有相应的数据结构表示，物理实体更是体现了它的物理意义。

传统的fork()系统调用直接把所有的资源复制给新创建的进程。这种实现过于简单并且效率低下，因为它拷贝的数据也许并不共享，更糟的情况是，如果新进程打算立即执行一个新的映像，那么所有的拷贝都将前功尽弃。Linux的fork()使用写时拷贝（copy-on-write）页实现。写时拷贝是一种可以推迟甚至免除拷贝数据的技术。内核此时并不复制整个进程地址空间，而是让父进程和子进程共享同一个拷贝。只有在需要写入的时候，数据才会被复制，从而使各个进程拥有各自的拷贝。也就是说，资源的复制只有在需要写入的时候才进行，在此之前，只是以只读方式共享。这种技术使地址空间上的页的拷贝被推迟到实际发生写入的时候。在页根本不会被写入的情况下{举例来说:fork()后立即调用exec()}它们就无需复制了。fork()的实际开销就是复制父进程的页表以及给子进程创建惟一的进程描述符。在一般情况下，进程创建后都会马上运行一个可执行的文件，这种优化可以避免拷贝大量根本就不会被使用的数据（地址空间里常常包含数十兆的数据）。由于Unix强调进程快速执行的能力，所以这个优化是很重要的。这里补充一点：Linux COW与exec没有必然联系。

[cpp] view
plaincopy

1. string str1 = "hello world";
2. string str2 = str1;

之后执行代码:

[cpp] view
plaincopy

1. str1[1]='q';
2. str2[1]='w';

在开始的两个语句后，str1和str2存放数据的地址是一样的，而在修改内容后，str1的地址发生了变化，而str2的地址还是原来的,这就是C++中的COW技术的应用;

附：可以使用ps命令查看系统中的进程