• Linux系统编程系列之线程的信号处理

     Linux系统编程系列（16篇管饱，吃货都投降了！）

            1、Linux系统编程系列之进程基础

            2、Linux系统编程系列之进程间通信(IPC)-信号

            3、Linux系统编程系列之进程间通信(IPC)-管道

            4、Linux系统编程系列之进程间通信-IPC对象

            5、Linux系统编程系列之进程间通信-消息队列

            6、Linux系统编程系列之进程间通信-共享内存

            7、Linux系统编程系列之进程间通信-信号量组

            8、Linux系统编程系列之守护进程

            9、Linux系统编程系列之线程

            10、Linux系统编程系列之线程属性 

            11、Linux系统编程系列之互斥锁和读写锁

            12、Linux系统编程系列之线程的信号处理

            13、Linux系统编程系列之POSIX信号量

            14、Linux系统编程系列之条件变量

            15、Linux系统编程系列之死锁

            16、 Linux系统编程系列之线程池

    一、为什么要有线程的信号处理

            由于多线程程序中线程的执行状态是并发的，因此当一个进程收到一个信号时，那么究竟由进程中的哪条线程响应这个信号就是不确定的，只能取决于哪条线程刚好在信号达到的瞬间被调度，这种不确定性在程序逻辑中一般是不能接受的。

    二、解决办法

            1、在多线程进程中选定某条线程去响应信号

            2、其余线程对该信号进行屏蔽

    三、相关函数API接口

            1、发送信号给指定线程

            

    1. // 在进程内部，只允许在线程之间进行发送
    2. int pthread_kill(pthread_t thread, int sig);
    3.  
    4. // 接口说明
    5.         返回值：成功返回0，失败返回错误码
    6.         参数thread：接收信号的线程号
    7.         参数sig：待发送的信号
    8.  
    9.  
    10. // 在进程之间进行的信号发送
    11. int kill(pid_t pid, int sig);
    12.  
    13. // 接口说明
    14.         返回值：成功返回0，失败返回-1
    15.         参数pid：接受信号的进程号
    16.         参数sig：待发送的信号

             2、发送带参数的信号给指定线程

    1. // 发送带参数的信号给指定线程
    2. // 线程间
    3. int pthread_sigqueue(pthread_t thread, 
    4.                      int sig,
    5.                      const union sigval value);
    6.  
    7. // 接口说明
    8.         返回值：成功返回0，失败返回-1
    9.         参数thread：待接收信号的线程号
    10.         参数sig：待发送的信号
    11.         参数value：额外携带的参数
    12.  
    13.  
    14. // 进程间
    15.  int sigqueue(pid_t pid, int sig, const union sigval value);
    16.  
    17. // 接口说明
    18.         返回值：成功返回0，失败返回-1
    19.         参数pid：待接收信号的进程号
    20.         参数sig：待发送的信号
    21.         参数value：额外携带的参数

             3、屏蔽指定信号 

    1. // 屏蔽指定信号
    2. int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
    3.  
    4. // 接口说明
    5.         返回值：成功返回0，失败返回-1
    6.         
    7. // 参数解析：
    8. 1、how：操作命令字，比如阻塞、解除阻塞等
    9.     SIG_BLOCK：阻塞set中的信号（原有正在阻塞的信号保持阻塞）
    10.     SIG_SETMASK：阻塞set中的信号（原有正在阻塞的信号自动解除）
    11.     SIG_UNBLOCK：解除set中的信号
    12.  
    13. 2、set：当前要操作的信号集
    14. 3、oldset：若为非空，则将原有阻塞信号集保留到该oldset中
    15. 注意：该函数的操作参数不是单个信号，而是信号集。
    16.  
    17. // 信号集操作函数组
    18. int sigemptypset(sigset_t *set);    // 清空信号集set
    19. int sigfillset(sigset_t *set);    // 将所有信号加入信号集set中
    20. int sigaddset(sigset_t *set, int signum); // 将信号signum添加到信号集set中
    21. int sigdelset(sigset_t *set, int signum); // 将信号signum从信号集set中剔除
    22. int sigsimember(const sigset_t *set, int signum); // 测试信号signum是否在信号集set中

    四、案例

            1、使用线程结合信号的方式完成数据的接收和发送，要求一条线程发送数据同时发送信号指定某条线程接收数据，另外有多余线程做伪任务。

    1. // 多线程信号处理的案例
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. char data[100];
    11. pthread_t tid1, tid2, tid3;
    12.  
    13. // 信号响应函数
    14. void recv_handler(int sig)
    15. {
    16.     printf("\nmy tid is %ld\n", pthread_self());
    17.     printf("read data: %s\b", data);
    18.     memset(data, 0, sizeof(data));
    19. }
    20.  
    21.  
    22. // 线程1的例程函数
    23. void *routine1(void *arg)
    24. {
    25.     printf("I am recv_routine, my tid = %ld\n", tid1);
    26.  
    27.     // 设置线程分离 
    28.     pthread_detach(pthread_self()); 
    29.  
    30.     while(1)
    31.     {
    32.         printf("please input data:\n");
    33.         fgets(data, sizeof(data), stdin);
    34.  
    35.         pthread_kill(tid2, 34);  // 给线程2发送信号
    36.         printf("send data success\n");
    37.     }
    38. }
    39.  
    40. // 线程2的例程函数，用来接收数据
    41. void *routine2(void *arg)
    42. {
    43.     // 注册信号响应函数
    44.     signal(34, recv_handler);
    45.  
    46.     printf("I am routine2, my tid = %ld\n", tid2);
    47.  
    48.     // 设置线程分离 
    49.     pthread_detach(pthread_self());
    50.     while(1)
    51.     {
    52.         pause();
    53.     }
    54. }
    55.  
    56. // 线程3的例程函数
    57. void *routine3(void *arg)
    58. {
    59.     printf("I am routine3, my tid = %ld\n", tid3);
    60.  
    61.     // 设置线程分离 
    62.     pthread_detach(pthread_self());
    63.     while(1)
    64.     {
    65.         pause();
    66.     }
    67. }
    68.  
    69. int main(int argc, char *argv[])
    70. {
    71.     // 创建线程1，用来发送和接收数据
    72.     errno = pthread_create(&tid1, NULL, routine1, NULL);
    73.     if(errno == 0)
    74.     {
    75.         printf("pthread create routine1 success, tid = %ld\n", tid1);
    76.     }
    77.     else
    78.     {
    79.         perror("pthread create routine1 fail\n");
    80.     }
    81.  
    82.    
    83.     // 创建线程2，用来做多余线程
    84.     errno = pthread_create(&tid2, NULL, routine2, NULL);
    85.     if(errno == 0)
    86.     {
    87.         printf("pthread create routine2 success, tid = %ld\n", tid2);
    88.     }
    89.     else
    90.     {
    91.         perror("pthread create routine2 fail\n");
    92.     }
    93.  
    94.      // 创建线程3，用来做多余线程
    95.     errno = pthread_create(&tid3, NULL, routine3, NULL);
    96.     if(errno == 0)
    97.     {
    98.         printf("pthread create routine3 success, tid = %ld\n", tid3);
    99.     }
    100.     else
    101.     {
    102.         perror("pthread create routine3 fail\n");
    103.     }
    104.  
    105.     // 一定要加这个，否则主函数直接退出，相当于进程退出，所有线程也退出
    106.     // 或者加上while(1)等让主函数不退出
    107.     pthread_exit(0);
    108.     
    109.     return 0;
    110. }

              2、使用线程结合信号的方式完成数据的接收和发送，要求一条线程完成数据的发送和接收，另外两个线程屏蔽信号，做伪任务。

    1. // 多线程信号处理的案例
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. char data[100];
    11. sigset_t sigs_set; // 信号集
    12. pid_t pid;
    13. pthread_t tid1, tid2, tid3;
    14.  
    15. // 信号响应函数
    16. void recv_handler(int sig)
    17. {
    18.     printf("\nmy tid is %ld\n", pthread_self());
    19.     printf("read data: %s\b", data);
    20.     memset(data, 0, sizeof(data));
    21. }
    22.  
    23.  
    24. // 线程1的例程函数
    25. void *routine1(void *arg)
    26. {
    27.     printf("I am routine1, my tid = %ld\n", tid1);
    28.  
    29.     // 设置线程分离 
    30.     pthread_detach(pthread_self()); 
    31.  
    32.     while(1)
    33.     {
    34.         printf("please input data:\n");
    35.         fgets(data, sizeof(data), stdin);
    36.         printf("send data success\n");
    37.  
    38.         kill(pid, 34);  // 给进程（所有线程）发送信号
    39.     }
    40. }
    41.  
    42. // 线程2的例程函数，用来接收数据
    43. void *routine2(void *arg)
    44. {
    45.     printf("I am routine2, my tid = %ld\n", tid2);
    46.  
    47.     // 屏蔽（阻塞）信号集中的信号
    48.     sigprocmask(SIG_BLOCK, &sigs_set, NULL);
    49.  
    50.     // 设置线程分离 
    51.     pthread_detach(pthread_self());
    52.     while(1)
    53.     {
    54.         pause();
    55.     }
    56. }
    57.  
    58. // 线程3的例程函数
    59. void *routine3(void *arg)
    60. {
    61.     printf("I am routine3, my tid = %ld\n", tid3);
    62.  
    63.     // 设置线程分离 
    64.     pthread_detach(pthread_self());
    65.  
    66.     // 屏蔽（阻塞）信号集中的信号
    67.     sigprocmask(SIG_BLOCK, &sigs_set, NULL);
    68.  
    69.     while(1)
    70.     {
    71.         pause();
    72.     }
    73. }
    74.  
    75. int main(int argc, char *argv[])
    76. {
    77.     // 注册信号响应函数
    78.     signal(34, recv_handler);
    79.  
    80.     sigemptyset(&sigs_set); // 清空信号集
    81.     sigaddset(&sigs_set, 34);   // 把34信号加到信号集中
    82.  
    83.     pid = getpid(); // 获取进程号
    84.  
    85.     // 创建线程1，用来发送和接收数据
    86.     errno = pthread_create(&tid1, NULL, routine1, NULL);
    87.     if(errno == 0)
    88.     {
    89.         printf("pthread create routine1 success, tid = %ld\n", tid1);
    90.     }
    91.     else
    92.     {
    93.         perror("pthread create routine1 fail\n");
    94.     }
    95.  
    96.     // 创建线程2，用来做多余线程
    97.     errno = pthread_create(&tid2, NULL, routine2, NULL);
    98.     if(errno == 0)
    99.     {
    100.         printf("pthread create routine2 success, tid = %ld\n", tid2);
    101.     }
    102.     else
    103.     {
    104.         perror("pthread create routine2 fail\n");
    105.     }
    106.  
    107.      // 创建线程3，用来做多余线程
    108.     errno = pthread_create(&tid3, NULL, routine3, NULL);
    109.     if(errno == 0)
    110.     {
    111.         printf("pthread create routine3 success, tid = %ld\n", tid3);
    112.     }
    113.     else
    114.     {
    115.         perror("pthread create routine3 fail\n");
    116.     }
    117.  
    118.     // 一定要加这个，否则主函数直接退出，相当于进程退出，所有线程也退出
    119.     // 或者加上while(1)等让主函数不退出
    120.     pthread_exit(0);
    121.     
    122.     return 0;
    123. }

    五、总结

            多线程进程中的信号处理可以采用选定某一条线程来接收信号，其余线程屏蔽该信号的做法，可以结合案例加深对多线程中信号的处理。

  • 相关阅读:
    推荐系统 学习笔记
    JS原型对象prototype
    mybatis源码探索之代理封装阶段
    msssql子查询列传行(stuff() 与for xml path())
    572. 另一棵树的子树
    Ubuntu Linux下安装 TensorFlow等开发环境
    【汇总】剑指 offer Ⅱ 1 ~ 40 题笔记
    【PHP代码审计】——开启你的代码审计生涯
    全量和已占用字符集
    STC15单片机-整合代码，完成软件设计
  • 原文地址：https://blog.csdn.net/AABond/article/details/133418970