Linux多进程开发

进程概述

1、概念

进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
每个进程都由进程号来标识，其类型为 pid_t（整型），进程号的范围：0～32767。
进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。
进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各
种信号，关联的进程有一个进程组号（PGID）。默认情况下，当前的进程号会当做当
前的进程组号。

2、时间片

时间片（timeslice）又称为“量子（quantum）”或“处理器片（processor slice）”是操作系统分配给每个正在运行的进程微观上的一段 CPU 时间。事实上，虽然一台计算机通常可能有多个 CPU，但是同一个 CPU 永远不可能真正地同时运行多个任务。在只考虑一个 CPU 的情况下，这些进程“看起来像”同时运行的，实则是轮番穿插地运行，由于时间片通常很短（在 Linux 上为 5ms－800ms），用户不会感觉到。
时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番地执行相应的时间，当所有进程都处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。

3、进程控制块

为了管理进程，内核必须对每个进程所做的事情进行清楚的描述。内核为每个进程分配一个 PCB(Processing Control Block)进程控制块，维护进程相关的信息，Linux 内核的进程控制块是 task_struct 结构体。
在 /usr/src/linux-headers-xxx/include/linux/sched.h 文件中可以查看 struct task_struct 结构体定义。

其内部成员有很多，我们只需要掌握以下部分即可：

• 进程id：系统中每个进程有唯一的 id，用 pid_t 类型表示，其实就是一个非负整数
• 进程的状态：有就绪、运行、挂起、停止等状态
• 进程切换时需要保存和恢复的一些CPU寄存器
• 描述虚拟地址空间的信息
• 描述控制终端的信息
• 当前工作目录（Current Working Directory）
• umask 掩码
• 文件描述符表，包含很多指向 file 结构体的指针
• 和信号相关的信息
• 用户 id 和组 id
• 会话（Session）和进程组
• 进程可以使用的资源上限（Resource Limit）

4、进程状态

• 运行态：进程占有处理器正在运行。
• 就绪态：进程具备运行条件，等待系统分配处理器以便运
  行。当进程已分配到除CPU以外的所有必要资源后，只要再
  获得CPU，便可立即执行。在一个系统中处于就绪状态的进
  程可能有多个，通常将它们排成一个队列，称为就绪队列。
• 阻塞态：又称为等待(wait)态或睡眠(sleep)态，指进程
  不具备运行条件，正在等待某个事件的完成。

5、查看进程
ps aux / ajx
a：显示终端上的所有进程，包括其他用户的进程
u：显示进程的详细信息
x：显示没有控制终端的进程
j：列出与作业控制相关的信息

其中的STAT参数意义：
D 不可中断 Uninterruptible（usually IO） R 正在运行，或在队列中的进程
S(大写) 处于休眠状态
T 停止或被追踪
Z 僵尸进程
W 进入内存交换（从内核2.6开始无效）
X 死掉的进程
< 高优先级
N 低优先级
s 包含子进程
+ 位于前台的进程组

6、实时显示进程动态
top
可以在使用 top 命令时加上 -d 来指定显示信息更新的时间间隔，在 top 命令
执行后，可以按以下按键对显示的结果进行排序：

• M 根据内存使用量排序
• P 根据 CPU 占有率排序
• T 根据进程运行时间长短排序
• U 根据用户名来筛选进程
• K 输入指定的 PID 杀死进程

7、kill
kill [-signal] pid
kill –l 列出所有信号
kill –SIGKILL 进程ID
kill -9 进程ID
killall name 根据进程名杀死进程

进程相关函数

pid_t getpid(void); //获得进程id
pid_t getppid(void); //获得父进程id
pid_t getpgid(pid_t pid); //获得进程组id
pid_t fork(void); //创建子进程

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
函数的作用：用于创建子进程。
返回值：
fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。
在父进程中返回创建的子进程的ID,
在子进程中返回0
如何区分父进程和子进程：通过fork的返回值。
在父进程中返回-1，表示创建子进程失败，并且设置errno
父子进程之间的关系：
区别：
1.fork()函数的返回值不同
    父进程中: >0 返回的子进程的ID
    子进程中: =0
2.pcb中的一些数据
    当前的进程的id pid
    当前的进程的父进程的id ppid
    信号集
共同点：
    某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作
    - 用户区的数据
    - 文件描述符表       
