一、fork函数

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

该函数的每次调用都返回两次，在父进程中返回的是子进行的PID，在子进程中返回的是0.失败时返回-1

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

int main()
{
	pid_t pid;
	cout << "开始" << endl;

	pid = fork();
	if(pid == -1)
	{
		perror("fork error");
		exit(-1);
	}
	else if(pid == 0) //子进程
	{
		cout << "我是儿子,我的进程ID是:" << getpid() << "我的爸爸是：" << getppid() << endl;
	}
	else
	{
		sleep(5);
		cout << "我是爸爸,我的进程ID是:" << getpid() << "我的儿子的爷爷是：" << getppid() << endl;
	}

	cout << "结束" << endl;
	return 0;
}

上述简单示例，可以初步体会到fork函数的用法

运行结果：

循环创建n个子进程程序：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

int main()
{
	pid_t pid;
	cout << "开始" << endl;
	//开始循环
	for(int i = 0; i < 3; i++)
	{
		pid = fork();
		if(pid == -1)
		{
			perror("fork error");
			exit(-1);
		}
		if(pid == 0) //子进程，子进程不再进入循环
		{
			cout << "我是第" << i + 1 << "个子进程" << endl;
			break; //为啥要break，搞清楚
		}
		else
		{
			cout << "反正我就是爹" << i + 1 << endl;
			sleep(1);
		}
	}

	cout << "结束" << endl;
	return 0;
}

相信通过上面两个程序，对fork函数已经有所了解

干货：

fork函数复制当前进程，在内核进程表中创建一个新的进程表项。新的进程表项有很多属性和原进程相同，比如堆指针、栈指针和标志寄存器的值。但也有很多属性被赋予了新的值，比如该进程的PPId被设置成了原进程的PID，信号位图被清除。子进程的代码和父进程的代码完全相同，同时它还会复制父进程的数据（堆数据、栈数据和静态数据）。数据的复制采用的是写时复制，也就是只有在任一进程对数据执行了写操作是，复制才会发生。此外，创建子进程后，父进程中打开的文件描述符默认在子进程中也是打开的，且文件描述符的引用计数+1。

关于数据共享：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

int x = 100;

int main()
{
	pid_t pid;
	cout << "开始" << endl;

	pid = fork();
	if(pid == -1)
	{
		perror("fork error");
		exit(-1);
	}
	if(pid == 0) //子进程
	{
		cout << "我是子进程改之前的" << "x:" << x << endl;
		x = 20;
		cout << "我是子进程改之后的" << "x:" << x << endl;
	}
	else
	{
		x = 1;
		cout << "我是父进程" << "x:" << x << endl;
		sleep(1);
	}
	cout << "最后的x" << x << endl;
	cout << "结束" << endl;
	return 0;
}

什么是写时复制：

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

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

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

在网上看到的还有个细节问题是：fork之后内核会将子进程排在队列的前面，以让子进程先执行，以免父进程执行导致写时复制，而后子进程执行exec系统调用，因无意义的复制而造成效率的下降。

父子进程真正共享的部分：1.文件描述符 2.mmap

二、gdb调试多进程程序

set follow-fork-mode child

set follow-fork-mode parent

需要在fork函数调用之前设置

三、exec系列系统调用

#include <unistd.h>

extern char **environ;

int 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 execvpe(const char *file, char *const argv[],
                   char *const envp[]);

有时候，我们需要在子进程中执行其他程序，即替换当前进程映像，就使用上面这些函数可以实现。

四、处理僵尸进程

    僵尸进程：进程终止，父进程尚未回收，子进程残留资源（PCB）存在于内核中，变成僵尸进程。

    孤儿进程：就是爹死了，但是儿子没死，然后就成孤儿了，孤儿最后被好心人隔壁老王(init)领养了。

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

int main()
{
	pid_t pid;
	cout << "开始" << endl;

	pid = fork();
	if(pid == -1)
	{
		perror("fork error");
		exit(-1);
	}
	if(pid == 0) //子进程
	{
		while(1)
		{
			cout << getppid() << endl;
			sleep(2);
		}
	}
	else
	{
		sleep(3);
		cout << "爹即将死去" << endl;
	}
	cout << "结束" << endl;
	return 0;
}

上面是一个孤儿进程程序：

可以看到ctrl+c都停不下来，然后

ps -all

然后可以把它kill掉。

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

int main()
{
	pid_t pid;
	cout << "开始" << endl;

	pid = fork();
	if(pid == -1)
	{
		perror("fork error");
		exit(-1);
	}
	if(pid == 0) //子进程
	{
		sleep(10);
		cout << "子进程也死了" << endl;
	}
	else
	{
		while(1)
		{
			sleep(3);
			cout << "我是爹，我还活着" << endl;
		}
	}
	cout << "结束" << endl;
	return 0;
}

上面代码是一个关于僵尸进程的代码，

可以看到上面的僵尸进程。

所以说如何处理僵尸进程呢？

 #include <sys/types.h>
 #include <sys/wait.h>

 pid_t wait(int *status);

 pid_t waitpid(pid_t pid, int *status, int options);

 int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

这俩函数。差别就是，wait阻塞等待一个子进程退出并回收，waitpid则是回收指定子进程，可以不则塞，这样的话，就需要轮询。

五、进程间通信

    在进程间完成数据传递需要借助操作系统提供特殊的方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身设计缺陷而被淘汰，目前常用的进程间通信方式有四种：管道（使用最简单）信号（开销最小）共享映射区（无血缘关系）本地套接字（最稳定）

1.管道

     管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe函数即可创建一个管道。有如下特性：

      1）.其本质是一个伪文件（实为内核缓冲区）

      2）.两个文件描述符引用，一个表示读端，一个表示写端

      3）.规定数据从管道的写端流入管道，从读端流出

   管道的原理：管道实为内核使用唤醒队列机制，借助内核缓冲区（4k）实现

pipe函数：

int pipe(int pipefd[2], int flags);

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <wait.h>
using namespace std;

int main()
{
	pid_t pid;
	int fd[2];
	int ret = pipe(fd);
	int status = -1;
	if(ret == -1)
	{
		perror("pipe error");
		exit(-1);
	}
	cout << "开始" << endl;
	pid = fork();
	if(pid == -1)
	{
		perror("fork error");
		exit(-1);
	}
	if(pid == 0) //子进程  读数据
	{
		//将写端关闭
		//为保证写的时候，读操作已经完成了，所以儿子先睡一下
		sleep(2);
		close(fd[1]);
		char buf[1024];
		int ret = read(fd[0], buf, sizeof(buf));
		if(ret == -1)
		{
			perror("child read error");
			exit(-1);
		}
		cout << buf << endl;
	}
	else //父进程 写数据
	{
		//将读端关闭
		close(fd[0]);
		char hh[1024] = "我是数据";
		int ret = write(fd[1], hh, sizeof(hh));
		if(ret == -1)
		{
			perror("parent write error");
			exit(-1);
		}
		//回收子进程
		wait(&status);
	}
	cout << "结束" << endl;
	return 0;
}

上面代码简单示例了利用管道进行进程间通信。

2.FIFO

https://blog.csdn.net/firefoxbug/article/details/8137762

可以自行了解一下，我不是很感兴趣

3.mmap

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags,
                  int fd, off_t offset);
int munmap(void *addr, size_t length);