《深入理解计算机系统》第8章（fork）

一般来说，在fork之后是父进程先执行还是子进程先执行是不确定的.这取决于内核所使用的调度算法.如果要求父，子进程之间相互同步.则要求某种形式的进程间通信. 好了我们继续，当进程调用fork后，当控制转移到内核中的fork代码后，内核会做4件事情:

　　1.分配新的内存块和内核数据结构给子进程

　　2.将父进程部分数据结构内容(数据空间，堆栈等）拷贝至子进程

　　3.添加子进程到系统进程列表当中

　　4.fork返回，开始调度器调度

为什么fork成功调用后返回两个值? 

由于在复制时复制了父进程的堆栈段，所以两个进程都停留在fork函数中，等待返回。所以fork函数会返回两次,一次是在父进程中返回，另一次是在子进程中返回，这两次的返回值不同。

从fork函数开始以后的代码父子共享，既父进程要执行这段代码，子进程也要执行这段代码.(子进程获得父进程数据空间，堆和栈的副本. 但是父子进程并不共享这些存储空间部分. (即父，子进程共享代码段.)。现在很多实现并不执行一个父进程数据段，堆和栈的完全复制. 而是采用写时拷贝技术

例子0：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int set = 110;
int main( void)
{
    printf( "before fork\n");
    pid_t pid = fork( );
    if( pid < 0){ perror(" fork"),exit( 1);}

    if( pid == 0)
    {
        ++set;
        printf( "son pid=%d, %d\n", getpid(), set);
    }
    else
    {
        sleep( 1);
        printf( "parent pid=%d , %d\n", getpid( ), set);
    }
    exit( 0);
}

结果：

但是把输出重定位到文件而不是屏幕后结果：

首先，先要知道标准IO库是是带缓冲的，而像printf这种直接输出到标准输出时，这个缓冲区是由换行符刷新的；而当执行了重定向操作，这里就是将标准输出重定向到文件，文件就不会立即去刷新缓冲区（全缓冲的方式）；好，由于在fork之前调用了一次printf,但fork之后，该行数据仍存留在缓冲区中，然后父进程数据空间被复制到子进程中，该行数据去也被复制了过去，这样父子进程都各自带有该行内容的缓冲区了，相当于子进程缓冲区添加了一行“before fork”，然后在每个进程exit之后，每个缓冲区的内容就被写到了相应的文件中。

　　再一个就是，在重定向父进程的标准输出时，子进程标准输出也被重定向。这就源于父子进程会共享所有的打开文件。　因为fork的特性就是将父进程所有打开文件描述符复制到子进程中。当父进程的标准输出被重定向，子进程本是写到标准输出的时候，此时自然也改写到那个对应的地方； 

例子1：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
int main()
{
    printf("L0\n");
    if (fork() != 0) {
	printf("L1\n");
	if (fork() != 0) {
	    printf("L2\n");
	}
    }
    printf("Bye\n");
    return 0;
}

   运行结果:            

例2：

int main()
{
    printf("L0\n");
    if (fork() == 0) {
	printf("L1\n");
	if (fork() == 0) {
	    printf("L2\n");
	}
    }
    printf("Bye\n");
    return 0;
}

       结果：

例子3：atexit()函数

进程终⽌的⽅式有8种，前5种为正常终⽌，后三种为异常终⽌：
1 从main函数返回；
2 调⽤exit函数；
3 调⽤_exit或_Exit；
4 最后⼀个线程从启动例程返回；
5 最后⼀个线程调⽤pthread_exit；
6 调⽤abort函数；
7 接到⼀个信号并终⽌；
8 最后⼀个线程对取消请求做出响应。

atexit函数是一个特殊的函数，它是在正常程序退出时调用的函数，我们把他叫为登记函数

（函数原型：int atexit (void (*)(void))）：

      ⼀个进程可以登记若⼲个函数，这些函数由exit⾃动调⽤，这些函数被称为终⽌处理函数， atexit函数可以登记这些函数。 exit调⽤终⽌处理函数的顺序和atexit登记的顺序相反

     exit()和_exit()以及_Exit()函数的本质区别是是否立即进入内核，_exit()以及_Exit()函数都是在调用后立即进入内核，而不会执行一些清理处理，但是exit()则会执行一些清理处理，这也是为什么会存在atexit()函数的原因，因为exit()函数需要执行清理处理，需要执行一系列的操作，这些终止处理函数实际上就是完成各种所谓的清除操作的实际执行体。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
int main()
{
void cleanup1(void) {
    printf("The process is done...\n");
}

void cleanup2(void) {
    printf("Clean up the processing\n");
}

void cleanup3(void) {
    printf("Exit sucessful...\n");
}
    atexit(cleanup1);
    atexit(cleanup2);
    atexit(cleanup3);
    fork();
    exit(0);
}

结果：

例子4：僵尸进程

系统调用exit后，该进程并非马上消失，而是留下一个叫僵尸进程的数据结构，僵尸进程是非常特使的一种，它放弃了几乎所有的内存空间，没有任何可执行代码，也不能别调度，仅仅在进程列表保留位置，而且不占用任何内存空间

void fork7()
{
    if (fork() == 0) {
	/* Child */
	printf("Terminating Child, PID = %d\n", getpid());
	exit(0);
    } else {
	printf("Running Parent, PID = %d\n", getpid());
	while (1)
	    ; /* Infinite loop */
    }
}

例子5：wait（）和waitpid()函数

进程一旦调用了wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。

参数status用来保存被收集进程退出时的一些状态，它是一个指向int类型的指针 

pid = wait(NULL);

如果参数status的值不是NULL，wait就会把子进程退出时的状态取出并存入其中，这是一个整数值（int），指出了子进程是正常退出还是被非正常结束的，以及正常结束时的返回值，或被哪一个信号结束的等信息。由于这些信息被存放在一个整数的不同二进制位中，所以用常规的方法读取会非常麻烦，人们就设计了一套专门的宏（macro）来完成这项工作

WIFEXITED(status)如果子进程正常结束则为非0值。  
WEXITSTATUS(status)取得子进程exit()返回的结束代码，一般会先用WIFEXITED 来判断是否正常结束才能使用此宏。  
WIFSIGNALED(status)如果子进程是因为信号而结束则此宏值为真 

WTERMSIG(status)取得子进程因信号而中止的信号代码，一般会先用WIFSIGNALED 来判断后才使用此宏。  
WIFSTOPPED(status)如果子进程处于暂停执行情况则此宏值为真。一般只有使用WUNTRACED 时才会有此情况。  
WSTOPSIG(status)取得引发子进程暂停的信号代码，一般会先用WIFSTOPPED 来判断后才使用此宏。

例子6：

#define N 5

void fork10()
{
    pid_t pid[N];
    int i, child_status;

    for (i = 0; i < N; i++)
	if ((pid[i] = fork()) == 0) {
	    exit(100+i); /* Child */
	}
    for (i = 0; i < N; i++) { /* Parent */
	pid_t wpid = wait(&child_status);
	if (WIFEXITED(child_status))
	    printf("Child %d terminated with exit status %d\n",
		   wpid, WEXITSTATUS(child_status));
	else
	    printf("Child %d terminate abnormally\n", wpid);
    } 
}

结果：

void fork11()
{
    pid_t pid[N];
    int i;
    int child_status;

    for (i = 0; i < N; i++)
	if ((pid[i] = fork()) == 0)
    //此时父进程和子进程都拥有pid数组，在子进程里面数组为0；父进程里面为子进程的pid号
	    exit(100+i); /* Child */
    for (i = N-1; i >= 0; i--) {
	pid_t wpid = waitpid(pid[i], &child_status, 0);
	if (WIFEXITED(child_status))
	    printf("Child %d terminated with exit status %d\n",
		   wpid, WEXITSTATUS(child_status));
	else
	    printf("Child %d terminate abnormally\n", wpid);
    }
}

结果同上：

例子7：kill（）

用于向任何进程组或进程发送信号。

头文件用法：
#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);

参数： 
pid：可能选择有以下四种

1. pid大于零时，pid是信号欲送往的进程的标识。
2. pid等于零时，信号将送往所有与调用kill()的那个进程属同一个使用组的进程。
3. pid等于-1时，信号将送往所有调用进程有权给其发送信号的进程，除了进程1(init)。
4. pid小于-1时，信号将送往以-pid为组标识的进程。

sig：准备发送的信号代码，假如其值为零则没有任何信号送出，但是系统会执行错误检查，通常会利用sig值为零来检验某个进程是否仍在执行。sig取值很多： SIGINT程序终止(interrupt)信号, 在用户键入INTR字符(通常是Ctrl-C)时发出，用于通知前台进程组终止进程。
返回值说明： 成功执行时，返回0。失败返回-1，errno被设为以下的某个值 EINVAL：指定的信号码无效（参数 sig 不合法） EPERM；权限不够无法传送信号给指定进程 ESRCH：参数 pid 所指定的进程或进程组不存在

void fork12()
{
    pid_t pid[N];
    int i;
    int child_status;

    for (i = 0; i < N; i++)
	if ((pid[i] = fork()) == 0) {
	    /* Child: Infinite Loop */
	    while(1)
		;
	}
    for (i = 0; i < N; i++) {
	printf("Killing process %d\n", pid[i]);
	kill(pid[i], SIGINT);
    }

    for (i = 0; i < N; i++) {
	pid_t wpid = wait(&child_status);
	if (WIFEXITED(child_status))
	    printf("Child %d terminated with exit status %d\n",
		   wpid, WEXITSTATUS(child_status));
	else
	    printf("Child %d terminated abnormally\n", wpid);
    }
}

结果：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
 
int N=5;

int main()
{
	void fork12()
{
    pid_t pid[N];
    int i;
    int child_status;

    for (i = 0; i < N; i++)
	if ((pid[i] = fork()) == 0) {
	    printf("Child %d running while \n",getpid());
	    while(1)
		;
	}
    
    for (i = 0; i < N; i++) {
	pid_t wpid = wait(&child_status);//由于此处子进程处在while循环中，父进程等不到子进程终止，下面的语句无法执行
	if (WIFEXITED(child_status))
	    printf("Child %d terminated with exit status %d\n",
		   wpid, WEXITSTATUS(child_status));
	else
	    printf("Child %d terminated abnormally\n", wpid);
    }
}

fork12();
}

结果：

可以看到state为running的5个est程序