C++项目实战--01

父子进程虚拟地址空间情况

• fork()以后，子进程的用户区数据和父进程一样。内核区也会拷贝过来，但是pid不一样。

• fork返回值，父进程pid大于0，子进程pid等于0。

• 父进程和子进程运行在不同的内存空间。

• Linux的fork()使用写时拷贝，写时拷贝是一种推迟甚至避免拷贝数据的技术。读时共享，写时复制。

• 父子进程之间的关系。

• fork()函数的返回值。父进程中pid>0,返回子进程的PID，子进程返回0。

• pcb中一些数据，当前进程的id，pid，ppid，信号集。

• 子进程刚被创建时，还没有进行写数据的操作，用户区的数据和文件描述符都是一样的。

父子进程关系及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函数族的作用是根据指定的文件名找到可执行文件，并用它来取代进程的内容，换句话说，就是在调试进程内部执行一个可执行文件。
• exec函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据段和堆栈都已被新内容取代掉，只留下进程ID等一些表面上的信息保持原样。只有调用失败了，他们才会返回-1，从原程序的调用点接着往下执行。
• int execl(const char *path, const char *arg,…/ * char( *) NULL */)
• int execlp(const char *file, const char *arg, …/ *char( *) NULL */)
• path：需要指定的执行的文件的路径或者名称。
• arg：是执行可执行文件需要的参数列表。第一个参数一般没有什么作用，为了方便，一般写的是可执行的程序的名称。从第二个参数开始，就是程序执行所需的参数列表。参数最后需要以null结束(哨兵)。
• 返回值：出错返回-1调用成功没有返回值。
• execlp()会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。

进程退出，孤儿进程，僵尸进程。

进程退出

#include 
void exit(int status);
//exit()会在调用_exit系统调用之前，刷新I/O缓冲，关闭文件描述符。

#include
void _exit(int status);

• status参数：进程退出时的一个状态信息，父进程回收子进程资源的时候可以获取到。

孤儿进程

• 父进程运行结束后，但子进程还在运行(未运行结束)，这样的子进程就称为孤儿进程。
• 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置成init，而init进程会循环地wait()他的已经退出的子进程。
• 这样当一个孤儿进程结束了其生命周期的时候，init进程会处理他的善后工作。因此孤儿进程并不会有什么危害。

僵尸进程

• 每个进程结束后，都会释放自己地址空间中的用户区数据，内核区的PCB没有办法自己释放掉，需要父进程去释放。
• 进程终止时，父进程尚未回收，子进程残留资源存放在内核中，变成僵尸进程
• 僵尸进程不能被kill -9 杀死。
• 如果父进程不调用wait()或waitpid()的话，那么保留的信息就不会释放，其进程号就会一直占用。

wait函数

进程回收

• 在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等。但是仍然为其保留一定的信息，这些信息主要指进程控制块PCB的信息(包括进程号，退出状态，运行时间等)
• 父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。
• wait函数会阻塞，waitpid可以设置不阻塞，还可以指定等待哪个子进程结束。
• 一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。

#include
#include

pid_t wait(int *wstatus)
        // 功能：等待任意一个子进程结束，如果一个子进程结束了，此函数会回收子进程的资源。
        // 参数：进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
        //返回值：成功返回被回收的子进程的ID，失败-1。(所有的子进程都结束，调用函数失败)
    //调用wait函数的进程会被挂起(阻塞)，直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒。
    //如果没有子进程，函数立刻返回，返回-1，如果子进程都已经结束了也会立即返回-1，并回收子系统的资源。

退出信息相关的宏函数
WIFEXITED(status)：非零，进程正常退出。
WEXITSTATUS(status)：如果上宏为真，获取进程退出的状态。
WIFSIGNALED(status)：非零，进程异常终止
WIERMSIG(status)：如果上宏为真，获取使进程终止的信号编号。

waitpid函数

#include
#include

