用程序验证信号集相同信号共存，信号继承，嵌套的特点以及客户端和服务器通讯程序解析

已于 2022-03-31 12:47:03 修改
阅读量1.4k 收藏 1
点赞数 2
分类专栏： 嵌入式C语言基础 LINUX系统编程 文章标签： linux
于 2022-03-31 10:51:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44651073/article/details/123865906
版权

一.验证信号集的特点。

1.是否有相同的信号

#include <stdio.h>
#include <signal.h>

int main(int argc,char *argv[])
{
    //1. 定义信号集
    sigset_t set;
    
    //2. 将所有的信号都添加到信号集中
    sigfillset(&set);
    
    //3. 判断一下在不在集合中
    int ret;
    ret = sigismember(&set,SIGINT);
    if(ret == 1)
        printf("is member!\n");  //√
    else
        printf("is not member\n");
    
    //4. 清空信号集
    sigemptyset(&set);
    
    //5. 判断一下在不在集合中
    ret = sigismember(&set,SIGINT);
    if(ret == 1)
        printf("is member!\n");  
    else
        printf("is not member\n");//√
    
    //6. 单独将SIGINT信号添加到信号集中
    sigaddset(&set,SIGINT);
    
    //7. 判断一下在不在集合中
    ret = sigismember(&set,SIGINT);//√
    if(ret == 1)
        printf("is member!\n");  
    else
        printf("is not member\n");
    
    //8. 将SIGINT删除
    sigdelset(&set,SIGINT);
    
    //9. 判断一下在不在集合中
    ret = sigismember(&set,SIGINT);
    if(ret == 1)
        printf("is member!\n");  
    else
        printf("is not member\n");//√
    
    return 0;
}

--------------------------------------------------------------------------------------------------------------------------------

2.阻塞属性会不会被继承

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>


void my_func(int sig)
{
    printf("helloworld!\n");
}

int main(int argc,char *argv[])
{
    //1. 让父进程先捕捉这个信号
    signal(SIGUSR1,my_func);
    
    //思路： 让父进程先有阻塞属性，然后让父进程带着阻塞状态去产生一个子进程
    //2. 定义一个信号集
    sigset_t set;
    
    //3. 清空信号集
    sigemptyset(&set);
    
    //4. 将SIGUSR1添加到信号集中
    sigaddset(&set,SIGUSR1);
    
    //5. 给信号集设置阻塞状态
    sigprocmask(SIG_BLOCK,&set,NULL);
    
    //6. 带着这个信号集去产生一个子进程。
    pid_t x;
    x = fork();
    int i;
    if(x > 0)
    {
        printf("parent pid = %d\n",getpid());
        for(i=20;i>0;i--)
        {
            sleep(1);
            printf("parent i = %d\n",i);    //在这20s内，给父进程发送一个SIGUSR1信号。
        }
        
        sigprocmask(SIG_UNBLOCK,&set,NULL);
        printf("parent unblock!\n");
        wait(NULL);
        exit(0);
    }
    
    if(x == 0)
    {
        printf("child pid = %d\n",getpid());
        for(i=40;i>0;i--)
        {
            sleep(1);
            printf("child i = %d\n",i);    //在这20s~40s内，给子进程发送一个SIGUSR1信号。
        }
        sigprocmask(SIG_UNBLOCK,&set,NULL);
        printf("child unblock!\n");
        exit(0);
    }
}

--------------------------------------------------------------------------------------------------------------------------------

3.挂起队列的信号会不会被继承

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

void func(int sig)
{
    printf("helloworld!\n");
}

int main(int argc,char *argv[])
{
    //0. 捕捉信号
    signal(SIGUSR1,func);
    
    //1. 定义一个信号集
    sigset_t set;
    
    //2. 清空信号集
    sigemptyset(&set);
    
    //3. 将SIGUSR1添加到信号集中
    sigaddset(&set,SIGUSR1);
    
    //4. 设置信号集为阻塞状态
    sigprocmask(SIG_BLOCK,&set,NULL);
    
    //5. 持续一段，这段期间内，我们要发送一个SIGUSR1信号给父进程
    int i;
    for(i=20;i>0;i--)
    {
        sleep(1);
        printf("parent i = %d\n",i); //在此20s内，一定要发送SIGUSR1信号给父进程
    }
    
    //6. 这时候，父进程的挂起队列就有SIGUSR1。
    //7. 带着挂起队列去产生一个子进程
    pid_t x;
    x = fork();
    if(x > 0)
    {
        for(i=10;i>0;i--)
        {
            sleep(1);
            printf("parent unblock : %d\n",i);
        }
        
        sigprocmask(SIG_UNBLOCK,&set,0);
        
        wait(NULL);
        
        exit(0);
    }
    
    if(x == 0)
    {
        for(i=20;i>0;i--)
        {
            sleep(1);
            printf("child unblock : %d\n",i);
        }
        
        sigprocmask(SIG_UNBLOCK,&set,0);
        
        exit(0);
    }
    
    return 0;
}

