UNIX-like 操作系统，有一个强劲的功能：可以同时运行多个进程，并且让进程们共享 CPU，内存，和其他的资源．我们所开发的程序，往往会从一个进程演变为多个进程．的确，许多时候线程是不错的选择，不过多进程和多线程使用有许多是相通的：如何启动和停止进程，如何在进程间通信，如何同步进程．
什么是 UNIX 进程？
谈论进程前，需要正确的理解＂什么是进程＂：
进程是一个正在运行的程序实例，执行给定的代码，有自己的＂执行栈内存＂，有自己的＂内存页集合＂，有自己的＂文件描述符号码表＂，有一个唯一的进程号码．
从这个定义可以知道，一个进程并不代表一个程序，几个进程可能是同一时刻同一个程序的多个实例，他们的用户可能是相同的，也可能是不同的．
使用系统调用 fork() 创建进程
系统调用 pid_t fork(void) 用来创建新的进程．这是一个非常奇特的调用，返回两次！听起来很奇怪．首先，在一个正在运行的进程中调用 fork()，会创建一个新进程，新进程是调用进程的子进程．当 fork() 时，调用进程的所有正在使用的＂内存页＂会被复制，调用进程正在使用的＂文件描述符号码表＂也会被复制，这些复制被放入新进程中使用．因此，新进程和调用进程的这些内容变成相互独立的．
注意：
＂写时复制＂，许多现代系统采用了这些技术．当
fork()时，系统并不立刻复制＂内存页＂和＂文件描述符号码表＂，只是在新进程中做一个映射，这样会节省很多复制开销．当新进程中有代码修改＂内存页＂和＂文件描述符号码表＂时，系统会立刻复制一个副本，用于修改．
还有一个需要注意的：
＂文件描述符号码表＂：操作系统每打开一个文件，会在内核缓存中保存文件资源，并为每一个文件建立一些散列表，记录文件信息，同时为开发者提供一个非负整数的号码（文件表的索引），用于引用内存中的文件资源．因此，多个进程的＂文件描述符号码表＂虽然是独立的，但是号码指向的文件却可能是同一个文件，对同一个文件的修改是可以影响到多个进程．由此，出现了另一项技术：＂同步＂，防止多进程同时修改文件资源．
fork() 返回两次，返回值有 3 种情况:
- 如果返回的是 0 ，那么返回值位于新进程中
- 如果返回的是 >0，那么返回值位于调用进程中，返回值是新进程的进程号码．返回值
pid_t定义在sys/types.h头文件中，通常是一个整数 - 如果返回的是 -1，那么返回值位于调用进程中，创建新进程失败
例子：
#include <stdio.h>
#include <stdlib.h>
#define MAX_COUNT 200
void doChild(void);
void doParent(void);
void main(void) {
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild();
exit(0);
default:
doParent();
}
}
void doChild(void) {
int i;
for (i = 1; i <= MAX_COUNT; i++)
printf("This line is from child, value = %d\n", i);
printf("*** Child process is done ***\n");
}
void doParent(void) {
int i;
for (i = 1; i <= MAX_COUNT; i++)
printf("This line is from parent, value = %d\n", i);
printf("*** Parent is done ***\n");
}
对于这个例子，我准备了一个 Nim 语言版本的：
import posix, os
const maxCount = 200
proc doChild()
proc doParent()
proc main() =
var pid = fork()
case pid
of -1:
raise newException(OsError, osLastError().osErrorMsg())
of 0:
doChild()
quit(QuitSuccess)
else:
doParent()
proc doChild() =
for i in 1..maxCount:
echo "This line is from child, value = ", i
echo "*** Child process is done ***"
proc doParent() =
for i in 1..maxCount:
echo "This line is from parent, value = ", i
echo "*** Parent process is done ***"
main()
子进程结束
一旦创建了一个新进程，其就成为调用进程的子进程．有两种可能存在的情况：父进程先于子进程退出，子进程先于父进程退出：
当一个子进程退出时，并不立刻清空进程表，而是向父进程发送一个信号．父进程需要对此应答，然后系统会完全清除子进程．假设父进程没有应答，或者应答之前子进程退出，子进程会被系统设置为＂僵尸＂状态．
当一个父进程退出时，如果有几个子进程仍在运行，这些子进程会变成＂孤儿进程＂．＂孤儿进程＂会立刻被 ＂init＂ 超级进程接管，作为其父进程．＂init＂ 进程能够确保这些子进程在退出时不会变为＂僵尸进程＂，因为 ＂init＂ 进程总是应答子进程的退出．("init" 进程是随操作系统启动的第一个进程，进程号码是 1)
使用系统调用 wait() 应答子进程
应答子进程的简单方法，是使用系统调用 pid_t wait(int * status)．当调用这个函数时，有以下可能：
- 进程中没有子进程，立刻返回
- 进程中的子进程已经退出，并且是＂僵尸＂状态，立刻应答并返回，取得子进程状态（通过参数）
- 进程中的子进程都在运行，立刻阻塞，直到有一个子进程退出或者收到一个 ＂SIGCHILD＂ 信号时返回，取得子进程状态（通过参数）
例子：
#include <stdio.h>
#include <stdlib.h>
#define MAX_COUNT 200
void doChild(void);
void doParent(void);
void main(void) {
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild();
exit(0);
default:
doParent();
}
int status;
pid = wait(&status);
printf("*** Parent detects process %d is done ***\n", pid);
printf("*** Parent exits ***\n");
exit(0);
}
void doChild(void) {
int i;
for (i = 1; i <= MAX_COUNT; i++)
printf("This line is from child, value = %d\n", i);
printf("*** Child process is done ***\n");
}
void doParent(void) {
int i;
for (i = 1; i <= MAX_COUNT; i++)
printf("This line is from parent, value = %d\n", i);
printf("*** Parent is done ***\n");
}
注：当一个进程正常或者异常结束时，内核就向其父进程发送 ＂SIGCHILD＂ 信号．子进程结束是一个异步事件，（可以在父进程运行的任何时候发生），所以这种信号由内核向父进程发送异步通知．父进程可以选择忽略该信号，也可以提供一个信号处理函数：
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#define MAX_COUNT 200
void catchChild(int sigNumber);
void doChild(void);
void doParent(void);
void main(void) {
signal(SIGCHLD, catchChild);
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild();
exit(0);
default:
doParent();
}
sleep(1);
printf("*** Parent exits ***\n");
exit(0);
}
void catchChild(int sigNumber) {
int childStatus;
pid_t pid = wait(&childStatus);
printf("*** Parent detects process %d is done ***\n", pid);
}
void doChild(void) {
printf("*** Child process is done ***\n");
}
void doParent(void) {
printf("*** Parent is done ***\n");
}
也可以：
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#define MAX_COUNT 200
void catchChild(int sigNumber);
void doChild(void);
void doParent(void);
void main(void) {
struct sigaction action;
struct sigaction oaction;
action.sa_flags = 0;
action.sa_handler = catchChild;
sigaction(SIGCHLD, &action, &oaction);
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild();
exit(0);
default:
doParent();
}
sleep(1);
printf("*** Parent exits ***\n");
exit(0);
}
void catchChild(int sigNumber) {
int childStatus;
pid_t pid = wait(&childStatus);
printf("*** Parent detects process %d is done ***\n", pid);
}
void doChild(void) {
printf("*** Child process is done ***\n");
}
void doParent(void) {
printf("*** Parent is done ***\n");
}
使用系统调用 exec() 执行程序
有时候，创建一个子进程，但是并不想运行和父进程同样的程序．这时候可以使用 exec 家族执行另一个二进制文件．exec 家族函数包括： execl()，execlp()，execle()，execv()，execvp()，execve()．这里介绍一下 int execvp(const char *file, char *const argv[])．
- 第一个参数是一个字符串，表示可执行文件的路径
- 第二个参数是传递给可执行程序的参数，同
int main(int argc, char **argv)中的argv．
当 execvp() 调用时，给出的二进制程序文件会被加载进内存，该子进程 fork() 出来的所有＂内存页＂和＂文件描述符号码表＂都会清空．子进程的进程号码不变．然后子进程运行新的二进制程序．
如果 execvp() 执行程序成功，该函数不会返回，其下面的代码不会继续运行，因为已经转入新的程序中．如果执行程序失败，返回 -1．
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#define MAX_COUNT 200
void doChild(char **argv);
void doParent(void);
void main(int argc, char **argv) {
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild(argv);
exit(0);
default:
doParent();
}
int status;
pid = wait(&status);
printf("*** Parent detects process %d is done ***\n", pid);
printf("*** Parent exits ***\n");
exit(0);
}
void doChild(char **argv) {
execvp(argv[1], NULL);
printf("*** Child process is done ***\n");
}
void doParent(void) {
printf("*** Parent is done ***\n");
}
使用系统调用 pipe() 创建管道，在进程间通信
一旦创建了多个进程后，我们突然意识到没有办法在进程之间通信．在多进程的程序中，我们常常需要进程之间共同完成一些任务．在父－子进程这样的关系进程，可以使用管道（匿名管道）进行通信．
系统调用 int pipe(int fds[2])，创建一对管道，第一个用于读，第二个用于写，返回两个对应的文件描述符号码．
管道非常受限：
- 每一个都是单向的，要么只能读，要么只能写
- 管道只能在有父－子关系的进程中使用，不相关的进程之间无法使用．
管道也有一些优点：．
- 管道中传输的是字节流，写入的顺序和读取的顺序是一致的
- 管道中不会丢失数据，除非读取端提前关闭读取管道
#include <stdio.h>
#include <stdlib.h>
#define BUFFSIZE 6
void doChild(int pipefds[2]);
void doParent(int pipefds[2]);
void main(void) {
int pipefds[2];
pipe(pipefds);
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild(pipefds);
exit(0);
default:
doParent(pipefds);
}
int status;
pid = wait(&status);
printf("*** Parent detects process %d is done ***\n", pid);
printf("*** Parent exits ***\n");
exit(0);
}
void doChild(int pipefds[2]) {
close(pipefds[1]);
char buff[BUFFSIZE];
read(pipefds[0], buff, sizeof(buff));
printf("Recv %s.\n", buff);
printf("*** Child process is done ***\n");
}
void doParent(int pipefds[2]) {
close(pipefds[0]);
char buff[BUFFSIZE] = "Hello";
write(pipefds[1], buff, sizeof(buff));
printf("*** Parent is done ***\n");
}
如果 pipe() 调用成功，将会创建一对管道．pipefds[0] 用于读取，pipefds[1] 用于写入．我们首先使用 pipe() 创建了管道，然后调用 fork() 创建一个子进程，fork() 会把 pipe() 创建的管道描述符做一份复制给新进程．因此，在新进程（子进程）也存在同样的＂文件描述符号码表＂，他们都指向操作系统内核缓冲中存放的管道文件资源．另外，我们在父子进程分别关闭了不需要的＂文件描述符号码表＂，虽然不是必须的，但是＂打开的文件＂是有上限的，尽可能的关闭不使用的总是好的．
close() 只会减少内核缓冲中保存的＂文件资源＂的引用计数，而不是真的关闭＂文件资源＂．当引用计数变为 0 的时候，才会真正关闭＂文件资源＂．同样的，每次 open() 或者以其他方式打开一个＂文件资源＂时，也会把引用计数加 1．
从上面的代码也可以看出，管道实际上是属于文件性质，对管道的操作跟对文件的操作是相同的．这意味着你也可以把管道设置为非阻塞的（请关注我的后续文字： POSIX 程序设计 __ IO），可以使用文件操作的常用函数．
在更复杂的程序中，你可能需要一个双向通信的管道，那么你必须建立两对管道：每一个进程使用两个端进行读和写．这时候你必须要小心，因为这样使用管道很容易＂死锁＂．我们没有用锁，怎么会出现＂死锁＂？事实上，这种情况只是跟＂死锁＂相同的表现．
进程 A 进程 B
pipefds_a[1] ----------> pipefds_a[0]
pipefds_b[0] <---------- pipefds_b[1]
比如在上图中，进程 A 和进程 B 分别通过一对管道进行读写．
假设进程 A 使用 pipefds_b[0，阻塞在读取时，进程 B 也使用 pipefds_b[1] 阻塞在读取．这时候，两边都没有字节流发送，进程 A 和进程 B 就会一直阻塞在那里，什么都不做了．
假设进程 A 使用 pipefds_a[1] 写入．基于字节流的读写往往都是基于内核缓冲区，管道也不例外．当创建管道的时候，内核同时为管道分配了一块内存缓冲，管道写入的时候会写入到这块内核缓冲区上，管道读取的时候也会从这块内核缓冲区读走数据．如果写入的数据很大，内核缓冲区已经填满了，那么进程 A 就会阻塞在那，等待内核缓冲区清空，继续写入．然而此时，进程 B 并没有读取数据，也在使用 pipefds_b[1] 写入管道的内核缓冲区，也阻塞在那里．这样，两个进程也同时阻塞，什么都不做了．
建议：可能的话，把管道读写设置为非阻塞的．
使用系统调用 mkfifo() 创建命名管道，在进程间通信
管道 pipe() 有一个限制：只能在父－子进程之间使用（祖父-孙子也可以）．在不相干的进程之间通信，可以使用命名管道 FIFO．int mkfifo(const char * filename, mode_t mode) 打开一个文件，然后进行写入数据，写入完毕关闭，另外一个进程就可以打开同一个文件进行读取数据．
说白了，管道是使用内存交换数据，命名管道使用一个实际的文件交换数据．操作一个命名管道和操作一个普通文件非常相似．另外，命名管道不能够同时读和写，要么读，要么写，每一个操作只能等待另一个的完成．因为是对文件的操作，需要有文件的读写权限．
从一个命名管道读取时，如果没有数据，会阻塞，而不是立刻返回 EOF（这与普通文件的读不同）．当命名管道写入时，如果内核缓冲区塞满了，但是没有消费者（读取），进程会阻塞在那，直到内核缓冲区的数据被读取清空．
建议：可能的话，把命名管道读写设置为非阻塞的．
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#define BUFFSIZE 6
void doChild(void);
void doParent(void);
void main(void) {
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild();
exit(0);
default:
doParent();
}
int status;
pid = wait(&status);
printf("*** Parent detects process %d is done ***\n", pid);
printf("*** Parent exits ***\n");
exit(0);
}
void doChild(void) {
mkfifo("./fifo_file", S_IFIFO | 0666);
char buff[BUFFSIZE];
int fd = open("./fifo_file", O_RDONLY);
read(fd, buff, sizeof(buff));
printf("Recv %s.\n", buff);
printf("*** Child process is done ***\n");
}
void doParent(void) {
mkfifo("./fifo_file", S_IFIFO | 0666);
char buff[BUFFSIZE] = "Hello";
int fd = open("./fifo_file", O_WRONLY);
write(fd, buff, sizeof(buff));
printf("Write %s.\n", buff);
printf("*** Parent is done ***\n");
}
使用系统调用 socket() 创建套接字，在进程间通信
这是一个广博的话题，应该占用单独一个章节．
这里我们单独介绍一下 UNIX Domain Socket，这是一个非常好用的通信方式，跟管道是非常相似，甚至工作方式接近相同，但是拥有非常棒的优点：进程之间可以是不相关的，通信方式是双向的（管道是单向的）．
我们可以使用普通的 int socket(int domain, int type, int protocol) 系统调用，并设置 domain 为 AF_UNIX，采用本机通信来建立本机多进程之间的通信．不过，UNIX 系统为这种场景提供了一个更简便可行的方案：int socketpair(int domain, int type, int protocol, int sockfd[2])．
使用 socketpair()，会创建一对管道，每一端都可以读写，是双向的，跨进程的．除此之外，跟管道是相同的工作方式．
建议：对于进程间通信，这是一个非常效率稳定的方式，你也可以将其设置为非阻塞的．
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define BUFFSIZE 6
void doChild(int pipefds[2]);
void doParent(int pipefds[2]);
void main(void) {
int pipefds[2];
socketpair(AF_UNIX, SOCK_STREAM, 0, pipefds);
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild(pipefds);
exit(0);
default:
doParent(pipefds);
}
int status;
pid = wait(&status);
printf("*** Parent detects process %d is done ***\n", pid);
printf("*** Parent exits ***\n");
exit(0);
}
void doChild(int pipefds[2]) {
close(pipefds[1]);
char buff[BUFFSIZE];
read(pipefds[0], buff, sizeof(buff));
printf("Child recv %s.\n", buff);
char buff2[BUFFSIZE] = "OK";
write(pipefds[0], buff2, sizeof(buff2));
printf("Child send %s.\n", buff2);
printf("*** Child process is done ***\n");
}
void doParent(int pipefds[2]) {
close(pipefds[0]);
char buff[BUFFSIZE] = "Hello";
write(pipefds[1], buff, sizeof(buff));
printf("Parent send %s.\n", buff);
char buff2[BUFFSIZE];
read(pipefds[1], buff2, sizeof(buff2));
printf("Parent recv %s.\n", buff2);
printf("*** Parent is done ***\n");
}
使用系统调用 mmap() 创建内存映射，在进程间通信
系统调用 void *mmap(void *addr, size_t length, int port, int flags, int fd, off_t offset) 在虚拟内存空间创建一个内存映射，映射的内存可以与其他进程共享：
- 映射同一个文件同一个区域，共享相同的＂物理内存页＂
- 通过
fork()创建的子进程，会复制父进程的＂内存页＂，可以在这些内存页中映射共享内存
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <pthread.h>
#define BUFFSIZE 6
void doChild(void);
void doParent(void);
struct Data {
pthread_mutex_t mutex;
int state;
};
static struct Data *data;
void main(void) {
int fd;
pthread_mutexattr_t mattr;
fd = open("/dev/zero", O_RDWR, 0);
data = (struct Data *)mmap(0, sizeof(struct Data),
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
close(fd);
pthread_mutexattr_init(&mattr);
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(&data->mutex, NULL);
data->state = 0;
pid_t pid = fork();
switch (pid) {
case -1:
perror("Counld not fork");
exit(1);
case 0:
doChild();
exit(0);
default:
doParent();
}
int status;
pid = wait(&status);
printf("Parent state %d\n", data->state);
printf("*** Parent detects process %d is done ***\n", pid);
printf("*** Parent exits ***\n");
exit(0);
}
void doChild(void) {
pthread_mutex_lock(&data->mutex);
data->state = 1;
pthread_mutex_unlock(&data->mutex);
printf("*** Child process is done ***\n");
}
void doParent(void) {
printf("*** Parent is done ***\n");
}
在这个程序中，我们首先定义了一个全局共享数据 data，在后面的代码中使用 mmap() 对其申请内存，并映射内存页．open() 打开了一个 /dev/zero 的设备，当从这个设备读取数据时，获得的是字符 \0，可以用来初始化一个文件（也可以向这个字符设备写入，字符设备会丢弃数据，什么也不做）．然后我们设置共享数据的 state 为 0，初始化线程锁，通过 pthread_mutexattr_setpshared 系统调用设置锁的共享属性是进程共享 PTHREAD_PROCESS_SHARED．然后调用 fork() 创建子进程，在子进程中修改共享数据 data 的 state 字段为 1．最后在父进程中 wait 等待并应答子进程，打印最后的共享数据 data 的 state 值．你会发现，state 已经变为 1，这表示父进程和子进程确实共享了 data．
这种数据通信，是基于内存映射的，所以操作非常快．
更多的进程通信
还有一些进程通信方式，包括但不限于：
- 消息队列
- 信号量
- 共享内存（类似于 mmap，但是可移植较差）
友情提示：这些方式无法使用 select() 或者 poll()，进程等待消息只能通过消息队列，不能通过其他类似通知的方式知道消息到来．除非你没有更好的法子的时候，选择这些通信方式．
常用编程 API
pid_t fork(void)
// 创建一个子进程
pid_t wait(int *status)
// 等待并应答一个随机子进程
pid_t waitpid(pid_t pid, int * status, int options)
// 等待并应答一个特定子进程
int execve(const char * filename, char const *argv, char const *envp)
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[])
// 在一个子进程中，执行一个二进制可执行文件，运行新程序
void exit(int status)
// 退出进程
pid_t getpid(void) // 获取当前进程号码
pid_t getppid(void) // 获取当前进程的父进程号码
pid_t getpgrp(void) // 获取当前进程的进程组号码
pid_t getpgid(pid_t pid) // 获取特定进程的进程组号码
pid_t getsid(pid_t pid) // 获取特定进程的进程组首进程号码
int setpgid(pid_t pid, pid_t pgid)
// 设置特定进程的进程组号码
pid_t setsid(void)
// 使当前进程创建一个新会话，并成为新进程组首进程
uid_t getuid(void) // 获取当前进程的用户号码
uid_t geteuid(void) // 获取当前进程的有效用户号码
gid_t getgid(void) // 获取当前进程的用户组号码
gid_t getegid(void) // 获取当前进程的有效用户组号码
int setuid(uid_t uid) // 设置当前进程的用户号码
int seteuid(uid_t uid) // 设置当前进程的有效用户号码
int setgid(gid_t gid) // 设置当前进程的用户组号码
int setegid(gid_t gid) // 设置当前进程的有效用户组号码
int pipe(int fds[2])
// 创建一对匿名管道
int mkfifo(const char * filename, mode_t mode)
// 创建一对命名管道
int socketpair(int domain, int type, int protocol, int sockfd[2])
// 创建一对本机套接字管道
void *mmap(void *addr, size_t length, int port, int flags, int fd, off_t offset)
// 创建一个内存映射
友情提示：出于演示简洁，本文字中的函数调用，大部分没有检查创建的正确性，实际项目中，应该有严格的检查．
