C多进程

创建子进程

关于创建子进程的原型一般都是用的这个，直接fork，这个函数在父进程中调用，在父子进程中各有一个pid_t类型的返回值，父进程中得到的是子进程的ID，子进程中得到的是0值。当然调用失败就是-1。

//创建进程，然后复制出另一份进程 #include <unistd.h> pid_t fork(); 

根据不同的fork返回值，父子进程可以分出自己专属的代码区域段。例子如下：

#include <stdio.h> #include <unistd.h>  int i = 10; int main() {     pid_t pid;     pid = fork();     if (pid == 0) {         i++;         printf("I' m the subprocess.The i:%dn", i);     } else {         i--;         printf("I' m the parent process.The i:%dn", i);     }     return 0; } 

一般来说，写代码的理想状态是最后的程序正常跑，更理想的就是完全不出错，不过那个太理想了。比如多进程程序中，当父进程结束了，子进程没有被父进程获取状态信息，从而使得进程号依然保留在系统中，占用系统定数的进程号；又比如父进程都结束运行了，子进程还在继续跑，由init进程来接管。这两种情况，前者被叫僵尸进程，后者被称为孤儿进程(这个概念其实我挺犯迷糊，如果有冲突那就是你对，记得提点一声)。所以，父进程在结束之前，要对子进程负责，要查询子进程的结束状态，并确保子进程跑完了才跑路。

wait一下

简单的方案，就是父进程一直等，实现这个功能的函数原型如下：

#include <sys/wait.h> pid_t wait(int *statloc);  //配合使用的宏 WIFEXITED(statloc);						//子进程正常终止，返回非0值 WEXITSTATUS(statloc);						//子进程正常终止，返回退出码 WIFSIGNALED(statloc);						//因为未捕获信号而终止，返回非0值 WTERMSIG(statloc);						//配合前一个宏，返回信号值 WIFSTOPPED(statloc);						//子进程意外终止，返回非0 WSTOPSIG(statloc);						//子进程意外终止，返回信号值 

上面函数的通用解读就是，wait函数的调用会阻塞父进程，一直等着子进程跑完返回状态信息到statloc才对父进程放行。而对于子进程的结束信息的解读，就是上面对应的宏来进行。不过wait的阻塞让很多人不满，所以他们实现了另一种wait：

#include <sys/wait.h> pid_t waitpid(pid_t pid, int *statloc, int options); 

使用waitpid处理僵尸进程：

#include <stdio.h> #include <unistd.h> #include <sys/wait.h>  int main() {     pid_t pid;     int status, i=0;     pid = fork();     if (pid == 0) {         i--;         printf("subprocess: %dn", i);         sleep(5);         return 6;     } else {         //因为只有一个子进程，就不明确指定了         while (!waitpid(-1, &status, WNOHANG)) {             i++;             printf("parent process, %d secn", i);             sleep(1);         }         if (WIFEXITED(status))             printf("Subprocess was ended and return a value :%dn", WEXITSTATUS(status));     }     return 0; } 

进程间通信

比较简单的通信方式，是创建管道，管道和socket套接字同属系统资源，创建了管道，就是使得两个管道在系统提供的内存进行通信。实现的原型如下：

#include <unistd.h> int pipe(int filedes[2]); 

所谓管道，是有着两个口子的，这里的管道也一样，filedes就是一个包含了两个文件描述符的数组，一般传入的这个参数是空的，函数调用结束后就成了新创建的管道的入口和出口。
嗯，所以这个管道的使用，其实就是这两个描述符的使用，filedes数组中，第一个是管道入口，第二个是管道出口，这个要注意。

#include <stdio.h> #include <unistd.h>  int main() {      pid_t pid;     int fds[2];     char str[20];     pipe(fds);     pid = fork();      if (pid != 0) {         write(fds[1], "balabala", sizeof("balabala"));         printf("parent process.n");         sleep(3);     } else {         read(fds[0], str, 20);         printf("subprocess, get mes: %sn", str);     }      return 0; } 