父子进程对变量是不是共享的？
    - 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。
    - 读时共享（子进程被创建，两个进程没有做任何的写的操作），写时拷贝。
写时复制：
允许父进程和子进程最初共享相同的页面工作。当任何一个进程要进行写时，创建共享页面的副本到子进程的地址空间内。父子进程的虚拟地址空间指向同一个物理内存，发生写时会创建新的物理内存。vfork不采写时复制，父进程被挂起，子进程使用父进程的地址空间，如果子进程修改了父进程的地址空间，那么这些修改过的页面的对于回复的父进程来说是可见的。

例：创建子进程

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
    pid_t pid = fork();
    cout << "return pid is " << pid << endl;
    if (pid > 0)
    {
        cout << "i am father: " << getpid() << " " << getppid() << endl;
    }
    else if (pid == 0)
    {
        cout << "i am child: " << getpid() << " " << getppid() << endl;
    }
    else
        cout << "fail" << endl;
    for (int i = 0; i < 5; ++i)
        cout << "hello" << endl;
    return 0;
}

多进程GDB调试

使用 GDB 调试的时候，GDB 默认只能跟踪一个进程，可以在 fork 函数调用之前，通
过指令设置 GDB 调试工具跟踪父进程或者是跟踪子进程，默认跟踪父进程。
设置调试父进程或者子进程：set follow-fork-mode [parent（默认）| child]
设置调试模式：set detach-on-fork [on | off]
默认为 on，表示调试当前进程的时候，其它的进程继续运行，如果为 off，调试当前进
程的时候，其它进程被 GDB 挂起。
查看调试的进程：info inferiors
切换当前调试的进程：inferior id
使进程脱离 GDB 调试：detach inferiors id

exec函数族

exec 函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的
内容，换句话说，就是在调用进程内部执行一个可执行文件。

