• linux并发服务器 —— 多进程并发 - 进程间的通信及实践（五）

     进程间的通信

    进程是一个独立的资源分配单元，不能在一个进程中直接访问另一个进程的资源；

    进程间通信（IPC）的目的：

    1. 数据传输 - A进程发送数据给B进程

    2. 通知事件 - eg. 进程终止通知父进程

    3. 资源共享 - 多个进程之间共享资源，需要内核提供互斥和同步机制

    4. 进程控制 - 进程控制另一个进程的执行

    匿名管道（管道）

    UNIX系统IPC的最古老形式，所有UNIX系统都支持这种通信机制；

    ls | wc -l : 统计一个目录中的文件数目；| - 管道符

    管道的特点

    1.是一个内核内存中维护的缓冲器，存储能力有限，不同操作系统大小不同；

    2. 匿名管道没有文件实体，有名管道有文件实体（但不存储数据），可以按照操作文件的方式对管道进行操作；

    3. 一个管道是一个字节流，使用管道不存在消息/消息边界的概念；不管写入数据块多大，可以读任意大小的数据块；

    4. 先进先出；

    5. 管道是半双工的，数据传递方向是单向的；

    6. 读数据是一次性操作，读了就没了，并且无法随机访问数据；

    7. 匿名管道只能在有亲缘关系的进程之间进行通信；

    管道的数据结构 - 循环队列

    1. /*
    2.     #include 
    3.     int pipe(int pipefd[2]);
    4.         功能：创建一个匿名管道 用于进程间通信
    5.         参数： 是一个传出参数
    6.             pipefd[0] - 管道的读端
    7.             pipefd[1] - 管道的写端
    8.         返回值：
    9.             成功 - 0
    10.             失败 - -1
    11.         管道默认是阻塞的，管道中没有数据read阻塞，管道满了write阻塞
    12. */
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. using namespace std;
    21.  
    22. // 子进程写 父进程读
    23. int main(){
    24.  
    25.     // fork之前创建管道
    26.     int pipefd[2];
    27.     int ret = pipe(pipefd);
    28.     if(ret == -1){
    29.         perror("pipe");
    30.         return -1;
    31.     }
    32.  
    33.     pid_t pid = fork();
    34.     if(pid>0){
    35.         cout<<"我是你爹"<
    36.         while(1){
    37.             char buf[1024];
    38.             int len = read(pipefd[0] , buf , sizeof(buf));
    39.             cout<<"父进程 "<<getpid()<<"读到了: "<
    40.  
    41.             char str[10] = "hello zz";
    42.             write(pipefd[1] , str , sizeof(str));
    43.             sleep(2);
    44.  
    45.         }
    46.     }
    47.     else if(pid == 0){
    48.         // 写数据
    49.         cout<<"我是你儿子"<
    50.         while(1){
    51.             char str[10] = "hello 647";
    52.             write(pipefd[1] , str , sizeof(str));
    53.             sleep(2);
    54.  
    55.             char buf[1024];
    56.             int len = read(pipefd[0] , buf , sizeof(buf));
    57.             cout<<"子进程 "<<getpid()<<"读到了: "<
    58.         }
    59.     }
    60.  
    61.     return 0;
    62. }

    查管道大小：

    1. ulimit - a

    2. fpathconf(int fd , int name); name - _PC_PIPE_BUF 获取管道大小

    通过管道实现ps aux

    1. /*
    2.     实现ps aux | grep
    3.     父子进程通信 - 子进程 ps aux，结束后发送给父进程 过滤即可
    5.     pipe() - 创建管道
    6.     execlp() - 调用ps aux
    7.     将子进程标准输出stdout_fileno重定向到父进程 - 管道写端 dup2
    8. */
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. using namespace std;
    17.  
    18. // 子进程写 父进程读
    19. int main(){
    20.  
    21.     int fd[2];
    22.     int ret = pipe(fd);
    23.  
    24.     if(ret == -1){
    25.         perror("pipe");
    26.         exit(0);
    27.     }
    28.  
    29.     pid_t pid = fork();
    30.  
    31.     if(pid > 0){
    32.         close(fd[1]);
    33.         char buf[1024] = {0};
    34.         int len = -1;
    35.         while((len = read(fd[0] , buf , sizeof(buf) - 1)) > 0){
    36.             cout<
    37.             memset(buf , 0 , 1024);
    38.         }
    39.         wait(NULL);
    40.     }
    41.     else if(pid == 0){
    42.         close(fd[0]);
    43.         dup2(fd[1] , STDOUT_FILENO);
    44.         execlp("ps" , "ps" , "aux" , NULL);
    45.         perror("execlp");
    46.         exit(0);
    47.     }
    48.     else{
    49.         perror("fork");
    50.         exit(0);
    51.     }
    52.  
    53.     return 0;
    54. }
    管道的读写特点

    （假设都是阻塞I/O操作）

    1. 所有指向管道的写端描述符都关闭（写端引用计数为0），剩余数据都读完后再read会返回0；

    2. 如果有指向管道写端的文件描述符没有关闭（引用计数>0），但没有写数据，read会阻塞；

    3. 读端都关闭，进程向管道写数据，该进程会收到信号SIGPIPE，通常会导致进程异常终止；

    4. 读端没有完全关闭，而持有管道读端的进程也没从管道读数据，写数据写满了就阻塞；

    设置管道非阻塞

    通过设置文件描述符非阻塞；

    1. // 通过fcntl(fd , F_GETFL)获得状态，再设置可实现管道非阻塞
    2. int flg = fcntl(pipefd[0] , F_GETFL);
    3. flg |= O_NONBLOCK;
    4. int cnt = fcntl(pipefd[0] , F_SETFL , flg);

    有名管道（FIFO文件）

    提供一个路径名与之关联，有文件的实体，以FIFO文件形式存在文件系统中，没有亲缘关系也能通过有名管道实现通信；

    数据结构也是一个环形队列；

    与匿名管道的区别：

    1. FIFO在文件系统中作为特殊文件存在，但文件里没有内容，内容存在内存里的缓冲区；

    2. FIFO退出后，文件会保留；

    3. FIFO有名字，不相关进程可以通信；

    通过mkfifo 名字创建有名管道，创建后可以用open打开，常见文件I/O函数都可以用；

    有名管道的读端写端实践：

    1. /*
    2.     创建fifo文件
    3.     1. 命令 - mkfifo 名字
    4.     2. 函数 - int mkfifo(const char *pathname, mode_t mode);
    5.         参数：
    6.             pathname - 管道名称的路径
    7.             mode - 权限 和open的一样
    8.         返回值：
    9.             成功 - 0
    10.             失败 - -1 并设置 errno
    12.     #include 
    13.     #include 
    15.        
    16. */
    17. // 向管道写数据
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. using namespace std;
    26.  
    27. int main(){
    28.  
    29.     int dec = access("fifo" , F_OK);
    30.     if(dec==-1){
    31.         cout<<"管道不存在"<
    32.         int ret = mkfifo("fifo" , 0664);
    33.  
    34.         if(ret == -1){
    35.             perror("mkfifo");
    36.             exit(0);
    37.         }
    38.     }
    39.  
    40.     // 打开管道
    41.     int fd = open("fifo" , O_WRONLY);
    42.     if(fd == -1){
    43.         perror("open");
    44.         exit(0);
    45.     }
    46.  
    47.     for(int i = 0 ; i<100 ; i++){
    48.         char buf[1024];
    49.         sprintf(buf , "hello 647 : %d" , i);
    50.         cout<
    51.         write(fd , buf , sizeof(buf));
    52.         sleep(1);
    53.     }
    54.     close(fd);
    55.     return 0;
    56. }
    57.  
    58.  
    59. // 向管道读数据
    60. #include 
    61. #include 
    62. #include 
    63. #include 
    64. #include 
    65. #include 
    66. #include 
    67. using namespace std;
    68.  
    69. int main(){
    70.     // 打开管道
    71.     int fd = open("fifo" , O_RDONLY);
    72.     if(fd == -1){
    73.         perror("open");
    74.         exit(0);
    75.     }
    76.  
    77.     while(1){
    78.         char buf[1024] = {0};
    79.         int len = read(fd , buf , sizeof(buf));
    80.         if(len == 0){
    81.             cout<<"写端断开"<
    82.             break;
    83.         }
    84.         cout<<"get: "<
    85.     }
    86.  
    87.     close(fd);
    88.  
    89.     return 0;
    90. }

    一个为只读而打开一个管道的进程会阻塞，直到有写的权限打开管道，反之同理；

    读管道：

            管道中有数据，read返回实际读到的字节数

            管道无数据

                    写端全关闭，read返回0

                    写端没有全关闭，read阻塞

    写管道：

            读端全关闭，异常终止SIGPIPE

            读端没有全关闭

                    管道满了，阻塞

                     没满，正常写入即可，返回实际写入字节数

    有名管道实现聊天功能
    1. /*
    2.     实现进程A、B的聊天功能
    3.     需要两个管道 一个A读B写 一个B读A写
    4.     进程A：
    5.         1. 只写打开fifo1
    6.         2. 只读打开fifo2
    7.         3. 循环读写数据
    8.             while(1){
    9.                 获取键盘录入 fgets
    10.                 write fifo1
    12.                 read fifo2
    13.             }
    14.     进程B与进程A相反即可
    15.             while(1){
    16.                 read fifo1
    17.                 获取键盘录入 fgets
    18.                 write fifo2
    19.             }
    20. */
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28. #include 
    29. using namespace std;
    30.  
    31. int main(){
    32.     // 判断管道文件是否存在
    33.     int ret = access("fifo1" , F_OK);
    34.     if(ret == -1){
    35.         ret = mkfifo("fifo1" , 0664);
    36.         if(ret == -1){
    37.             perror("mkfifo");
    38.             exit(0);
    39.         }
    40.     }
    41.  
    42.     ret = access("fifo2" , F_OK);
    43.     if(ret == -1){
    44.         ret = mkfifo("fifo2" , 0664);
    45.         if(ret == -1){
    46.             perror("mkfifo");
    47.             exit(0);
    48.         }
    49.     }
    50.  
    51.     // 只写开fifo1
    52.     int fdw = open("fifo1" , O_WRONLY);
    53.     if(fdw == -1){
    54.         perror("open");
    55.         exit(0);
    56.     }
    57.     cout<<"打开fifo1成功..."<<"等待写入..."<
    58.  
    59.  
    60.     // 只读开fifo2
    61.     int fdr = open("fifo2" , O_RDONLY);
    62.     if(fdr == -1){
    63.         perror("open");
    64.         exit(0);
    65.     }
    66.     cout<<"打开fifo2成功..."<<"等待读取..."<
    67.  
    68.     char buf[128];
    69.     // 循环写读
    70.     while(1){
    71.         memset(buf , 0 , sizeof(buf));
    72.         // 获取输入数据
    73.         fgets(buf , sizeof(buf) , stdin);
    74.         // 写入
    75.         ret = write(fdw , buf , strlen(buf));
    76.         if(ret == - 1){
    77.             perror("write");
    78.             exit(0);
    79.         }
    80.  
    81.         // 读数据
    82.         memset(buf , 0 , sizeof(buf));
    83.         ret = read(fdr , buf , sizeof(buf));
    84.         if(ret<=0){
    85.             perror("read");
    86.             exit(0);
    87.         }
    88.         cout<<"进程A读到数据 - "<
    89.     }
    90.  
    91.     close(fdr);
    92.     close(fdw);
    93.  
    94. }
    95.  
    96.  
    97. #include 
    98. #include 
    99. #include 
    100. #include 
    101. #include 
    102. #include 
    103. #include 
    104. #include 
    105. using namespace std;
    106.  
    107. int main(){
    108.     // 判断管道文件是否存在
    109.     int ret = access("fifo1" , F_OK);
    110.     if(ret == -1){
    111.         ret = mkfifo("fifo1" , 0664);
    112.         if(ret == -1){
    113.             perror("mkfifo");
    114.             exit(0);
    115.         }
    116.     }
    117.  
    118.     ret = access("fifo2" , F_OK);
    119.     if(ret == -1){
    120.         ret = mkfifo("fifo2" , 0664);
    121.         if(ret == -1){
    122.             perror("mkfifo");
    123.             exit(0);
    124.         }
    125.     }
    126.  
    127.     // 只读开fifo1
    128.     int fdr = open("fifo1" , O_RDONLY);
    129.     if(fdr == -1){
    130.         perror("open");
    131.         exit(0);
    132.     }
    133.     cout<<"打开fifo1成功..."<<"等待读取..."<
    134.  
    135.  
    136.     // 只写开fifo2
    137.     int fdw = open("fifo2" , O_WRONLY);
    138.     if(fdw == -1){
    139.         perror("open");
    140.         exit(0);
    141.     }
    142.     cout<<"打开fifo2成功..."<<"等待写入..."<
    143.  
    144.     char buf[128];
    145.     // 循环写读
    146.     while(1){
    147.         // 读数据
    148.         memset(buf , 0 , sizeof(buf));
    149.         ret = read(fdr , buf , sizeof(buf));
    150.         if(ret<=0){
    151.             perror("read");
    152.             exit(0);
    153.         }
    154.         cout<<"进程B读到数据 - "<
    155.  
    156.          memset(buf , 0 , sizeof(buf));
    157.         // 获取输入数据
    158.         fgets(buf , sizeof(buf) , stdin);
    159.         // 写入
    160.         ret = write(fdw , buf , strlen(buf));
    161.         if(ret == - 1){
    162.             perror("write");
    163.             exit(0);
    164.         }
    165.     }
    166.  
    167.     close(fdr);
    168.     close(fdw);
    169.  
    170. }

    内存映射

    效率较高的IPC ， 直接对内存进行操作；将磁盘文件的数据映射到内存（栈和堆之间的地址空间），通过修改内存来修改磁盘文件；

    通过将磁盘文件映射到两个进程地址空间中实现进程间的通信；

    mmap - 文件映射到内存/munmap -  解除映射

    1. /*
    2.     
    4.     void *mmap(void *addr, size_t length, int prot, int flags,
    5.                 int fd, off_t offset);
    6.         功能： 映射一个文件到内存中
    7.         参数：
    8.             addr - 映射内存的首地址 - NULL 由内核指定
    9.             length - 映射的数据的长度 !=0 ， 建议文件长度 -> 分页整数倍
    10.                     获取文件长度 - stat lseek
    11.             prot -  对申请的内存映射区的操作权限
    12.                 PROT_EXEC - 执行
    13.                 PROT_READ - 读权限
    14.                 PROT_WRITE - 写权限
    15.                 PROT_NONE - 没有权限
    16.                 要操作映射内存，必须要有读的权限
    17.                 PROT_READ、PROT_READ|PROT_WRITE
    18.             flags
    19.                 MAP_SHARED - 映射区的数据自动和磁盘文件同步（进程通信必备）
    20.                 MAP_PRIVATE - 映射区的数据自动和磁盘文件不同步（copy on write）
    21.             fd - 磁盘文件描述符（open获得）
    22.                 - 文件大小!=0 ， open指定权限不能和prot有冲突（open>prot）
    23.             offset - 偏移量 必须是4K整数倍 一般不用；0 - 不偏移
    24.         返回值：创建好的内存首地址 ， 失败返回MAP_FAILED（void* -1）
    26.     int munmap(void *addr, size_t length);
    27.         功能：释放内存映射
    28.         参数：
    29.             addr - 释放内存的首地址
    30.             length - 要释放的内存大小 和mmap中的length保持一致
    32. */
    33.  
    34. /*
    35.     使用内存映射实现进程间的通信
    36.     1. 有关系的进程
    37.         没有子进程时，通过父进程创建内存映射区
    38.         父子进程共享创建的内存映射区
    39.     2. 没关系的进程
    40.         准备一个大小不是0的磁盘文件
    41.         进程1 通过磁盘文件创建内存映射 - 得到操作内存指针
    42.         进程2 通过磁盘文件创建内存映射 - 得到操作内存指针
    44.     NOTE：内存映射区通信是非阻塞的
    45. */
    46.  
    47. #include 
    48. #include 
    49. #include 
    50. #include 
    51. #include 
    52. #include 
    53. #include 
    54. #include 
    55. #include 
    56.  
    57.  
    58. using namespace std;
    59.  
    60. int main(){
    61.     //1.  打开文件
    62.     int fd = open("test.txt" , O_RDWR);
    63.  
    64.     if(fd == -1){
    65.         perror("open");
    66.         exit(0);
    67.     }
    68.     // 获取文件大小
    69.     int size = lseek(fd , 0 , SEEK_END);
    70.  
    71.     void* ptr = mmap(NULL , size , PROT_READ|PROT_WRITE , MAP_SHARED , fd , 0);
    72.     if(ptr == MAP_FAILED){
    73.         perror("mmap");
    74.         exit(0);
    75.     }
    76.  
    77.     // 创建子进程
    78.     pid_t pid = fork();
    79.     if(pid>0){
    80.         strcpy((char*) ptr , "我是你爹");
    81.         wait(NULL);
    82.     }
    83.     else if(pid == 0){
    84.         char buf[64];
    85.         strcpy(buf , (char*) ptr);
    86.         cout<<"子进程读到的数据："<
    87.     }
    88.  
    89.     munmap(ptr , size);
    90.     return 0;
    91. }
    NOTE

    1.如果对mmap的返回值(ptr)做++! I(ptr++)，munmap是否能够成功?

    可以对ptr进行++操作；

    但munmap需要传递内存的首地址，++后不能正确释放内存；


    2. 如果open时O_RDONLY，mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?

    错误，返回MAP_FAILED

    open函数中的权限建议与prot权限保持一致，大于等于也可；


    3. 如果文件偏移量为1000会怎样?

    文件偏移量必须是4k的整数倍 - 错误 返回MAP_FAILED


    4. mmap什么情况下会调用失败?

            - length = 0

            - prot的权限只指定了写 或 权限大于open

            ..............


    5. 可以open的时候O_CREAT一个新文件来创建映射区吗?

    可以！但是创建的文件大小如果为0则会出错

    可以对新的文件进行拓展 - lseek/truncate


    6. mmap后关闭文件描述符，对mmap映射有没有影响?

    不会产生问题；映射区仍然存在 创建映射区的fd关闭没什么影响


    7. 对ptr越界操作会怎样?

    void* ptr = mmap(NULL , 100 ...）

    4K

    越界操作操作的是非法内存 ——> 段错误

    通过内存映射实现文件拷贝
    1. // 使用内存映射实现拷贝
    2. /*
    3.     思路：
    4.         1. 原始文件进行映射
    5.         2. 创建一个新的文件（通过拓展，保证文件不为0）
    6.         3. 新文件的数据映射到内存
    7.         4. 通过内存拷贝 即可实现
    8.         5. 释放资源
    9. */
    10.  
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20.  
    21.  
    22. using namespace std;
    23.  
    24. int main(){
    25.     // 1.
    26.     int fd = open("old.txt" , O_RDWR);
    27.     if(fd == -1){
    28.         perror("open");
    29.         exit(0);
    30.     }
    31.     int size = lseek(fd , 0 , SEEK_END);
    32.     // 2.
    33.     int fdn = open("new.txt" , O_RDWR|O_CREAT , 0664);
    34.     if(fdn == -1){
    35.         perror("open");
    36.         exit(0);
    37.     }
    38.     truncate("new.txt" , size);
    39.     write(fdn , " " , 1);
    40.     // 3.
    41.     void* ptr1 = mmap(NULL , size , PROT_READ | PROT_WRITE , MAP_SHARED , fd , 0);
    42.     if(ptr1 == MAP_FAILED){
    43.         perror("mmap");
    44.         exit(0);
    45.     }
    46.     void* ptr2 = mmap(NULL , size , PROT_READ | PROT_WRITE , MAP_SHARED , fdn , 0);
    47.     if(ptr2 == MAP_FAILED){
    48.         perror("mmap");
    49.         exit(0);
    50.     }
    51.  
    52.     // 4.
    53.     memcpy(ptr2 , ptr1 , size);
    54.     // 5.
    55.     munmap(ptr2 , size);
    56.     munmap(ptr1 , size);
    57.     close(fdn);
    58.     close(fd);
    59.  
    60.     return 0;
    61. }

    匿名映射
    1. /*
    2.     匿名映射：不需要文件实体 只能用在父子进程之间的通信
    3.      - flags - MAP_ANONYMOUS fd指定为-1即可 offset为0
    4. */
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15.  
    16. using namespace std;
    17.  
    18. int main(){
    19.  
    20.     // 1. 创建匿名内存映射区
    21.     int len = 4096;
    22.     void* ptr = mmap(NULL , len , PROT_READ | PROT_WRITE , MAP_SHARED | MAP_ANONYMOUS , -1 , 0);
    23.     if(ptr == MAP_FAILED){
    24.         perror("mmap");
    25.         exit(0);
    26.     }
    27.  
    28.     // 父子进程间通信
    29.     pid_t pid = fork();
    30.     if(pid > 0){
    31.         strcpy((char*)ptr , "hello 647");
    32.         wait(NULL);
    33.     }
    34.     else if(pid == 0){
    35.         sleep(1);
    36.         cout<<(char*) ptr<
    37.     }
    38.  
    39.     int ret = munmap(ptr , len);
    40.     if(ret == -1){
    41.         perror("munmap");
    42.         exit(0);
    43.     }
    44.  
    45.     return 0;
    46. }

    信号概述

    信号是事件发生时对进程的通知机制 ， 有时称为软件中断（软件层次上对中断机制的模拟 - 异步通信）；

    信号通常源于内核 ，引发内核产生信号的事件：

    1. 前台进程，用户通过输入特殊中断字符发送信号；eg. Ctrl+c

    2. 硬件发生异常

    3. 系统状态发生变化 - alarm定时器到期引起SIGALRM

    4. kill 命令

    信号的特点：

    1. 简单

    2. 不能携带大量信息

    3. 满足某个特定条件才能发送

    4. 优先级较高*

    查看系统定义的信号列表：kill -l；1~31为常规信号 ， 其余为预定义好的实时信号

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

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

    kill、raise、abort函数

    Core处理动作会生成Core文件 - 保存进程异常退出的错误信息

    1. #include 
    2. #include 
    3.  
    4. int main(){
    5.     char* buf;
    6.     strcpy(buf , "hello");
    7.     return 0;
    8. }

     要生成core文件需要先通过ulimit修改core文件的大小；

    注意这里生成不了core文件可以通过sudo service apport stop关闭错误收集系统；

    进gdb调试后，core-file core即可打印错误信息；

    1. /*
    2.     int kill (pid_t pid, int sig);
    3.         功能：给任何进程/进程组pid，发送任何信号sig
    4.         参数：
    5.             pid
    6.                 >0 - 将信号发送给指定进程
    7.                 0 - 将信号发送给当前进程组所有进程
    8.                 -1 - 将信号发送给每一个有权限接收这个信号的进程
    9.                 <-1 - abs(pid)进程组
    10.             sig - 信号编号/宏值，如果为0表示不发送任何信号
    11.         kill(getppid() , 9);
    13.     int raise (int sig);
    14.         功能：给当前进程发送信号(给自己)
    15.         参数：sig - 要发送的信号
    16.         返回值：
    17.             成功 - 0
    18.             失败 - ！0
    20.     void abort(void);
    21.         功能：发送SIGABRT给当前进程，杀死当前进程
    22. */
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28. using namespace std;
    29.  
    30. int main(){
    31.  
    32.     pid_t pid = fork();
    33.  
    34.     if(pid == 0){
    35.         int i = 0;
    36.         for(i ; i<5 ; i++){
    37.             cout<<"子进程"<
    38.             sleep(1);
    39.         }
    40.     }
    41.     else if(pid > 0){
    42.         cout<<"父进程"<
    43.         sleep(2);
    44.         cout<<"杀死子进程"<
    45.         kill(pid , SIGINT);
    46.     }
    47.  
    48.     return 0;
    49. }

    alarm函数（自然定时法 ， 与进程状态无关）

    unsigned int alarm(unsigned int seconds);

    1. /*/
    2.     #include 
    3.     unsigned int alarm(unsigned int seconds);
    4.         功能：设置定时器（闹钟），函数调用开始倒计时，不会阻塞
    5.             倒计时为0，给当前进程发SIGALRM
    6.         参数：seconds - 倒计时/s ， 参数为0 - 定时器无效
    7.             取消一个定时器 - alarm(0)
    8.         返回值 
    9.             - 若之前没有定时器返回0
    10.             - 之前定时器，倒计时剩余的时间
    11.     SIGALRM：默认终止当前进程，某个进程都只有一个唯一定时器;
    12. */
    13. #include 
    14. #include 
    15. using namespace std;
    16.  
    17. int main(){
    18.  
    19.     int sec = alarm(5);
    20.     cout<<"seconds = "<
    21.  
    22.     sleep(2);
    23.     sec = alarm(2);
    24.     cout<<"seconds = "<
    25.  
    26.     while(1){
    27.  
    28.     }
    29.  
    30.     return 0;
    31. }

     实际的时间 = 内核时间 + 用户时间 + 消耗的时间（IO...）

    进行文件IO操作比较浪费时间；

    setitimer定时器函数（非阻塞）
    1. /*
    2.     #include 
    3.     int setitimer(int which, const struct itimerval *new_value,
    4.                     struct itimerval *old_value);
    5.         功能：设置定时器（闹钟） ， 替代alarm函数，精度更高 - us
    6.                 可以实现周期定时
    7.         参数： 
    8.             which - 定时器以什么时间计时
    9.                 ITINER_REAL - 真实事件->SIGALRM
    10.                 ITIMER_VIRTUAL - 用户时间->SIGVTALRM
    11.                 ITIMER_PROF - 用户态和内核态下的事件->SIGPROF
    12.             new_value - 设置定时器的属性
    13.                 struct itimerval { // 定时器的结构体
    14.                     struct timeval it_interval;  //Interval for periodic timer 间隔时间 
    15.                     struct timeval it_value;     //Time until next expiration  延迟时间
    16.                 };
    18.                 struct timeval { // 时间的结构体
    19.                     time_t      tv_sec;          //seconds 
    20.                     suseconds_t tv_usec;         //microseconds 
    21.                 };
    22.             old_value - 记录上一次的时间参数 一般设为NULL 不使用
    23.         返回值：
    24.             成功 - 0
    25.             失败 - -1 并设置errno
    26. */
    27.  
    28. #include 
    29. #include 
    30. #include 
    31. #include 
    32. #include 
    33. using namespace std;
    34.  
    35. // 过3s 每2s定时一次
    36. int main(){
    37.     // 设置结构体
    38.     struct itimerval new_value;
    39.  
    40.     new_value.it_interval.tv_sec = 2;
    41.     new_value.it_interval.tv_usec = 0;
    42.  
    43.     new_value.it_value.tv_sec = 3;
    44.     new_value.it_value.tv_usec = 0;
    45.  
    46.     int ret = setitimer(ITIMER_REAL , &new_value , NULL);
    47.  
    48.     if(ret == -1){
    49.         perror("setitimer");
    50.         exit(0);
    51.     }
    52.  
    53.     getchar();
    54.  
    55.     return 0;
    56. }

    捕捉signal信号 - signal/sigaction

    signal会根据不同的UNIX版本而表现不同；sigaction不会，建议使用sigaction

    一定要在定时器设置之前注册信号捕捉！！！

    1. /*
    2.     #include 
    3.     typedef void (*sighandler_t)(int);
    4.     sighandler_t signal(int signum, sighandler_t handler);
    5.         功能：设置某个信号的捕捉行为
    6.         参数：
    7.             signum - 要捕捉的信号
    8.             handler - 捕捉到信号的处理方法
    9.                 SIG_IGN - 忽略信号
    10.                 SIG_DFL - 使用信号默认的行为
    11.                 回调函数 - 由内核调用 程序员只负责写函数； 捕捉到后如何处理信号
    12.         返回值：
    13.             成功 - 上一次注册的信号处理函数；第一次返回NULL
    14.             失败 - SIG_ERR 并设置errno
    16.     SIGKILL SIGSTOP不能被捕捉、忽略、处理
    18. */
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. using namespace std;
    26.  
    27. void meet(int num){
    28.     // num 表示捕捉到信号的值
    29.     cout<<"逮到你了~"<
    30. }
    31.  
    32. // 过3s 每2s定时一次
    33. int main(){
    34.     // 注册信号捕捉
    35.     // signal(SIGALRM,  SIG_IGN);
    36.     // signal(SIGALRM,  SIG_DFL);
    37.     signal(SIGALRM,  meet);
    38.     
    39.     // 设置结构体
    40.     struct itimerval new_value;
    41.  
    42.     new_value.it_interval.tv_sec = 2;
    43.     new_value.it_interval.tv_usec = 0;
    44.  
    45.     new_value.it_value.tv_sec = 3;
    46.     new_value.it_value.tv_usec = 0;
    47.  
    48.     int ret = setitimer(ITIMER_REAL , &new_value , NULL);
    49.  
    50.     if(ret == -1){
    51.         perror("setitimer");
    52.         exit(0);
    53.     }
    54.  
    55.     getchar();
    56.  
    57.     return 0;
    58. }

    信号集

    sigantion涉及到了信号集的概念 - 很多信号组成的集合 ， 数据类型 - sigset_t；

    PCB中有两个重要的信号集 - 阻塞信号集和未决信号集；两个信号集都由内核使用位图机制来实现 - 64位；不能直接对两个信号集进行操作，需要自定义另一个集合，借助信号集操作函数来对其进行操作；

    1. /*
    2.     对自定义信号集进行操作
    3.     #include 
    4.     int sigemptyset(sigset_t *set);
    5.         功能 - 清空信号集的数据，标志位置0
    6.         参数 - 需要操作的信号集（传出参数）
    7.         返回值：
    8.             成功 - 0
    9.             失败 - -1 并设置errno
    10.     int sigfillset(sigset_t *set);
    11.         功能 - 标志位置1
    12.         参数 - 需要操作的信号集（传出参数）
    13.         返回值：
    14.             成功 - 0
    15.             失败 - -1 并设置errno
    17.     int sigaddset(sigset_t *set, int signum);
    18.         功能 - 设置信号集中的某一标志位为1，阻塞该信号
    19.         参数
    20.             set - 需要操作的信号集（传出参数）
    21.             signum - 需要阻塞的信号
    22.         返回值：
    23.             成功 - 0
    24.             失败 - -1 并设置errno
    25.     int sigdelset(sigset_t *set, int signum);
    26.         功能 - 设置信号集中的某一标志位为0，不阻塞该信号
    27.         参数
    28.             set - 需要操作的信号集（传出参数）
    29.             signum - 需要不阻塞的信号
    30.         返回值：
    31.             成功 - 0
    32.             失败 - -1 并设置errno
    33.     int sigismember(const sigset_t *set, int signum);
    34.         功能 - 判断某个信号是否阻塞
    35.         参数
    36.             set - 需要操作的信号集
    37.             signum - 待判断的信号
    38.         返回值：
    39.             被阻塞 - 1
    40.             没被阻塞 - 0
    41.             错误 - -1
    42. */
    43. #include 
    44. #include 
    45. #include 
    46. #include 
    47. #include 
    48. #include 
    49. using namespace std;
    50.  
    51. int main(){
    52.     sigset_t set;// 创建
    53.     //清空
    54.     sigemptyset(&set);
    55.     int ret = sigismember(&set , SIGINT);
    56.     if(ret == 0){
    57.         cout<<"SIGINT 不阻塞"<
    58.     }
    59.     else if(ret == 1){
    60.         cout<<"SIGINT 阻塞"<
    61.     }
    62.  
    63.     // 添加信号集
    64.     sigaddset(&set , SIGINT);
    65.     sigaddset(&set , SIGQUIT);
    66.  
    67.     ret = sigismember(&set , SIGINT);
    68.     if(ret == 0){
    69.         cout<<"SIGINT 不阻塞"<
    70.     }
    71.     else if(ret == 1){
    72.         cout<<"SIGINT 阻塞"<
    73.     }
    74.  
    75.     // 信号集删除
    76.     sigdelset(&set , SIGQUIT);
    77.     ret = sigismember(&set , SIGQUIT);
    78.     if(ret == 0){
    79.         cout<<"SIGQUIT 不阻塞"<
    80.     }
    81.     else if(ret == 1){
    82.         cout<<"SIGQUIT 阻塞"<
    83.     }
    84.     return 0;
    85. }

    可以通过sigprocmask对内核中的阻塞信号集进行操作

    1. /*
    2.     #include 
    3.     int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
    4.         功能：将自定义信号集中的数据设置到内核中
    5.         参数：
    6.             how:如何对内核阻塞信号集进行处理
    7.                 SIG_BLOCK - 将用户设置的阻塞信号集添加到内核中 内核中原来的数据不变（|）
    8.                     mask |= set
    9.                 SIG_UNBLOCK - 根据用户设置清除内核中阻塞信号（&）
    10.                     mask &= ~set
    11.                 SIG_SETMASK - 覆盖
    12.             set - 自定义信号集
    13.             oldset - 保存设置之前内存中信号集状态 ， 一般NULL
    14.         返回值：
    15.             成功 - 0
    16.             失败 - -1 (两个错误号)
    18.     int sigpending(sigset_t *set);
    19.         功能：获取内核中未决信号集
    20.         参数：set - 传出参数
    21. */
    22. // 写一个程序 不断把所有的常规信号的未决状态打印到屏幕（位）
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28. #include 
    29. using namespace std;
    30.  
    31. int main(){
    32.  
    33.     // 设置2、3信号阻塞
    34.     sigset_t set;
    35.     sigemptyset(&set);
    36.  
    37.     sigaddset(&set , SIGINT);
    38.     sigaddset(&set , SIGQUIT);
    39.  
    40.     sigprocmask(SIG_BLOCK , &set , NULL);
    41.  
    42.     while(1){
    43.         sigset_t pending_set;
    44.         sigemptyset(&pending_set);
    45.         sigpending(&pending_set);
    46.  
    47.         //遍历前32位
    48.         for(int i = 1 ; i<=32 ; i++){
    49.             if(sigismember(&pending_set , i)==1){
    50.                 cout<<"1";
    51.             }
    52.             else if(sigismember(&pending_set , i)==0){
    53.                 cout<<"0";
    54.             }
    55.             else{
    56.                 perror("sigismember");
    57.                 exit(0);
    58.             }
    59.         }
    60.         cout<
    61.     }
    62.  
    63.  
    64.  
    65.     return 0;
    66. }

    信号捕捉函数 - sigaction

    信号捕捉处理过程中使用临时阻塞信号集，信号处理完后恢复内核中的阻塞信号集；

    信号处理过程中，再发出信号会阻塞，且阻塞的常规信号不支持排队；

    1. /*
    2.     #include 
    4.     int sigaction(int signum, const struct sigaction *act,
    5.                     struct sigaction *oldact);
    6.         功能：检查/改变信号的处理
    7.         参数：
    8.             signum - 需要捕捉的信号编号/宏值
    9.             act - 捕捉到信号之后的处理动作
    10.             oldact - 上次的相关设置，一般NULL
    11.         返回值：
    12.             成功 - 0
    13.             失败 - -1
    15.     struct sigaction {
    16.             // 信号捕捉到后的处理函数
    17.             void     (*sa_handler)(int);
    18.             // 不常用
    19.             void     (*sa_sigaction)(int, siginfo_t *, void *);
    20.             // 临时阻塞信号集 信号捕捉函数执行过程中临时阻塞某些信号
    21.             sigset_t   sa_mask;
    22.             // 使用哪个处理捕捉信号 0 - sa_handler/SA_SIGINFO - sa_sigaction
    23.             int        sa_flags;
    24.             // 被废弃掉了 - NULL
    25.             void     (*sa_restorer)(void);
    26.         };
    29. */
    30. #include 
    31. #include 
    32. #include 
    33. #include 
    34. #include 
    35. #include 
    36. using namespace std;
    37.  
    38. void meet(int num){
    39.     // num 表示捕捉到信号的值
    40.     cout<<"逮到你了~"<
    41. }
    42.  
    43. // 过3s 每2s定时一次
    44. int main(){
    45.     struct sigaction act;
    46.     act.sa_flags = 0;
    47.     act.sa_handler = meet;
    48.     sigemptyset(&act.sa_mask);
    49.  
    50.     // 注册信号捕捉
    51.     sigaction(SIGALRM , &act , NULL);
    52.     
    53.     // 设置结构体
    54.     struct itimerval new_value;
    55.  
    56.     new_value.it_interval.tv_sec = 2;
    57.     new_value.it_interval.tv_usec = 0;
    58.  
    59.     new_value.it_value.tv_sec = 3;
    60.     new_value.it_value.tv_usec = 0;
    61.  
    62.     int ret = setitimer(ITIMER_REAL , &new_value , NULL);
    63.  
    64.     if(ret == -1){
    65.         perror("setitimer");
    66.         exit(0);
    67.     }
    68.  
    69.     while(1){
    70.         
    71.     }
    72.  
    73.     return 0;
    74. }

    SIGCHLD信号

    1. 子进程终止

    2. 子进程接收到SIGSTOP - 暂停

    3. 处于暂停的子进程收到SIGCONT唤醒

    给父进程发送SIGCHLD，父进程默认忽略；

    1. /*
    2.     通过SIGCHLD解决僵尸进程的问题
    3. */
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. using namespace std;
    13.  
    14. void meet(int num){
    15.     while(1){
    16.         int ret = waitpid(-1 , NULL , WNOHANG);
    17.         if(ret > 0){
    18.             cout<<"子进程结束了 - "<
    19.         }
    20.         else if(ret == 0){
    21.             break;
    22.         }
    23.         else{
    24.             break;
    25.         }
    26.     }
    27. }
    28.  
    29. int main(){
    30.     // 提前设置阻塞信号集 - SIGCHLD
    31.     sigset_t set;
    32.     sigemptyset(&set);
    33.     sigaddset(&set , SIGCHLD);
    34.     sigprocmask(SIG_BLOCK , &set , NULL);
    35.  
    36.     pid_t pid;
    37.     for(int i = 0 ; i < 5 ; i++){
    38.         pid = fork();
    39.         if(pid == 0){
    40.             break;
    41.         }
    42.     }
    43.     if(pid > 0){
    44.         // 捕捉SIGCHLD信号
    45.         struct sigaction act;
    46.         act.sa_flags = 0;
    47.         act.sa_handler = meet;
    48.         sigemptyset(&act.sa_mask);
    49.         sigaction(SIGCHLD , &act , NULL);
    50.         
    51.         sigprocmask(SIG_UNBLOCK , &set , NULL);
    52.  
    53.         while(1){
    54.             cout<<"父进程： "<<getpid()<
    55.             sleep(2);
    56.         }
    57.     }
    58.     else if(pid == 0){
    59.         cout<<"子进程："<<getpid()<
    60.     }
    61.  
    62.     return 0;
    63. }

    注意：当没有子进程时，waitpid也会返回-1；并不是只有在错误得时候才返回-1；

    共享内存

    共享内存的效率高于内存映射；允许多个进程共享同一物理内存区域，共享内存段为用户空间的一部分，因此共享内存无需内核介入（相比其他IPC通信少）；

    与管道等要求发送进程将数据从用户空间的缓冲区复制进内核内存和接收进程将数据从内核内存复制进用户空间的缓冲区的做法相比，这种 IPC 技术的速度更快。

    1. /*
    2.     key_t ftok(const char *pathname, int proj_id);
    3.         功能：根据指定路径名和int值生成一个共享内存的key
    4.         参数：
    5.             pathname - 路径名
    6.             proj_id - int值，但系统调用只是用其中1个字节
    8.     问题1:操作系统如何知道一块共享内存被多少个进程关联?
    9.         - 共享内存维护了一个结构体struct shmid_ds 其中有一个成员shm_nattach记录该信息
    10.         可以通过ipcs -a 查所有通信方式信息
    11.                 ipcs -m 共享内存;ipcrm 删除（标记删除不会释放）
    12.                 ipcs -q 消息队列
    13.                 ipcs -s 信号
    14.     问题2:可不可以对共享内存进行多次删除 shmct1
    15.         可以的
    16.         因为shmct1 标记删除共享内存，不是直接删除，当关联进程为0才会被真正删除
    17.         如果一个进程和共享内存取消关联就不能继续操作这个共享内存；
    18.     问题三：共享内存和内存映射的区别
    19.         1. 共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）
    20.         2. 共享内存效率更高
    21.         3. 所有进程操作的是统一共享内存，内存映射是每个进程在自己的虚拟地址空间有一块独立内存
    22.         4. 进程突然退出，共享内存还存在，内存映射区会消失，但磁盘文件中的数据还在
    23.         5. 内存映射区：进程退出就销毁
    24.             共享内存：进程退出，需要手动删除（所有关联进程数为0），进程退出会自动和共享内存取消关联
    25. */
    1. // write
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. using namespace std;
    8.  
    9. int main(){
    10.     // 1. 创建
    11.     int shmid = shmget(100 , 4096 , IPC_CREAT | 0664);
    12.     // 2. 关联
    13.     void* ptr = shmat(shmid , NULL , 0);
    14.     // 3. 写数据
    15.     char* ctr=new char[20];
    16.     string str = "hello 647";
    17.     strcpy(ctr,str.c_str());
    18.     memcpy(ptr , ctr , sizeof(str)+1);
    19.  
    20.     cout<<"按任意键继续"<
    21.     getchar();
    22.     
    23.     // 4. 解除关联
    24.     shmdt(ptr);
    25.     // 5. 删除共享内存
    26.     shmctl(shmid , IPC_RMID , NULL);
    27.  
    28.     return 0;
    29. }
    30.  
    31. // read
    32. #include 
    33. #include 
    34. #include 
    35. #include 
    36. #include 
    37. using namespace std;
    38.  
    39. int main(){
    40.     // 1. 创建
    41.     int shmid = shmget(100 , 0 , IPC_CREAT);
    42.     // 2. 关联
    43.     void* ptr = shmat(shmid , NULL , 0);
    44.     // 3. 读数据
    45.     cout<<(char*)ptr<
    46.  
    47.     cout<<"按任意键继续"<
    48.     getchar();
    49.     
    50.     // 4. 解除关联
    51.     shmdt(ptr);
    52.     // 5. 删除共享内存
    53.     shmctl(shmid , IPC_RMID , NULL);
    54.  
    55.     return 0;
    56. }

    守护进程

    终端

    UNIX系统，用户通过终端登陆系统得到一个shell进程，这个终端为shell控制终端 - 保存于PCB；

    默认情况下标准输入、标准输出、标准错误都指向控制终端；

    进程组

    进程组是一组相关进程集合，进程组的生命周期从首进程创建组开始，最后一个成员进程退出组结束；

    会话

    会话是一组相关进程组的集合，会话首进程为创建该会话的id，进程Id为会话id；

    一个会话中的所有进程共享单个控制终端，一个终端最多可能会成为一个会话的控制终端；会话首进程为该终端的控制进程；

    在任一时刻，会话中的其中一个进程组会成为终端的前台进程组，其他进程组会成为后台进程组。只有前台进程组中的进程才能从控制终端中读取输入。当用户在控制终端中输入终端字符生成信号后，该信号会被发送到前台进程组中的所有成员。

    守护进程 - 后台服务进程

    生命周期很长，守护进程会在系统启动的时候被创建并一直运行直至系统被关闭。

    它在后台运行并且不拥有控制终端。没有控制终端确保了内核永远不会为守护进程自动生成任何控制信号以及终端相关的信号(如 SIGINT、SIGQUIT)

    创建步骤

    1. fork()，父进程退出 - 确保子进程不是进程组首进程/防止父进程结束后显示shell提示符

    2. setsid() - 脱离控制终端

    3. 清楚进程umask，确保守护进程创建文件、目录所需的权限

    4. 该当前目录为根目录

    5. 关继承的打开的文件描述符

    6. 关闭文件描述符0 1 2后，守护进程打开/dev/null，重定向文件描述符到该设备

    7. 业务逻辑

    1. /*
    2.     写一个守护进程，每隔2s获取系统时间 写入磁盘文件
    3. */
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. using namespace std;
    17.  
    18. void work(int num){
    19.     time_t tm = time(NULL);
    20.     struct tm* loc = localtime(&tm);
    21.     // char buf[1024];
    22.     // sprintf(buf, "%d-%d-%d %d:%d:%d\n", loc->tm_year, loc->tm_mon, loc->tm_mday, loc->tm_hour, loc->tm_min, loc->tm_sec);
    23.     // cout<
    24.     char* str = asctime(loc);
    25.     int fd = open("time.txt" , O_RDWR|O_CREAT , 0664);
    26.     write(fd , str , strlen(str));
    27. }
    28.  
    29. int main(){
    30.     // 创建子进程 - 防止进程组冲突
    31.     pid_t pid = fork();
    32.  
    33.     if(pid>0){
    34.         exit(0);
    35.     }
    36.     // 新建会话 - 脱离控制终端
    37.     setsid();
    38.  
    39.     // 设置掩码
    40.     umask(022);
    41.  
    42.     // 更改工作目录
    43.     chdir("/home/nowcoder");
    44.  
    45.     // 关文件描述符
    46.     int fd = open("/dev/null" , O_RDWR);
    47.     dup2(fd , STDIN_FILENO);
    48.     dup2(fd , STDOUT_FILENO);
    49.     dup2(fd , STDERR_FILENO);
    50.  
    51.     // 业务逻辑
    52.     struct sigaction act;
    53.     act.sa_flags = 0;
    54.     act.sa_handler = work;
    55.     sigemptyset(&act.sa_mask);
    56.  
    57.     sigaction(SIGALRM , &act , NULL);
    58.  
    59.     struct itimerval val;
    60.     val.it_interval.tv_sec = 2;
    61.     val.it_interval.tv_usec = 0;
    62.     val.it_value.tv_sec = 2;
    63.     val.it_value.tv_usec = 0;
    64.  
    65.     setitimer(ITIMER_REAL , &val , NULL);
    66.  
    67.     while(1){
    68.         sleep(10);
    69.     }
    70.  
    71.     return 0;
    72. }

  • 相关阅读:
    【PMSM】二. 经典电流环、速度环设计（下）
    C语言序列化与反序列化--TCL中支持的数据结构（二）
    本文带你了解透彻云计算（前世，今生，未来）
    Linux 之 split 切分大文件 cat 合并多个小文件
    FlinkSQL 窗口聚合
    Python——LeetCode刷题——【36. 有效的数独】（字节二面）
    NTB0101GS1Z 电压电平 移位器 产品概述 特性
    java房屋装修公司业务管理系统
    MySQL高可用搭建方案之（MMM）
    Spring的“一站式解决方案”体现在哪里？
  • 原文地址：https://blog.csdn.net/rygy_/article/details/132567073