创建子进程

关于创建子进程的原型一般都是用的这个，直接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:%d\n", i);
    } else {
        i--;
        printf("I' m the parent process.The i:%d\n", 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: %d\n", i);
        sleep(5);
        return 6;
    } else {
        //因为只有一个子进程，就不明确指定了
        while (!waitpid(-1, &status, WNOHANG)) {
            i++;
            printf("parent process, %d sec\n", i);
            sleep(1);
        }
        if (WIFEXITED(status))
            printf("Subprocess was ended and return a value :%d\n", 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: %s\n", 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
};