1. 进程的创建
Linux下有四类创建子进程的函数：system(),fork(),exec*(),popen()
1.1. system函数
原型：
#include <stdlib.h>
int system(const char *string);
system函数通过调用shell程序/bin/sh –c来执行string所指定的命令，该函数在内部是通过调用execve(“/bin/sh”,..)函数来实现的。通过system创建子进程后，原进程和子进程各自运行，相互间关联较少。如果system调用成功，将返回0。
示例：
#include <stdio.h>
#include <stdlib.h>
int main()
{
system("ls -l"); //system(“clear”);表示清屏
return 0;
}
此外，system函数后面的参数还可以是一个可执行程序，例如：system(“/home/wangxiao/1”);如果想要执行system后面进程的时候，不至于对当前进程进行阻塞，可以利用&将/home/wangxiao/1调到后台运行。
1.2. fork函数
原型：
#include <unistd.h>
pid_t fork(void);
在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。它和其他函数的区别在于：它执行一次返回两个值。其中父进程的返回值是子进程的进程号，而子进程的返回值为0.若出错则返回-1.因此可以通过返回值来判断是父进程还是子进程。
fork函数创建子进程的过程为：使用fork函数得到的子进程是父进程的一个复制品，它从父进程继承了进程的地址空间，包括进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设定、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端，而子进程所独有的只有它的进程号、资源使用和计时器等。通过这种复制方式创建出子进程后，原有进程和子进程都从函数fork返回，各自继续往下运行，但是原进程的fork返回值与子进程的fork返回值不同，在原进程中，fork返回子进程的pid,而在子进程中，fork返回0,如果fork返回负值，表示创建子进程失败。（vfork函数）
示例：
#include <stdlib.h>
#include <unistd.h>
int main()
{
printf("Parent process id:%d\n",getpid());
pid_t iRet = fork();
if(iRet < 0){//出错
printf("Create child process fail!\n");
}else if(iRet == 0){//表示子进程
printf("child process id:%d ppid:%d\n",getpid(),getppid());
}else{//表示父进程
printf("parent process success,child id:%d\n",iRet);
}
return 0;
}
//有人可能会有疑问：这里怎么if和else里面的语句都得到执行了，和我们以前的if…else结构相矛盾啊？此时相当于有两份main函数代码的拷贝，其中一份做的操作是if(iRet == 0)的情况；另外一份做的操作是else(父)的情况。所以可以输出2句话。提问：如何创建兄弟进程和爷孙进程？
1.3. exec函数族
exec*由一组函数组成
int execl(const char *path, const char *arg, ...)
exec函数族的工作过程与fork完全不同，fork是在复制一份原进程，而exec函数是用exec的第一个参数指定的程序覆盖现有进程空间（也就是说执行exec族函数之后，它后面的所有代码不在执行）。
path是包括执行文件名的全路径名
arg是可执行文件的命令行参数，多个用，分割注意最后一个参数必须为NULL。
例如，有个加法程序，从命令行接受两个数，输出其和 。
代码如下：
//add.c
#inclue<stdio.h>
#include <string.h>
Int main(int argc , char * argv[])
{
Int a = atoi(argv[1]) ;
Int b = atoi(argv[2]);
Print f(“%d + %d = %d” , a , b , a + b);
Return 0 ;
}
编译连接得到add.exe.
Gcc –o add.exe add.c
然后在main.exe 中调用 add.exe 程序 ,计算3 和 4 的和。
Main.c 的源程序为 ，
//main.c
#include <stdio.h>
#include <string.h>
Int main()
{
Execl(“./add.exe” ,”add.exe” ,”3” , “4” , NULL):
Return 0 ;
}
编译连接得，
Gcc –o main.exe main.c
然后运行 。./main.exe。
在运行main.exe的过程中会通过execl启动之前的add.exe 程序。
2.4popen函数
popen函数类似于system函数，与system的不同之处在于它使用管道工作。原型为：
#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);
command为可执行文件的全路径和执行参数；
type可选参数为”r”或”w”,如果为”w”,则popen返回的文件流做为新进程的标准输入流，即stdin，如果为”r”,则popen返回的文件流做为新进程的标准输出流。
如果type是“r”，（即command命令执行的输出结果作为当前进程的输入结果）。被调用程序的输出就可以被调用程序使用，调用程序利用popen函数返回的FILE*文件流指针，就可以通过常用的stdio库函数（如fread）来读取被调用程序的输出；如果tpye是“w”，（即当前进程的输出结果作为command命令的输入结果）。调用程序就可以用fwrite向被调用程序发送数据，而被调用程序可以在自己的标准输入上读取这些数据。
pclose等待新进程的结束，而不是杀新进程。
示例：
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main()
{
FILE *read_fp;
char buffer[BUFSIZ + 1];
int chars_read;
memset(buffer, '\0', sizeof(buffer));
read_fp = popen("ps -ax", "r");
if (read_fp != NULL) {
chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
while (chars_read > 0) {
buffer[chars_read - 1] = '\0';
printf("Reading:-\n %s\n", buffer);
chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
}
pclose(read_fp);
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}
进程控制与终止
1.1. 进程的控制
用fork函数启动一个子进程时，子进程就有了它自己的生命并将独立运行。
如果父进程先于子进程退出，则子进程成为孤儿进程，此时将自动被PID为1的进程（即init）接管。孤儿进程退出后，它的清理工作有祖先进程init自动处理。但在init进程清理子进程之前，它一直消耗系统的资源，所以要尽量避免。
Example1：写一个孤儿进程：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
main()
{
pid_t pid = fork();
if( pid == 0)
{
while(1) ;
}
else
{
exit(10);
}
}
通过ps –ef就可以看到此时子进程一直在运行，并且父进程是1号进程。
如果子进程先退出，系统不会自动清理掉子进程的环境，而必须由父进程调用wait或waitpid函数来完成清理工作，如果父进程不做清理工作，则已经退出的子进程将成为僵尸进程(defunct),在系统中如果存在的僵尸（zombie）进程过多，将会影响系统的性能，所以必须对僵尸进程进行处理。
函数原型：
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
wait和waitpid都将暂停父进程，等待一个已经退出的子进程，并进行清理工作；
wait函数随机地等待一个已经退出的子进程，并返回该子进程的pid；
waitpid等待指定pid的子进程；如果为-1表示等待所有子进程。
status参数是传出参数，存放子进程的退出状态；通常用下面的两个宏来获取状态信息：
WIFEXITED(stat_val) 如果子进程正常结束，它就取一个非0值。
WEXITSTATUS(stat_val) 如果WIFEXITED非零，它返回子进程的退出码
options用于改变waitpid的行为，其中最常用的是WNOHANG，它表示无论子进程是否退出都将立即返回，不会将调用者的执行挂起。
Example1：写一个僵尸进程：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
main()
{
pid_t pid = fork();
if( pid == 0 )
{
exit(10);
}
else
{
sleep(10);
}
}
通过用ps –aux快速查看发现Z的僵尸进程。
Example2：避免僵尸进程：(wait()函数)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
main()
{
pid_t pid = fork();
if( pid == 0 )
{
exit(10);
}
else
{
wait(NULL); //NULL表示等待所有进程
sleep(10); //通常要将sleep放在wait的后面，要不然也会出现僵尸进程
}
}
Example3：利用信号处理避免僵尸进程：（wait ()函数）
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
void SignChildPsExit(int iSignNo)
{
int iExitCode;
pid_t pid = wait(&iExitCode); //等待子进程的退出，没有这句会出现僵尸进程
printf("SignNo:%d child %d exit\n",iSignNo,pid);
if(WIFEXITED(iExitCode))
{
printf("Child exited with code %d\n", WEXITSTATUS(iExitCode));
}
sleep(10);
}
int main()
{
signal(SIGCHLD, SignChildPsExit);
printf("Parent process id:%d\n", getpid());
pid_t iRet = fork();
if(iRet == 0)
exit(3);
}
Example4：waitpid实现
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
void SignChildPsExit(int iSignNo)
{
int iExitCode;
pid_t pid = waitpid(-1,NULL,0); //表示等待任何进程，并阻塞。如果换成waitpid(-1,NULL,WNOHANG);则跟没有写waitpid效果类似，此时父进程没有阻塞
printf("SignNo:%d child %d exit\n",iSignNo,pid);
if(WIFEXITED(iExitCode))
{
printf("Child exited with code %d\n", WEXITSTATUS(iExitCode));
}
sleep(10);
}
int main()
{
signal(SIGCHLD, SignChildPsExit);
printf("Parent process id:%d\n", getpid());
pid_t iRet = fork();
if(iRet == 0)
exit(3);
}
1.2. 进程的终止
进程的终止有5种方式：
l main函数的自然返回；
l 调用exit函数
l 调用_exit函数
l 调用abort函数
l 接收到能导致进程终止的信号ctrl+c SIGINT ctrl+\ SIGQUIT
前3种方式为正常的终止，后2种为非正常终止。但是无论哪种方式，进程终止时都将执行相同的关闭打开的文件，释放占用的内存等资源。只是后两种终止会导致程序有些代码不会正常的执行比如对象的析构、atexit函数的执行等。
exit和_exit函数都是用来终止进程的。当程序执行到exit和_exit时，进程会无条件的停止剩下的所有操作，清除包括PCB在内的各种数据结构，并终止本程序的运行。但是它们是有区别的，exit和_exit的区别如图所示：
exit函数和_exit函数的最大区别在于exit函数在退出之前会检查文件的打开情况，把文件缓冲区中的内容写回文件，就是图中的“清理I/O缓冲”。
由于linux的标准函数库中，有一种被称作“缓冲I/O”操作，其特征就是对应每一个打开的文件，在内存中都有一片缓冲区。每次读文件时，会连续读出若干条记录，这样在下次读文件时就可以直接从内存的缓冲区中读取；同样，每次写文件的时候，也仅仅是写入内存中的缓冲区，等满足一定的条件（如达到一定数量或遇到特定字符等），再将缓冲区中的内容一次性写入文件。这种技术大大增加了文件读写的速度，但也为编程带来了麻烦。比如有一些数据，认为已经写入文件，实际上因为没有满足特定的条件，它们还只是保存在缓冲区内，这时用_exit函数直接将进程关闭，缓冲区中的数据就会丢失。因此，如想保证数据的完整性，建议使用exit函数。
exit和_exit函数的原型：
#include <stdlib.h> //exit的头文件
#include <unistd.h> //_exit的头文件
void exit(int status);
void _exit(int status);
status是一个整型的参数，可以利用这个参数传递进程结束时的状态。一般来说，0表示正常结束；其他的数值表示出现了错误，进程非正常结束。
Example1：exit的举例如下：
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("Using exit...\n");
printf("This is the content in buffer");
exit(0);
}
可以发现，调用exit函数，缓冲区中的记录也能正常输出。
Example2：_exit的举例如下：
#include <stdio.h>
#include <unistd.h>
int main()
{
printf("Using _exit...\n");
printf("This is the content in buffer");
_exit(0);
}
可以发现，最后的输出结果没有This is the content in buffer，说明_exit函数无法输出缓冲区中的记录。