int execl(const char *path, const char *arg, ... /* (char *) NULL */);
int execlp(const char *file, const char *arg, ... /* (char *) NULL */);
int execle(const char *path, const char *arg, ... /*, (char *) NULL, 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[]);
int execve(const char *filename, char *const argv[], char *const envp[]);

l(list) 参数地址列表，以空指针结尾
v(vector) 存有各参数地址的指针数组的地址
p(path) 按 PATH 环境变量指定的目录搜索可执行文件
e(environment) 可给程序添加环境变量

 #include <unistd.h>
int execl(const char *path, const char *arg, ...);
参数：
- path:需要指定的执行的文件的路径或者名称
    a.out /home/nowcoder/a.out 推荐使用绝对路径
    ./a.out hello world
- arg:是执行可执行文件所需要的参数列表
    第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
    从第二个参数开始往后，就是程序执行所需要的的参数列表。
    参数最后需要以NULL结束（哨兵）
- 返回值：
    只有当调用失败，才会有返回值，返回-1，并且设置errno
    如果调用成功，没有返回值。

#include <unistd.h>
int execlp(const char *file, const char *arg, ... );
- 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。
参数：
- file:需要执行的可执行文件的文件名
    a.out
    ps
- arg:是执行可执行文件所需要的参数列表
    第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
    从第二个参数开始往后，就是程序执行所需要的的参数列表。
    参数最后需要以NULL结束（哨兵）
- 返回值：
    只有当调用失败，才会有返回值，返回-1，并且设置errno
    如果调用成功，没有返回值。


int execv(const char *path, char *const argv[]);
argv是需要的参数的一个字符串数组
char * argv[] = {"ps", "aux", NULL};
execv("/bin/ps", argv);


int execve(const char *filename, char *const argv[], char *const envp[]);
char * envp[] = {"/home/nowcoder", "/home/bbb", "/home/aaa"}; //为程序添加环境变量

进程控制

#include <stdlib.h>
void exit(int status);
#include <unistd.h>
void _exit(int status);

退出当前进程，返回给父进程status。

1、孤儿进程
父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程
（Orphan Process）。

• 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init ，而 init
  进程会循环地 wait() 它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束
  了其生命周期的时候，init 进程就会代表党和政府出面处理它的一切善后工作。
• 因此孤儿进程并不会有什么危害

2、僵尸进程
每个进程结束之后, 都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法
自己释放掉，需要父进程去释放。

• 进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸
  （Zombie）进程。
• 僵尸进程不能被 kill -9 杀死，这样就会导致一个问题，如果父进程不调用 wait()
  或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，
  但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进
  程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

wait和waitpid

#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *wstatus);
    功能：等待任意一个子进程结束，如果任意一个子进程结束了，次函数会回收子进程的资源。
    参数：int *wstatus
        进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
    返回值：
        - 成功：返回被回收的子进程的id
        - 失败：-1 (所有的子进程都结束，调用函数失败)
调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.

#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);
    功能：回收指定进程号的子进程，可以设置是否阻塞。
    参数：
        - pid:
            pid > 0 : 某个子进程的pid
            pid = 0 : 回收当前进程组的所有子进程    
            pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）
            pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程
        - options：设置阻塞或者非阻塞
            0 : 阻塞
            WNOHANG : 非阻塞
        - 返回值：
            > 0 : 返回子进程的id
            = 0 : options=WNOHANG, 表示还有子进程或者
            = -1 ：错误，或者没有子进程了

进程间通信

管道通信：

#include <unistd.h>
int pipe(int pipefd[2]);
    功能：创建一个匿名管道，用来进程间通信。
    参数：int pipefd[2] 这个数组是一个传出参数。
        pipefd[0] 对应的是管道的读端
        pipefd[1] 对应的是管道的写端
    返回值：
        成功 0
        失败 -1
管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞
注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）


管道的读写特点：
使用管道时，需要注意以下几种特殊的情况（假设都是阻塞I/O操作）
1.所有的指向管道写端的文件描述符都关闭了（管道写端引用计数为0），有进程从管道的读端
读数据，那么管道中剩余的数据被读取以后，再次read会返回0，就像读到文件末尾一样。

2.如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程
也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，
再次read会阻塞，直到管道中有数据可以读了才读取数据并返回。

3.如果所有指向管道读端的文件描述符都关闭了（管道的读端引用计数为0），这个时候有进程
向管道中写数据，那么该进程会收到一个信号SIGPIPE, 通常会导致进程异常终止。

4.如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程
也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候再次write会阻塞，
直到管道中有空位置才能再次写入数据并返回。

总结：
    读管道：
        管道中有数据，read返回实际读到的字节数。
        管道中无数据：
            写端被全部关闭，read返回0（相当于读到文件的末尾）
            写端没有完全关闭，read阻塞等待，非阻塞返回-1

    写管道：
        管道读端全部被关闭，进程异常终止（进程收到SIGPIPE信号）
        管道读端没有全部关闭：
            管道已满，write阻塞
            管道没有满，write将数据写入，并返回实际写入的字节数
    设置管道非阻塞
int flags = fcntl(fd[0], F_GETFL);  // 获取原来的flag
flags |= O_NONBLOCK;            // 修改flag的值
fcntl(fd[0], F_SETFL, flags);   // 设置新的flag


 创建fifo文件
1.通过命令： mkfifo 名字
2.通过函数：int mkfifo(const char *pathname, mode_t mode);
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
    参数：
        - pathname: 管道名称的路径
        - mode: 文件的权限 和 open 的 mode 是一样的
            是一个八进制的数
返回值：成功返回0，失败返回-1，并设置错误号


有名管道的注意事项：
    1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道
    2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道
读管道：
    管道中有数据，read返回实际读到的字节数
    管道中无数据：
        管道写端被全部关闭，read返回0，（相当于读到文件末尾）
        写端没有全部被关闭，read阻塞等待    
写管道：
    管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
    管道读端没有全部关闭：
        管道已经满了，write会阻塞
        管道没有满，write将数据写入，并返回实际写入的字节数。

例：父子进程通过管道进行通信

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

    // 在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};
        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("parent recv : %s, pid : %d\n", buf, getpid());
            
            // 向管道中写入数据
            //char * str = "hello,i am parent";
            //write(pipefd[1], str, strlen(str));
            //sleep(1);
        }

    } else if(pid == 0){
        // 子进程
        printf("i am child process, pid : %d\n", getpid());
        // 关闭读端
        close(pipefd[0]);
        char buf[1024] = {0};
        while(1) {
            // 向管道中写入数据
            char * str = "hello,i am child";
            write(pipefd[1], str, strlen(str));
            //sleep(1);

            // int len = read(pipefd[0], buf, sizeof(buf));
            // printf("child recv : %s, pid : %d\n", buf, getpid());
            // bzero(buf, 1024);
        }
        
    }
    return 0;
}

例：利用有名管道和子进程完成A,B进程聊天功能

//A进程
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <iostream>
using namespace std;
int main()
{
    int exist = access("fifo1", F_OK);
    if (exist == -1)
    {
        int res = mkfifo("fifo1", 0664);
        if (res == -1)
        {
            perror("mkfifo1");
            return 0;
        }
    }
    exist = access("fifo2", F_OK);
    if (exist == -1)
    {
        int res = mkfifo("fifo2", 0664);
        if (res == -1)
        {
            perror("mkfifo2");
            return 0;
        }
    }
    pid_t pid = fork();
    if (pid > 0)
    {
        while (1)
        {
            char buf1[1024];
            memset(buf1, 0, sizeof(buf1));
            int fd1 = open("fifo1", O_WRONLY);
            fgets(buf1, sizeof(buf1), stdin);
            write(fd1, buf1, strlen(buf1));
        }
    }
    else if (pid == 0)
    {
        while (1)
        {
            char buf2[1024];
            memset(buf2, 0, sizeof(0));
            int fd2 = open("fifo2", O_RDONLY);
            read(fd2, buf2, sizeof(buf2));
            cout << buf2;
        }
    }
    return 0;
}

//B进程
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <iostream>
using namespace std;
int main()
{
    int exist = access("fifo1", F_OK);
    if (exist == -1)
    {
        int res = mkfifo("fifo1", 0664);
        if (res == -1)
        {
            perror("mkfifo1");
            return 0;
        }
    }
    exist = access("fifo2", F_OK);
    if (exist == -1)
    {
        int res = mkfifo("fifo2", 0664);
        if (res == -1)
        {
            perror("mkfifo2");
            return 0;
        }
    }
    pid_t pid = fork();
    if (pid > 0)
    {
        while (1)
        {
            char buf1[1024];
            memset(buf1, 0, sizeof(buf1));
            int fd1 = open("fifo2", O_WRONLY);
            fgets(buf1, sizeof(buf1), stdin);
            write(fd1, buf1, strlen(buf1));
        }
    }
    else if (pid == 0)
    {
        while (1)
        {
            char buf2[1024];
            memset(buf2, 0, sizeof(0));
            int fd2 = open("fifo1", O_RDONLY);
            read(fd2, buf2, sizeof(buf2));
            cout << buf2;
        }
    }
    return 0;
}

内存映射

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
- 功能：将一个文件或者设备的数据映射到内存中
- 参数：
    - void *addr: NULL, 由内核指定
    - length : 要映射的数据的长度，这个值不能为0。建议使用文件的长度。
        获取文件的长度：stat lseek
    - prot : 对申请的内存映射区的操作权限
        -PROT_EXEC ：可执行的权限
        -PROT_READ ：读权限
        -PROT_WRITE ：写权限
        -PROT_NONE ：没有权限
        要操作映射内存，必须要有读的权限。
    PROT_READ、PROT_READ|PROT_WRITE
    - flags :
        - MAP_SHARED : 映射区的数据会自动和磁盘文件进行同步，进程间通信，必须要设置这个选项
        - MAP_PRIVATE ：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件。（copy on write）
        fd: 需要映射的那个文件的文件描述符
        - 通过open得到，open的是一个磁盘文件
        - 注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。
            prot: PROT_READ                open:只读/读写 
            prot: PROT_READ | PROT_WRITE   open:读写
    - offset：偏移量，一般不用。必须指定的是4k的整数倍，0表示不便宜。
        - 返回值：返回创建的内存的首地址
        失败返回MAP_FAILED，(void *) -1
int munmap(void *addr, size_t length);
    - 功能：释放内存映射
    - 参数：
        - addr : 要释放的内存的首地址
        - length : 要释放的内存的大小，要和mmap函数中的length参数的值一样。

使用内存映射实现进程间通信：
    1.有关系的进程（父子进程）
        - 还没有子进程的时候
            - 通过唯一的父进程，先创建内存映射区
        - 有了内存映射区以后，创建子进程
        - 父子进程共享创建的内存映射区
    
    2.没有关系的进程间通信
        - 准备一个大小不是0的磁盘文件
        - 进程1 通过磁盘文件创建内存映射区
            - 得到一个操作这块内存的指针
        - 进程2 通过磁盘文件创建内存映射区
            - 得到一个操作这块内存的指针
        - 使用内存映射区通信

    注意：内存映射区通信，是非阻塞。

内存映射注意事项：

1.如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?
void * ptr = mmap(…);
ptr++; 可以对其进行++操作
munmap(ptr, len); // 错误,要保存地址
2.如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?
错误，返回MAP_FAILED
open()函数中的权限建议和prot参数的权限保持一致。
3.如果文件偏移量为1000会怎样?
偏移量必须是4K的整数倍，返回MAP_FAILED
4.mmap什么情况下会调用失败?
- 第二个参数：length = 0
- 第三个参数：prot
- 只指定了写权限
- prot PROT_READ | PROT_WRITE
第5个参数fd 通过open函数时指定的 O_RDONLY / O_WRONLY
5.可以open的时候O_CREAT一个新文件来创建映射区吗?
- 可以的，但是创建的文件的大小如果为0的话，肯定不行
- 可以对新的文件进行扩展
- lseek()
- truncate()
6.mmap后关闭文件描述符，对mmap映射有没有影响？
int fd = open(“XXX”);
mmap(,fd,0);
close(fd);
映射区还存在，创建映射区的fd被关闭，没有任何影响。
7.对ptr越界操作会怎样？
void * ptr = mmap(NULL, 100,);
4K
越界操作操作的是非法的内存 -> 段错误>

例：用内存映射完成父子进程之间的通信

#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <wait.h>

int main() {

    // 1.打开一个文件
    int fd = open("test.txt", O_RDWR);
    int size = lseek(fd, 0, SEEK_END);  // 获取文件的大小

    // 2.创建内存映射区
    void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 3.创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        wait(NULL);
        // 父进程
        char buf[64];
        strcpy(buf, (char *)ptr);
        printf("read data : %s\n", buf);
       
    }else if(pid == 0){
        // 子进程
        strcpy((char *)ptr, "nihao a, son!!!");
    }

    // 关闭内存映射区
    munmap(ptr, size);

    return 0;
}

匿名映射

void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);

要进行匿名映射首先要在flag字段加上MAP_ANONYMOUS，这样就会忽略文件描述符字段，有些实现要求为-1。只能用在有血缘关系的进程之间。

信号

信号是 Linux 进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。

比较重要的信号：
SIGINT 当用户按下了<Ctrl+C>组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。 终止进程
SIGQUIT 用户按下<Ctrl+>组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信号。 终止进程
SIGKILL 无条件终止进程。该信号不能被忽略，处理和阻塞。 终止进程，可以杀死任何进程
SIGSEGV 指示进程进行了无效内存访问(段错误) 。 终止进程并产生core文件
SIGPIPE Broken pipe向一个没有读端的管道写数据。 终止进程
SIGCHLD 子进程结束时，父进程会收到这个信号。 忽略这个信号
SIGCONT 如果进程已停止，则使其继续运行。 继续/忽略
SIGSTOP 停止进程的执行。信号不能被忽略，处理和阻塞。 终止进程

信号的 5 中默认处理动作

• Term 终止进程
• Ign 当前进程忽略掉这个信号
• Core 终止进程，并生成一个Core文件
• Stop 暂停当前进程
• Cont 继续执行当前被暂停的进程

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
    - 功能：给任何的进程或者进程组pid, 发送任何的信号 sig
    - 参数：
        - pid ：
            > 0 : 将信号发送给指定的进程
            = 0 : 将信号发送给当前的进程组
            = -1 : 将信号发送给每一个有权限接收这个信号的进程
            < -1 : 这个pid=某个进程组的ID取反 （-12345）
        - sig : 需要发送的信号的编号或者是宏值，0表示不发送任何信号
        kill(getppid(), 9);
        kill(getpid(), 9);
        
int raise(int sig);
    - 功能：给当前进程发送信号
    - 参数：
        - sig : 要发送的信号
    - 返回值：
        - 成功 0
        - 失败 非0
    kill(getpid(), sig);   

void abort(void);
    - 功能： 发送SIGABRT信号给当前的进程，杀死当前进程
    kill(getpid(), SIGABRT);


#include <unistd.h>
unsigned int alarm(unsigned int seconds);
- 功能：设置定时器（闹钟）。函数调用，开始倒计时，当倒计时为0的时候，
    函数会给当前的进程发送一个信号：SIGALARM
- 参数：
    seconds: 倒计时的时长，单位：秒。如果参数为0，定时器无效（不进行倒计时，不发信号）。
        取消一个定时器，通过alarm(0)。
- 返回值：
    - 之前没有定时器，返回0
    - 之前有定时器，返回之前的定时器剩余的时间
- SIGALARM ：默认终止当前的进程，每一个进程都有且只有唯一的一个定时器。
    alarm(10);  -> 返回0
    过了1秒
    alarm(5);   -> 返回9
alarm(100) -> 该函数是不阻塞的
无论进程处于什么状态，不会影响计时。


#include <sys/time.h>
int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);
- 功能：设置定时器（闹钟）。可以替代alarm函数。精度微妙us，可以实现周期性定时
- 参数：
    - which : 定时器以什么时间计时
        ITIMER_REAL: 真实时间，时间到达，发送 SIGALRM   常用
        ITIMER_VIRTUAL: 用户时间，时间到达，发送 SIGVTALRM
        ITIMER_PROF: 以该进程在用户态和内核态下所消耗的时间来计算，时间到达，发送 SIGPROF
- new_value: 设置定时器的属性  
struct itimerval 
{      // 定时器的结构体
    struct timeval it_interval;  // 每个阶段的时间，间隔时间
    struct timeval it_value;     // 延迟多长时间执行定时器
};
struct timeval 
{        // 时间的结构体
    time_t      tv_sec;     //  秒数     
    suseconds_t tv_usec;    //  微秒    
};
过10秒后，每个2秒定时一次
- old_value ：记录上一次的定时的时间参数，一般不使用，指定NULL
    - 返回值：
    成功 0
    失败 -1 并设置错误号


#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
- 功能：设置某个信号的捕捉行为
- 参数：
    - signum: 要捕捉的信号
    - handler: 捕捉到信号要如何处理
        - SIG_IGN ： 忽略信号
        - SIG_DFL ： 使用信号默认的行为
        - 回调函数 :  这个函数是内核调用，程序员只负责写，捕捉到信号后如何去处理信号。
        回调函数：
            - 需要程序员实现，提前准备好的，函数的类型根据实际需求，看函数指针的定义
            - 不是程序员调用，而是当信号产生，由内核调用
            - 函数指针是实现回调的手段，函数实现之后，将函数名放到函数指针的位置就可以了。
- 返回值：
    成功，返回上一次注册的信号处理函数的地址。第一次调用返回NULL
    失败，返回SIG_ERR，设置错误号     


int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
捕捉信号后执行相应的动作

以下信号集相关的函数都是对自定义的信号集进行操作。
int sigemptyset(sigset_t *set);
    - 功能：清空信号集中的数据,将信号集中的所有的标志位置为0
    - 参数：set,传出参数，需要操作的信号集
    - 返回值：成功返回0， 失败返回-1
int sigfillset(sigset_t *set);
    - 功能：将信号集中的所有的标志位置为1
    - 参数：set,传出参数，需要操作的信号集
    - 返回值：成功返回0， 失败返回-1
int sigaddset(sigset_t *set, int signum);
    - 功能：设置信号集中的某一个信号对应的标志位为1，表示阻塞这个信号
    - 参数：
        - set：传出参数，需要操作的信号集
        - signum：需要设置阻塞的那个信号
    - 返回值：成功返回0， 失败返回-1
int sigdelset(sigset_t *set, int signum);
    - 功能：设置信号集中的某一个信号对应的标志位为0，表示不阻塞这个信号
    - 参数：
        - set：传出参数，需要操作的信号集
        - signum：需要设置不阻塞的那个信号
    - 返回值：成功返回0， 失败返回-1

int sigismember(const sigset_t *set, int signum);
    - 功能：判断某个信号是否阻塞
    - 参数：
        - set：需要操作的信号集
        - signum：需要判断的那个信号
    - 返回值：
        1 ： signum被阻塞
        0 ： signum不阻塞
       -1 ： 失败


int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
- 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）
- 参数：
    - how : 如何对内核阻塞信号集进行处理
        SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变
            假设内核中默认的阻塞信号集是mask， mask | set
        SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞
            mask &= ~set
        SIG_SETMASK:覆盖内核中原来的值
            
    - set ：已经初始化好的用户自定义的信号集
    - oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL
- 返回值：
    成功：0
    失败：-1
    设置错误号：EFAULT、EINVAL

int sigpending(sigset_t *set);
- 功能：获取内核中的未决信号集
- 参数：set,传出参数，保存的是内核中的未决信号集中的信息。


#include <signal.h>
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
- 功能：检查或者改变信号的处理。信号捕捉
- 参数：
    - signum : 需要捕捉的信号的编号或者宏值（信号的名称）
    - act ：捕捉到信号之后的处理动作
    - oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL
- 返回值：
    成功 0
    失败 -1
struct sigaction {
    // 函数指针，指向的函数就是信号捕捉到之后的处理函数
    void     (*sa_handler)(int);
    // 不常用
    void     (*sa_sigaction)(int, siginfo_t *, void *);
    // 临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号。
    sigset_t   sa_mask;
    // 使用哪一个信号处理对捕捉到的信号进行处理
    // 这个值可以是0，表示使用sa_handler,也可以是SA_SIGINFO表示使用sa_sigaction
    int        sa_flags;
    // 被废弃掉了
    void     (*sa_restorer)(void);
};


SIGCHLD信号产生的3个条件：
1.子进程结束
2.子进程暂停了
3.子进程继续运行
都会给父进程发送该信号，父进程默认忽略该信号。
使用SIGCHLD信号解决僵尸进程的问题。
收到子进程发送的SIGCHLD时利用回调函数进行回收子进程。


共享内存相关的函数
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
    - 功能：创建一个新的共享内存段，或者获取一个既有的共享内存段的标识。
        新创建的内存段中的数据都会被初始化为0
    - 参数：
        - key : key_t类型是一个整形，通过这个找到或者创建一个共享内存。
                一般使用16进制表示，非0值
        - size: 共享内存的大小
        - shmflg: 属性
            - 访问权限
            - 附加属性：创建/判断共享内存是不是存在
                - 创建：IPC_CREAT
                - 判断共享内存是否存在： IPC_EXCL , 需要和IPC_CREAT一起使用
                    IPC_CREAT | IPC_EXCL | 0664
        - 返回值：
            失败：-1 并设置错误号
            成功：>0 返回共享内存的引用的ID，后面操作共享内存都是通过这个值。


void *shmat(int shmid, const void *shmaddr, int shmflg);
    - 功能：和当前的进程进行关联
    - 参数：
        - shmid : 共享内存的标识（ID）,由shmget返回值获取
        - shmaddr: 申请的共享内存的起始地址，指定NULL，内核指定
        - shmflg : 对共享内存的操作
            - 读 ： SHM_RDONLY, 必须要有读权限
            - 读写： 0
    - 返回值：
        成功：返回共享内存的首（起始）地址。  失败(void *) -1


int shmdt(const void *shmaddr);
    - 功能：解除当前进程和共享内存的关联
    - 参数：
        shmaddr：共享内存的首地址
    - 返回值：成功 0， 失败 -1

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    - 功能：对共享内存进行操作。删除共享内存，共享内存要删除才会消失，创建共享内存的进行被销毁了对共享内存是没有任何影响。
    - 参数：
        - shmid: 共享内存的ID
        - cmd : 要做的操作
            - IPC_STAT : 获取共享内存的当前的状态
            - IPC_SET : 设置共享内存的状态
            - IPC_RMID: 标记共享内存被销毁
        - buf：需要设置或者获取的共享内存的属性信息
            - IPC_STAT : buf存储数据
            - IPC_SET : buf中需要初始化数据，设置到内核中
            - IPC_RMID : 没有用，NULL

key_t ftok(const char *pathname, int proj_id);
    - 功能：根据指定的路径名，和int值，生成一个共享内存的key
    - 参数：
        - pathname:指定一个存在的路径
            /home/nowcoder/Linux/a.txt
            / 
        - proj_id: int类型的值，但是这系统调用只会使用其中的1个字节
                   范围 ： 0-255  一般指定一个字符 'a'


问题1：操作系统如何知道一块共享内存被多少个进程关联？
    - 共享内存维护了一个结构体struct shmid_ds 这个结构体中有一个成员 shm_nattch
    - shm_nattach 记录了关联的进程个数

问题2：可不可以对共享内存进行多次删除 shmctl
    - 可以的
    - 因为shmctl 标记删除共享内存，不是直接删除
    - 什么时候真正删除呢?
        当和共享内存关联的进程数为0的时候，就真正被删除
    - 当共享内存的key为0的时候，表示共享内存被标记删除了
        如果一个进程和共享内存取消关联，那么这个进程就不能继续操作这个共享内存。也不能进行关联。

    共享内存和内存映射的区别
    1.共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）
    2.共享内存效果更高
    3.内存
        所有的进程操作的是同一块共享内存。
        内存映射，每个进程在自己的虚拟地址空间中有一个独立的内存。
    4.数据安全
        - 进程突然退出
            共享内存还存在
            内存映射区消失
        - 运行进程的电脑死机，宕机了
            数据存在在共享内存中，没有了
            内存映射区的数据 ，由于磁盘文件中的数据还在，所以内存映射区的数据还存在。

    5.生命周期
        - 内存映射区：进程退出，内存映射区销毁
        - 共享内存：进程退出，共享内存还在，标记删除（所有的关联的进程数为0），或者关机
            如果一个进程退出，会自动和共享内存进行取消关联。

阻塞信号集：
代表动作位，根据该位来决定是否对信号进行处理。
未决信号集：
代表状态为，表示的是这个信号是否被处理。

例:编写一个程序，把所有的常规信号（1-31）的未决状态打印到屏幕,设置某些信号是阻塞的（通过键盘产生这些信号），观察未决状态位，然后取消阻塞查看动作。

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
using namespace std;
int main()
{
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);
    sigprocmask(SIG_BLOCK, &set, NULL);
    int num = 0;
    while (1)
    {
        ++num;
        sigset_t tmp;
        sigemptyset(&tmp);
        sigpending(&tmp);
        for (int i = 0; i < 32; ++i)
        {
            if (sigismember(&tmp, i))
                cout << '1';
            else
                cout << '0';
        }
        sleep(1);
        cout << endl;
        if (num == 10)
        {
            sigprocmask(SIG_UNBLOCK, &set, NULL);
        }
    }

    return 0;
}

内核实现信号捕捉的过程：

利用共享内存进行进程通信的例子：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main()
{
    int shmid = shmget(0x1, 1024, IPC_CREAT | 0664);
    void *ptr = shmat(shmid, NULL, 0);
    char str[505] = {0};
    scanf("%s", str);
    memcpy(ptr, str, strlen(str) + 1);
    getchar();
    getchar();
    shmdt(ptr);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main()
{
    int shmid = shmget(0x1, 0, IPC_CREAT);
    void *ptr = shmat(shmid, NULL, 0);
    printf("%s\n",(char *)ptr);
    shmdt(ptr);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

守护进程

进程组：
进程组就是一组进程，进程组的组号是创建进程组的进程的PID，创建该进程组的进程是这个组的首进程，新进程会继承父进程的组ID，进程组的生命周期从创建时刻开始，到所有进程离开组结束，不是以首进程离开结束。
会话：
是一组进程组，会话首进程是创建该新会话的进程，其进程 ID 会成为会话 ID。新进程会继承其父进程的会话 ID。一个会话中的所有进程共享单个控制终端。控制终端会在会话首进程首次打开一个终端设备时被建立。
守护进程：
一种长期在后台运行的服务进程。

pid_t getpgrp(void);  //获得组id
pid_t getpgid(pid_t pid);    //获得组id
int setpgid(pid_t pid, pid_t pgid);    //设置组id
pid_t getsid(pid_t pid);   //获取会话id
pid_t setsid(void);   //创建会话

守护进程创建过程：

• 执行一个 fork()，之后父进程退出，子进程继续执行。
• 子进程调用 setsid() 开启一个新会话。
• 清除进程的 umask 以确保当守护进程创建文件和目录时拥有所需的权限。
• 修改进程的当前工作目录，通常会改为根目录（/）。
• 关闭守护进程从其父进程继承而来的所有打开着的文件描述符。
• 在关闭了文件描述符0、1、2之后，守护进程通常会打开/dev/null 并使用dup2()
• 使所有这些描述符指向这个设备。
• 核心业务逻辑

守护进程创建模板代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <iostream>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/time.h>
#include <time.h>
#include <signal.h>
using namespace std;
int main()
{
    pid_t pid = fork();
    if (pid > 0)
        exit(0);
    setsid();
    umask(02);
    chdir("/");
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, 0);
    dup2(fd, 1);
    dup2(fd, 2);

    //服务

    return 0;
}