--------------------------------------------------------------------------------------------------------------------------------

4.进程在相应信号时，能否相互嵌套

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

void func1(int sig)
{
    char str[] = "helloworld";
    int i;
    for(i=0;str[i]!='\0';i++)
    {
        fprintf(stderr,"%c",str[i]);
        sleep(1);
    }
}

void func2()
{
    char str[] = "appletree";
    int i;
    for(i=0;str[i]!='\0';i++)
    {
        fprintf(stderr,"%c",str[i]);
        sleep(1);
    }
}

int main()
{
    printf("parent pid = %d\n",getpid());
    
    signal(SIGUSR1,func1);
    signal(SIGUSR2,func2);
    
    while(1)
        pause();    
}

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

二.实现客户端和服务器收发通讯。

//服务器程序设计

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <strings.h>


#define S2C 10  //服务器发送给客户端消息类型
#define C2S 20  //客户端发送给服务器消息类型

//定义写入数据结构体

struct msgbuf{
    long mtype;    //消息的类型
    char mtext[50];//消息正文
};

void func(int sig)
{
    exit(0);
}

int main(int argc,char *argv[])
{
    //1. 为消息队列申请key值与ID号
    key_t key = ftok(".",10);
    int msgid = msgget(key,IPC_CREAT|0666);
    
    //2. 带着这条队列去产生一个小孩
    pid_t x;
    x = fork();
    if(x > 0)  //父进程  发送消息
    {
        signal(SIGCHLD,func);

//定义写入数据结构体变量gec
        
        struct msgbuf gec;
        int ret;
        while(1)
        {

//清空写入数据结构体变量
            bzero(&gec,sizeof(gec));

//定义写入数据结构体的消息类型
            gec.mtype = S2C;//服务器发送给客户端

//从标准输入获取数据存入写入数据结构体的消息正文缓冲区gec.mtext中
 /*     gec.mtext                   字符数组  等价于  数组首元素的地址

         sizeof(gec.mtext)       读取的字节大小

         stdin                           标准输入缓冲区文件指针

*/

 fgets(gec.mtext,sizeof(gec.mtext),stdin);


  //msgsnd函数写入数据到消息队列中  

 ret = msgsnd(msgid,&gec,strlen(gec.mtext),0);
            if(ret == -1)
            {
                printf("msgsnd error!\n");
            }
            
            if(strncmp(gec.mtext,"quit",4) == 0)
            {

//发送信号给子进程，当子进程收到SIGUSR1信号类型的时候，执行函数func()
                kill(x,SIGUSR1);
                exit(0);
            }
        }
    }
    
    if(x == 0)  //子进程   接收消息
    {

//捕捉父进程发送的SIGUSR1信号
        signal(SIGUSR1,func);
        

//定义写入数据结构体变量
        struct msgbuf gec;
        int ret;
        while(1)
        {

//清空写入数据结构体变量
            bzero(&gec,sizeof(gec));

//读取消息队列写入数据结构中的数据
            ret = msgrcv(msgid,&gec,sizeof(gec.mtext),C2S,0);
            if(ret == -1)
            {

       //读取失败
                printf("msgrcv error!\n");
            }
            
            printf("from client:%s",gec.mtext);
            
            if(strncmp(gec.mtext,"quit",4) == 0)
            {
                msgctl(msgid,IPC_RMID,NULL); //删除消息队列
                exit(0); //子进程推出的时候，系统会自动发送SIGCHLD给父进程。
            }
        }
    }
}

//客户端程序设计

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <strings.h>


#define S2C 10
#define C2S 20

//定义写入数据结构体

struct msgbuf{
    long mtype;    //消息类型
    char mtext[50];//正文
};

void func(int sig)
{
    exit(0);
}