pid_t waitpid(pid_t pid,int *wstatus,int options);

• 功能：回收指定进程号的子进程。可以设置是否阻塞。
• 参数：

  • pid>0：某个子进程的pid

  • pid=0：回收当前进程组的所有子进程

  • pid=-1：回收所有的子进程，相当于wait().

  • pid<-1：某个进程组的组id的绝对值，回收指定进程组中的子进程。

  • options：设置阻塞或者非阻塞。

    • 0：阻塞
    • WNOHANG：非阻塞

  • 返回值：

    • 大于0 ： 返回子进程的id
    • 等于0：options=WNOHANG，表示还有子进程活着。
    • 等于-1：错误，或者没有子进程。

进程间通信

• 进程是一个独立的资源分配单位，不同进程之间的资源是独立的，没有关联，不能再一个进程中直接访问另一个进程的资源。
• 但是，进程不是孤立的，不同进程需要进行信息的交互和状态的传递，因此需要进程间的通信(IPC)。
• 进程间通信的目的：数据传输，通知时间，资源共享，进程控制。

Linux进程间通信

• 同一主机进程间通信：

  • Unix进程间通信方式：匿名管道，有名管道，信号。
  • System V进程间通信方式 与 POSIX进程间通信方式：信息队列，共享内存，信号量。

• 不同主机(网络)进程间通信：Socket

匿名管道概述

• 管道也叫无名(匿名)管道，他是UNIX系统IPC(进程间通信)的最古老形式 ,所有的UNIX系统都支持这种通信方式。
• 管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。
• 管道拥有的文件特质：读操作，写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。
• 一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。
• 通过管道传的数据是顺序的，从管道中读取出来的字节顺序和它们被写入管道的顺序是完全一样的。
• 在管道中的数据传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。
• 从管道读数据是一次性操作，数据一旦被读走，他就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用lseek()来随机访问数据。
• 匿名管道只能在具有公共祖先的进程(父进程与子进程，或者两个兄弟进程，具有亲缘关系)之间使用。
• 管道的数据结构：循环队列。

父子进程通过匿名管道通信

• 创建匿名管道

#include
int pipe(int pipefd[2])
/*
参数：int pipefd[2] 这个数组是一个传出参数。pipefd[0]对应管道的读端，pipefd[1]对应管道的写端。
返回值：成功返回0，失败返回-1。
匿名管道只能用于具有关系的进程之间的通信。
管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞。
*/

• 查看管道缓冲大小命令

ulimit -a

• 查看管道缓冲大小函数

#include
long fpathconf(int fd,int name)

匿名管道通信案例

• 关闭写段：close(pipefd[0]);
• 关闭读端：close(pipefd[1]);

实现 ps aux | grep xxx 父子进程间通信

• 子进程：ps aux，子进程结束后将数据发送给父进程。
• 父进程：获取到数据，过滤
• pipe(),execlp(),dup2(),子进程将标准输出 stdout_fileno 重定向到管道的写段。

管道的读写特点和管道设置为非阻塞

使用管道时，需要注意一下几种特殊的情况(假设都是阻塞I/O操作)

• 所有的指向管道写端的文件描述符都关闭了(管道写端引用计数为0)，进程从管道的读端读数据，那么管道中剩余的数据被读取以后，再次read会返回0。就像读到文件末尾一样
• 如果有指向管道写端的文件描述符没有关闭(管道的写端引用计数>0),而持有管道写端的进程也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，再次read会阻塞，直到管道中有数据可以读了才读取数据并返回。
• 如果所有指向管道读端的文件描述符都关闭了，这个时候有进程往管道中写数据，该进程会收到一个信号SIGPIPE,通常会导致进程异常终止。
• 如果有指向管道读端的文件描述符没有关闭，而持有管道读端的进程也没有从管道中读数据，这时有进程向管道中写数据，那么管道被写满的时候再次write会阻塞，直到管道中有空位置才能再次写入数据并返回。