例子是父进程发送信息，子进程接收信息，实际上反过来也可以，不限定。但信息放进管道，父子进程其实都可以读取，就像写了信息在文本，谁都可以读取。管道的单向只体现在它的信息是从fds[1]进，fds[0]出。为了保证
信息的受众是对端从而实现双方通信，往往实现两个管道，然后一个管道负责发，一个负责收，这样就不需要预测运行流程。

管道是很便利，但它往往适用于关联进程(像父子进程)，想要无关联的通信还需要其他机制，比如下面的3种System V IPC。

System V IPC

针对共享资源的多进程访问，这种独占式的访问会引发大问题，谁先谁后无法控制，这种引发竞争的代码段，被称为临界区。对进程的同步，就是确保进入临界区只有一个进程。

信号量

它是一个特殊的整数值变量，只支持两种操作，一个是取，一个是放，分别是P原语和V原语的解读。因为针对多进程同步和多线程同步都有信号量的概念，虽然语义一致，但实现不一样，姑且把多进程间信号量称为信号量，多线程间信号量称为POSIX信号量。对于信号量的初始化决定了其行为，但最常用的就是二进制信号量，用0和1来代表空置和占用的意义。linux中的实现，往往在sys/sem.h头文件中，三个系统调用设计成操作一组信号量而不是单个信号量，三个系统调用分别是semget、semop和semctl；而POSIX信号量的实现都在semaphore.h头文件中。

信号量的创建

#include <sys/sem.h>  //申请信号集，申请成功就返回信号量标记值，失败返回-1 int semget(key_t key, int num_sems, int sem_flags); 

semget的参数key具有唯一性，num_sems则是申请的system V信号量集的信号量数，sem_flags制定了信号量的读写权限。在semget创建信号量成功后，相关联的内核数据结构体semid_ds也会被创建且初始化，具体存储的信息就是创建信号量集的进程的用户ID和组ID，以及信号量集的信号量数还有信号量的读写权限等。

信号量赋初值

具体操作需要依赖semctl函数：

#include <sys/sem.h> int semctl(int sem_id, int sem_num, int command, ...) 

sem_id，当然就是信号量集的标识符了，sem_num于信号量集的意义就像下标之于数组，是标记某某某信号量，command则是执行的命令了。因为这里要用它来赋初值，所以调用起来就是 semctl(sem_id, 0, SETVAL, sem_union)，这个调用其实就是执行SETVAL指示的赋值操作，而sem_union就是携带着想要赋值给信号量的初值。不过先不对这个结合体做过多阐述。系统了解一下semop先：

#include <sys/sem.h> int semop(int sem_id, struct sembuf *semops, size_t num_sem_ops); 

semop函数是对信号量进行PV操作的关键，但具体如何改变要看传参semops，也就是sembuf这种结构体