int main(int argc,char *argv[])
{
    //1. 为消息队列申请key值与ID号
    key_t key = ftok(".",10);
    int msgid = msgget(key,IPC_CREAT|0666);
    
    //2. 带着这条队列去产生一个小孩
    pid_t x;
    x = fork();
    if(x > 0)  //父进程  发送消息
    {

//捕捉子进程退出时的信号SIGCHLD
        signal(SIGCHLD,func);


        //定义写入数据结构体变量
        struct msgbuf gec;


        int ret;
        while(1)
        {

//清空写入数据结构体
            bzero(&gec,sizeof(gec));

//定义写入数据结构体消息的类型
            gec.mtype = C2S;

//从标准输入缓冲区中获取数据写入写入数据结构体的消息正文


            fgets(gec.mtext,sizeof(gec.mtext),stdin);

//写入数据到消息队列中
            ret = msgsnd(msgid,&gec,strlen(gec.mtext),0);
            if(ret == -1)
            {
                printf("msgsnd error!\n");
            }
            
            if(strncmp(gec.mtext,"quit",4) == 0)
            {
                kill(x,SIGUSR1);
                exit(0);
            }
        }
    }
    
    if(x == 0)  //子进程   接收消息
    {

//捕捉父进程发送的SIGUSR1信号，执行函数func()
        signal(SIGUSR1,func);


        //定义写入数据结构体变量
        struct msgbuf gec;
        int ret;
        while(1)
        {

//清空写入数据结构体
            bzero(&gec,sizeof(gec));

读取消息队列中的数据
            ret = msgrcv(msgid,&gec,sizeof(gec.mtext),S2C,0);
            if(ret == -1)
            {
                printf("msgrcv error!\n");
            }
            
            printf("from server:%s",gec.mtext);
            
            if(strncmp(gec.mtext,"quit",4) == 0)
            {
                msgctl(msgid,IPC_RMID,NULL); //删除消息队列
                exit(0); //子进程    会自动发送SIGCHLD给父进程。
            }
        }
    }
}