总结

• 读管道：管道中有数据，read返回实际读到的字节数。管道中无数据，写端被全部关闭，read返回0，写端没有完全关闭，read阻塞等待。
• 写管道：管道的读端被关闭，进程异常终止。管道读端没有关闭，管道已满，write阻塞，管道没有满，write将数据写入，并返回实际写入的字节数。

设置管道非阻塞

• int flags = fcntl(fd[0],F_GETFL); //获取原来的flag
• flags |= O_NONBLOCK; //修改flag的值
• fcnt1(fd[0],F_SETFL,flags); //设置新的flag

有名管道介绍及使用

• 有名管道不同于匿名管道之处在于他提供了一个路径名与之关联，以FIFO的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与FIFO的创建进程不存在亲缘关系的进程只要可以访问该路径，就能够彼此通过FIFO相互通信，因此通过FIFO不相关的进程也能交换数据。
• 一旦打开了FIFO，就能在它上面使用与操作匿名管道和其他文件系统调用一样的I/O系统调用了(如read(),write(),close())。与管道一样，FIFO也有一个写入端和读取端，并且从管道中读取数据的顺序和写入的顺序是一样的，FIFO的名称也由此而来：先入先出。
• 通过命令创建有名管道：mkfifo 名字
• 通过函数创建有名管道：

#include 
#include
int mkfifo(const char *pathname,mode_t mode)

有名管道的注意事项

• 一个为只读而打开一个管道的进程会阻塞，直到另一个进程为只写打开管道
• 一个为只写而打开一个管道的进程会阻塞，直到另一个进程为只读打开管道

读管道

• 管道中有数据，read返回实际读到的字节数
• 管道中无数据，
• 管道写端被全部关闭，read返回0，相当于读到文件的末尾。
• 写端没有全部被关闭，read阻塞等待

写管道

• 管道读端被全部关闭，进程异常终止，收到一个SIGPIPE信号
• 管道读端没有全部关闭，
• 管道已经满了，write会阻塞
• 管道没有满，write将字节写入，并返回写入的字节数。

有名管道实现简单版聊天功能

进程A

• 以只写的方式打开管道1
• 以只读的方式打开管道2
• 循环的写读数据

进程B

• 以只读的方式打开管道1
• 以只写的方式打开管道2
• 循环的读写数据

内存映射

• 内存映射：将磁盘文件的数据映射到内存，用户通过修改内存就能够修改磁盘文件。
• 内存映射相关系统调用

#include
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参数的值一样。

信号概述

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

• 发往进程的诸多信号，通常都是源于内核。引发内核为进程产生信号的各类事件如下：

  • 对于前台进程，用户可以通过输入特殊的终端字符来给它发送信号。比如输入Ctrl+C 通常会给进程发送一个中断信号。
  • 硬件发生异常，即硬件检测到一个错误条件并通知内核，随即再由内核发送相应信号给相关进程。比如执行一条异常的机器语言指令，诸如被 0 除，或者引用了无法访问的内存区域。
  • 系统状态变化，比如 alarm 定时器到期将引起 SIGALRM 信号，进程执行的 CPU 时间超限，或者该进程的某个子进程退出。
  • 运行 kill 命令或调用 kill 函数。

• 使用信号的两个主要目的是：

  • 让进程知道已经发生了一个特定的事情
  • 强迫进程执行它自己代码中的信号处理程序

• 信号的特点：简单，不能携带大量信息，满足某个特定条件才发送，优先级比较高。

• 查看系统定义的信号列表：kill –l 。 前 31 个信号为常规信号，其余为实时信号。

Linux信号一览表

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

信号的五种默认处理动作

• 查看信号的详细信息：man 7 signal

• 信号的 5 中默认处理动作：

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

• 信号的几种状态：产生、未决、递达

• SIGKILL 和 SIGSTOP 信号不能被捕捉、阻塞或者忽略，只能执行默认动作。