struct sembuf {     unsigned short int sem_num;                  //对应信号量在信号量集中的索引     short int sem_op;                            //指定操作类型     short int sem_flag;                          //标志位 }; 

可选值为正整型、0和负整型的sem_op以及可选值为IPC_NOWAIT和SEM_UNDO的sem_flag配合起来就决定了semop函数的调用结果。

共享内存

很容易理解的一个机制，就是一块内存，进程间可以共享，它的实现都在sys/shm.h中，使用的函数包括shemget、shmat、shmdt、shmctl：

#include <sys/shm.h>  //创建共享内存或者获取已存在的共享内存 int shmget(key_t key, size_t size, int shmflag); //size，字节为单位，指定内存的大小，获取已存在的共享内存可以设置为0； //shmflag，支持SHM_HUGETLB和SHM_NORESERVE，前者表示用“大页面”来分配空间给共享内存，后者表示不为共享内存保留交换分区，这样内存不足的时候继续写入就会发起SIGSEGV信号 

函数调用成功就返回共享内存的标识符，失败返回-1，然后同样地，内核中有个相关的数据结构shmid_ds会被创建且初始化。在共享内存创建成功后，需要把它关联到进程的地址空间中，用完了需要进行分离：

//关联操作，返回共享内存被关联到进程中的具体地址，失败会返回(void*)-1 void *shmat(int shm_id, const void *shm_addr, int shmflag); //分离原本关联好的共享内存，成功就回0，失败回-1 int shmdt(const void *shm_addr); 

shmget成功调用返回的标识符就可用于shm_id，shm_addr则是进程内指针，具体函数调用效果还是要看shmflag

• shm_addr为NULL，关联地址由系统选择，这样更加兼容
• shm_addr非空，shmflag没有设置SHM_RND，共享内存关联到shm_addr指向地址
• shm_addr非空，shmflag设置了SHM_RND
  嗯，shmflag标志位还可以设置SHM_RDONLY，表示进程只读该共享内存，没设置就读写都可(共享内存创建时就会设置读写权限)；SHM_REMAP，已经关联呢，就重新关联；SHM_EXEC，指定可读

关于关联成功和取消关联关系，都会使得shmid_ds的内核数据发生变动，比如关联成功：
shm_nattach加一、shm_lpid设置为调用进程的PID、shm_atime设置为当前时间；
取消关联成功，就：
shm_nattach减一、shm_lpid设为调用进程的PID、shm_dtime会设置成当前时间；
这么来看，其实关联和非关联都是一个记录，看看什么时候发生变动，变动的操作者是谁，至于区分开两者就是前面的shm_nattach了。

嗯，和信号量一样，共享内存的关联也是准备工作，要用还是要有个函数来进行调用，共享内存的就是shmctl，这个函数重点关注command参数，这个是具体如何用的关键：

int shmctl(int shm_id, int command, struct shmid_ds *buf); 

关于command参数参见下表：

暂时先写就这么点吧，后面再来更新

一些相关的内核数据结构：

//system v信号量 #include <sys/sem.h>  //描述IPC对象权限 struct ipc_perm {     key_t key;                      //键值     uid_t uid;                      //持有者的有效用户ID     gid_t gid;                      //持有者的组ID     uid_t cuid;                     //创建者的用户ID     gid_t cgid;                     //创建者的组ID     mode_t mode;                    //访问权限     ... };  //system v信号量的内核数据结构 struct semid_ds {     struct ipc_perm sem_perm;            //重点关注信号量的操作权限     unsigned long int sem_nsems;         //信号量集的信号量数     time_t sem_otime;                    //最后一次调用semop时间     time_t sem_ctime;                    //最后一次调用semctl时间     ... };   #include <sys/shm.h> //共享内存的内核数据结构 struct shmid_ds {     struct ipc_perm shm_perm;            //共享内存操作权限     size_t shm_segsz;                    //共享内存大小，以字节为单位     __time_t shm_atime;                  //对共享内存最后一次调用shmat的时间     __time_t shm_dtime;                  //对共享内存最后一次调用shmdt的时间     __time_t shm_ctime;                  //对共享内存最后一次调用shmctl的时间     __pid_t shm_cpid;                    //创建者PID     __pid_t shm_lpid;                    //最后一次执行shmat或者shmdt的进程PID     ... };   #include <sys/msg.h> //消息队列的内核数据结构 struct msqid_ds {     struct ipc_perm msg_perm;            //消息队列操作权限     time_t msg_stime;                    //最后一次调用msgsnd时间     time_t msg_rtime;                    //最后一次调用msgrcv时间     time_t msg_ctime;                    //最后一次被修改时间     unsigned long __msg_cbytes;          //消息队列中已有的字节数     msgqnum_t msg_qnum;                  //消息队列已有消息数     msglen_t msg_qbytes;                 //消息队列允许的最大字节数     pid_t msg_lspid;                     //最后执行msgsnd的进程PID     pid_t msg_lrpid;                     //最后执行msgrcv的进程PID };