肖爱Kun
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RF信号源低相位噪声及高速频率切换的共存设计
01-20
接收机质量和测试仪速度的提高对信号发生器性能提出了更为严苛的要求。随着频谱日益拥挤，通信行业必须开发新的调制技术，提高组件测试速度和性能及生产能力。因此，现在比以往更加需要经济高效的高质量信号源解决...
父子进程对信号的继承
yifeng_1118的专栏
09-01 716
经测试，使用system ,exec族产生的子进程 子进程会继承父亲的部分信号。 默认-》默认 忽略--》继承 改写--》默认 这个也好理解，父子进程就像DNA遗传，尽量遗传父亲的。 但是execl已经重新载入进程，改写的函数位置都不存在了。如何继承！！ 如果是fork的话，则完全继承。
fork 和 exec 对子进程继承父进程处理信号处理函数的影响
like的专栏
09-23 2955
当一个进程调用fork时，因为子进程在开始时复制父进程的存储映像，信号捕捉函数的地址在子进程中是有意义的，所以子进程继承父进程的信号处理方式。         但是当子进程调用exec后，因为exec运行新的程序后会覆盖从父进程继承来的存储映像，那么信号捕捉函数在新程序中已无意义，所以exec会将原先设置为要捕捉的信号都更改为默认动作。
Linux信号透彻分析与理解
热门推荐
01-11 1万+
本文将从以下几个方面来阐述信号:(1)信号的基本知识(2)信号生命周期与处理过程分析(3) 基本的信号处理函数(4) 保护临界区不被中断(5) 信号的继承与执行(6)实时信号中锁的研究第一部分: 信号的基本知识1.信号本质:信号的本质是软件层次上对中断的一种模拟。它是一种异步通信的处理机制，事实上，进程并不知道信号何时到来。2.信号来源(1)程序错误，如非法访问内存(2)外部信号，如按下了CTRL+C(3)通过kill或sigqueue向另外一个进程发送信号3.信号种类信号分为可靠信号与不可靠信号,可靠信号
linux信号嵌套,LINUX0.11信号机制
weixin_28883533的博客
05-14 357
原标题：LINUX0.11信号机制一、信号的本质信号(signal)是Linux操作系统在软件层面上对中断的模拟，是一种异步通信机制。进程之间可以相互发送信号来通知对方发生了什么事情，一个进程不必等待一个信号的到来，他也不知道什么时候会有信号到来。进程对信号有三种处理方法：第一种是类似中断的处理程序，对于需要处理的信号，进程可以指定处理函数，由该函数来处理。进程通过系统调用signal来指定进程对...
论文研究-非圆信号与圆信号共存下的快速方位估计算法.pdf
07-22
针对非圆信号和圆信号共存时，信号的波达方向估计算法运算量较大的问题，提出了一种可同时估计非圆信号和圆信号DOA的快速算法。利用观测数据及其复共轭构造中心复共轭对称矩阵，通过双映射定理可将该矩阵转换为实...
C#中的程序集和反射介绍
09-04
此外，每个程序集都有自己的名称、版本、公钥（如果为强命名程序集）以及文化和配置信息。这些信息通常通过`AssemblyInfo.cs`文件来定义和定制，如示例代码所示，其中包括各种属性，如`AssemblyTitle`、`...
PowerShell中使用.NET将程序集加入全局程序集缓存
09-21
全局程序集缓存（GAC，Global Assembly Cache）是.NET Framework提供的一种机制，用于存储共享的、强命名的程序集，这些程序集可以被多个应用程序域（AppDomain）同时访问。GAC中的程序集具有唯一性，确保了不同版本...
WCDMA.rar_WCDMA INTERFERENCE_WCDMA signal_WCDMA信号干扰_interference
09-24
“WCDMA频带中GSM干扰信号的抑制技术研究.kdh”文件很可能是详细探讨以上技术的一种学术论文或报告，深入分析了各种抑制方法的原理、性能和实际应用效果，对于理解WCDMA与GSM共存场景下的干扰问题以及寻求解决方案...
操作系统与系统编程（3）——信号
WSTONECH的博客
03-10 807
信号 信号原语 配置信号的handel
正式邀测！ OS Copilot——一款基于大模型构建的 Linux 智能操作系统助手
weixin_60347558的博客
07-02 511
重塑操作系统交互新体验，开启您的智能化系统管理之旅
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 149
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
Linux存储管理I
m0_54563444的博客
07-03 713
主要知识点: 基本分区、逻辑卷LVM、EXT3/4/XFS文件系统、RAID。
RedHat运维-LinuxSELinux基础4-端口绑定SELinux上下文
最新发布
a15735748145a的博客
07-06 206
12. 将60001/tcp端口上的SELinux上下文由http_port_t调整为gopher_port_t的方法是______________________；13. 将60002/tcp端口上的SELinux上下文由gopher_port_t调整为ssh_port_t的方法是______________________；14. 将60003/tcp端口上的SELinux上下文由ssh_port_t调整为http_port_t的方法是_______________________；
Linux——/etc/passwd文件含义，grep，cut
nianwan2157的博客
06-30 664
基于“行”的方式来提取数据是比较简单的，只需要设置好要搜索的关键词即可，但如果按列搜索，不仅要使用-f参数来设置需要看的列数，还需要使用-d参数来设置间隔符号。[root@server ~]# grep -nv "/sbin/nologin" /etc/passwd （反向）grep -r h ./* 如果要明确搜索当前目录中的子目录有h的行。# 相当于 grep -n “/sbin/nologin” /etc/passwd | wc -l。
linux的Top学习
wangkai6666的博客
07-02 808
普通定时器： arch_timer_handler_phys->tick_handle_periodic->update_process_times高精度定时器： tick_sched_handle->update_process_timeslinux 进程可以同时执行，是因为采用时间片轮转方案。每个进程都会分得相应的时间片，当前进程时间片用完，CPU就会停止执行当前进程，选择其他合适进程。什么时候判断当前进程的时间片是否用完？
【linux】（8）文件搜索grep
游码客的博客
07-01 1042
grep用于在文件中搜索指定的模式（字符串或正则表达式），并输出匹配的行。
Linux库概念及相关编程（动态库-静态库）
ITQWQ的博客
07-01 413
静态库在编译时直接被加入到目标程序中。优点是运行速度快，发布时无需提供库文件，但缺点是生成的可执行文件较大。动态库在程序运行时被加载。优点是节省内存和磁盘空间，缺点是运行速度稍慢。
C＃和.NET 2.0实战02
01-01
2.2 共享程序集和私有程序集共享程序集是供多个应用程序使用的程序集。它们需被正确地注册到全局程序集缓存中。全局程序集缓存是一个文件夹，位于%windir%\assembly目录下。它存放了由.NET安装程序安装的共享程序集...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

肖爱Kun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值