kill,raise,abort函数

    int kill(pid_t pid, int sig);
        - 功能：给任何的进程或者进程组pid, 发送任何的信号 sig
        - 参数：
            - pid ：
                > 0 : 将信号发送给指定的进程
                = 0 : 将信号发送给当前的进程组
                = -1 : 将信号发送给每一个有权限接收这个信号的进程
                < -1 : 这个pid=某个进程组的ID取反 （-12345）
            - sig : 需要发送的信号的编号或者是宏值，0表示不发送任何信号

    int raise(int sig);
        - 功能：给当前进程发送信号
        - 参数：
            - sig : 要发送的信号
        - 返回值：
            - 成功 0
            - 失败 非0

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

alarm函数

#include 
    unsigned int alarm(unsigned int seconds);
        - 功能：设置定时器（闹钟）。函数调用，开始倒计时，当倒计时为0的时候，
                函数会给当前的进程发送一个信号：SIGALARM
        - 参数：
            seconds: 倒计时的时长，单位：秒。如果参数为0，定时器无效（不进行倒计时，不发信号）。
                    取消一个定时器，通过alarm(0)。
        - 返回值：
            - 之前没有定时器，返回0
            - 之前有定时器，返回之前的定时器剩余的时间
    - SIGALARM ：默认终止当前的进程，每一个进程都有且只有唯一的一个定时器。

• 实际的时间 = 内核时间 + 用户时间 + 消耗的时间。进行文件IO操作的时候比较浪费时间
• 定时器，与进程的状态无关（自然定时法）。无论进程处于什么状态，alarm都会计时。

setitimer 定时器函数

#include 
    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;    //  微秒    
                };
         - old_value ：记录上一次的定时的时间参数，一般不使用，指定NULL
         - 返回值：
            成功 0
            失败 -1 并设置错误号

signal 信号扑捉函数

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

        - 返回值：
            成功，返回上一次注册的信号处理函数的地址。第一次调用返回NULL
            失败，返回SIG_ERR，设置错误号
            
    SIGKILL SIGSTOP不能被捕捉，不能被忽略。

信号集及相关函数

• 用户通过键盘 Ctrl + C, 产生2号信号SIGINT (信号被创建)

• 信号产生但是没有被处理 （未决）

• 在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）

• SIGINT信号状态被存储在第二个标志位上

  • 这个标志位的值为0， 说明信号不是未决状态
  • 这个标志位的值为1， 说明信号处于未决状态

• 这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较

• 阻塞信号集默认不阻塞任何的信号

• 如果想要阻塞某些信号需要用户调用系统的API

• 在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了

• 如果没有阻塞，这个信号就被处理

• 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号就被处理

信号集相关的函数

• 以下信号集相关的函数都是对自定义的信号集进行操作。

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 ： 失败

sigprocmask

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,传出参数，保存的是内核中的未决信号集中的信息。

sigaction

#include 
    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);
    };

内核实现信号捕捉的过程

• 在执行主控制流程的某条指令时因为中断、异常或系统调用进入内核
• 内核处理完异常准备回用户模式之前先处理当前进程中可以递送的信号
• 如果信号的处理动作为自定义的信号处理函数，则回到用户模式执行信号处理函数（而不是回到主控制流程）
• 信号处理函数返回时执行特殊的系统调用sigreturn再次进入内核
• 返回用户模式从主控制流程中上次被中断的地方继续向下执行

SIGCHLD 信号

• SIGCHLD信号产生的条件
  • 子进程终止时
  • 子进程接收到SIGSTOP信号停止时
  • 子进程处在停止态，接受到SIGCONT后唤醒后
• 以上三种条件都会给父进程发送SIGCHLD信号，父进程默认会忽略该信号。
• 使用SIGCHLD信号解决僵尸进程的问题。

共享内存(1)

共享内存相关的函数
#include 
#include 

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'

共享内存(2)

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

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

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

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