IO进程（学习）2024.8.22

已于 2024-08-23 08:33:56 修改
阅读量1k 收藏 14
点赞数 30
分类专栏： IO进程 文章标签： 学习 c语言 IO 进程 linux 算法
于 2024-08-22 20:03:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60450758/article/details/141426409
版权

信号

信号函数

信号处理函数

#include <signal.h>
sighandler_t signal(int signum, sighandler_t handler);
功能：信号处理函数
参数：signum：要处理的信号
           handler：信号处理方式
                        SIG_IGN：忽略信号
                        SIG_DFL：执行默认操作
                        handler：捕捉信号  
                        void handler(int sig){} //函数名可以自定义
返回值：成功：设置之前的信号处理方式
               失败：-1

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

void handler(int sig)
{
    if (sig == SIGQUIT)
    {
        printf("是SIGQUIT信号\n");
    }
    else
    {
        printf("是其他信号\n");
    }
}

int main(int argc, char const *argv[])
{
    // signal(SIGINT, SIG_DFL); // 执行默认操作

    // signal(SIGINT, SIG_IGN); // 忽略信号

    signal(SIGINT, handler); // 捕捉信号

    pause();
    return 0;
}

信号的处理过程

程序运行在用户空间时->进程由于系统调用或中断进入内核->转向用户空间执行信号处理函数->信号处理函数完毕后进入内核->返回用户空间继续执行程序

练习：用信号的知识实现司机和售票员问题。
1.售票员捕捉SIGINT(代表开车)信号，向司机发送SIGUSR1信号，司机打印（let's gogogo）
2.售票员捕捉SIGQUIT(代表停车)信号，向司机发送SIGUSR2信号，司机打印（stop the bus）
3.司机捕捉SIGTSTP(代表到达终点站)信号，向售票员发送SIGUSR1信号，售票员打印（please get off the bus）
4.司机等待售票员下车，之后司机再下车。

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

pid_t pid;  // 售票员的进程ID
pid_t ppid; // 司机的进程ID

// 售票员的信号处理函数
void shoupiaoyuan(int sig)
{
    if (sig == SIGINT)
    {
        kill(ppid, SIGUSR1); // 向司机发送SIGUSR1信号
    }
    if (sig == SIGQUIT)
    {
        kill(ppid, SIGUSR2); // 向司机发送SIGUSR2信号
    }
    if (sig == SIGUSR1)
    {
        printf("Please get off the bus!\n");
        exit(0);
    }
}

// 司机的信号处理函数
void siji(int sig)
{
    if (sig == SIGUSR1)
    {
        printf("Let's gogogo!\n");
    }
    if (sig == SIGUSR2)
    {
        printf("Stop the bus!\n");
    }
    if (sig == SIGTSTP)
    {
        kill(pid, SIGUSR1); // 向售票员发送SIGUSR1信号
        wait(NULL);
        exit(0);
    }
}

int main()
{
    ppid = getpid();
    pid = fork();
    if (pid < 0)
    {
        perror("forka创建失败");
        return -1;
    }

    if (pid == 0) // 子进程：售票员
    {
        // 等待信号
        while (1)
        {
            signal(SIGTSTP, SIG_IGN);      // 忽略SIGTSTP信号
            signal(SIGINT, shoupiaoyuan);  // 捕捉信号SIGINT
            signal(SIGQUIT, shoupiaoyuan); // 捕捉信号SIGQUIT
            signal(SIGUSR1, shoupiaoyuan); // 捕捉信号SIGUSR1
            pause();
        }
    }
    else // 父进程：司机
    {
        // 等待信号
        while (1)
        {
            signal(SIGINT, SIG_IGN);  // 忽略SIGINT
            signal(SIGQUIT, SIG_IGN); // 忽略SIGQUIT
            signal(SIGUSR1, siji);    // 捕捉信号SIGUSR1
            signal(SIGUSR2, siji);    // 捕捉信号SIGUSR2
            signal(SIGTSTP, siji);    // 捕捉信号SIGTSTP
            pause();
        }
    }
    return 0;
}

共享内存

概念

共享内存指的是操作系统在物理内存中申请一块空间，应用程序可以映射到这块空间，进行直接读写操作

特点

1.共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝
2.为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间
3.进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率
4.由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等

步骤

1.创建唯一key值        ftok
2.创建或打开共享内存        shmget
3.映射共享内存        shmat
4.取消映射        shmdt
5.删除共享内存        shmctl

函数接口

创建key值

#include <sys/types.h>
#include <sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);
功能：创建key值
参数：pathname：文件名
           proj_id：取整型数的低8位数值（一般是写一个字符 'a'）
返回值：成功：key值
              失败：-1
key值是根据pathname的inode号和proj_id的低8位组合而成的。

 

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>

int main(int argc, char const *argv[])
{
    key_t key;
    key = ftok("./test", 'a');
    if (key < 0)
    {
        perror("创建key值失败");
        return -1;
    }
    printf("key值为：%#x\n", key);
    return 0;
}

创建或打开共享内存

#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);
功能：创建或打开共享内存
参数：
        key  键值
        size   共享内存的大小
                             创建                      检测错误             创建共享内存的时候的权限
        shmflg   IPC_CREAT       |       IPC_EXCL       |             0666  
返回值：成功   shmid  共享内存的id
              出错    -1

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>

int main(int argc, char const *argv[])
{
    key_t key;
    int shmid;
    key = ftok("./test", 'a');
    if (key < 0)
    {
        perror("创建key值失败");
        return -1;
    }
    shmid = shmget(key, 64, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
        {
            shmid = shmget(key, 64, 0666);
        }
        else
        {
            perror("创建共享内存失败");
            return -1;
        }
    }
    printf("%d\n", shmid);

    return 0;
}

映射共享内存

void  *shmat(int  shmid,const  void  *shmaddr,int  shmflg);
功能：映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
参数：
        shmid   共享内存的id号
        shmaddr   一般为NULL，表示由系统自动完成映射
                         如果不为NULL，那么有用户指定
        shmflg：SHM_RDONLY就是对该共享内存只进行读操作
                                0        可读可写
返回值：成功：完成映射后的地址，
               出错：(void *)-1的地址

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

int main(int argc, char const *argv[])
{
    key_t key;
    int shmid;
    char *p;

    key = ftok("./test", 'a');
    if (key < 0)
    {
        perror("创建key值失败");
        return -1;
    }
    printf("key值为：%#x\n", key);

    shmid = shmget(key, 64, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
        {
            shmid = shmget(key, 64, 0666);
        }
        else
        {
            perror("创建共享内存失败");
            return -1;
        }
    }
    printf("shmid号为：%d\n", shmid);

    p = shmat(shmid, NULL, 0);
    if (p == (char *)-1)
    {
        perror("映射共享内存失败");
        return -1;
    }

    strcpy(p, "hello");
    printf("%s\n", p);

    return 0;
}

取消映射

int shmdt(const void *shmaddr);
功能：取消映射
参数：要取消的地址
返回值：成功:0  
               失败:-1

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

int main(int argc, char const *argv[])
{
    key_t key;
    int shmid;
    char *p;

    key = ftok("./test", 'a');
    if (key < 0)
    {
        perror("创建key值失败");
        return -1;
    }
    printf("key值为：%#x\n", key);

    shmid = shmget(key, 64, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
        {
            shmid = shmget(key, 64, 0666);
        }
        else
        {
            perror("创建共享内存失败");
            return -1;
        }
    }
    printf("shmid号为：%d\n", shmid);

    p = shmat(shmid, NULL, 0);
    if (p == (char *)-1)
    {
        perror("映射共享内存失败");
        return -1;
    }

    strcpy(p, "hello");
    printf("%s\n", p);
    
    // 阻塞观察内存状态
    // getchar();

    // 取消映射
    shmdt(p);

    return 0;
}

删除共享内存

int  shmctl(int  shmid,int  cmd,struct  shmid_ds   *buf);
功能：(删除共享内存)，对共享内存进行各种操作
参数：
        shmid   共享内存的id号
        cmd     IPC_STAT 获得shmid属性信息，存放在第三参数
                    IPC_SET 设置shmid属性信息，要设置的属性放在第三参数
                    IPC_RMID:删除共享内存，此时第三个参数为NULL即可
        struct  shmid_ds   *buf：是一个结构体指针，但我们是删除共享内存，所以并没有意义，我们直接设置为NULL就可以了
返回：成功0 
           失败-1

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

int main(int argc, char const *argv[])
{
    key_t key;
    int shmid;
    char *p;

    key = ftok("./test", 'a');
    if (key < 0)
    {
        perror("创建key值失败");
        return -1;
    }
    printf("key值为：%#x\n", key);

    shmid = shmget(key, 64, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
        {
            shmid = shmget(key, 64, 0666);
        }
        else
        {
            perror("创建共享内存失败");
            return -1;
        }
    }
    printf("shmid号为：%d\n", shmid);

    p = shmat(shmid, NULL, 0);
    if (p == (char *)-1)
    {
        perror("映射共享内存失败");
        return -1;
    }

    strcpy(p, "hello");
    printf("%s\n", p);

    // 阻塞观察内存状态
    // getchar();

    // 取消映射
    shmdt(p);

    // 删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

操作命令

ipcs -m：查看系统中创建的共享内存
ipcrm -m shmid：删除创建的共享内存

练习：通过共享内存实现进程间通信，一个进程从终端输入数据(input.c)，另一个进程打印数据(output.c)，循环执行，当输入quit时循环结束

input.c：

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

struct data
{
    int flag;
    char buf[32];
};

int main()
{
    key_t key;
    int shmid;
    struct data *p = NULL;

    key = ftok("./test", 'a');
    if (key < 0)
    {
        perror("创建key值失败");
        return -1;
    }
    printf("key值为：%#x\n", key);

    shmid = shmget(key, 64, IPC_CREAT | 0666);
    if (shmid < 0)
    {
        perror("创建共享内存失败");
        return -1;
    }
    printf("shmid号为：%d\n", shmid);

    p = (struct data *)shmat(shmid, NULL, 0);
    if (p == (struct data *)-1)
    {
        perror("映射共享内存失败");
        return -1;
    }
    p->flag = 0;
    while (1)
    {
        scanf("%s", p->buf);
        p->flag = 1;
        if (strcmp(p->buf, "quit") == 0)
        {
            break;
        }
    }
    shmdt(p);
    return 0;
}

output.c:

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
struct data
{
    int flag;
    char buf[32];
};

int main()
{
    key_t key;
    int shmid;
    struct data *p = NULL;

    key = ftok("./test", 'a');
    if (key < 0)
    {
        perror("创建key值失败");
        return -1;
    }
    printf("key值为：%#x\n", key);

    shmid = shmget(key, 64, 0666);
    if (shmid < 0)
    {
        perror("获取共享内存失败");
        return -1;
    }
    printf("shmid号为：%d\n", shmid);

    p = (struct data *)shmat(shmid, NULL, 0);
    if (p == (struct data *)-1)
    {
        perror("映射共享内存失败");
        return -1;
    }
    p->flag = 0;
    while (1)
    {
        if (p->flag == 1)
        {
            if (strcmp(p->buf, "quit") == 0)
            {
                break;
            }
            printf("读取到的数据: %s\n", p->buf);
            p->flag = 0;
        }
    }
    shmdt(p);
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}
何物爱惜雨#1110
关注
专栏目录
IO进程（学习）2024.8.17
何物爱惜雨的博客
08-18 1010
文件属性获取，目录操作，库，进程的相关知识
IO进程（学习）2024.8.20
何物爱惜雨的博客
08-20 1258
线程同步和线程互斥的相关知识，包括信号量函数，互斥锁函数，条件变量相关知识
IO进程（学习）2024.8.14
何物爱惜雨的博客
08-14 830
标准IO的概念，特点，缓存区，文件IO函数的相关知识
IO进程（学习）2024.8.23
何物爱惜雨的博客
08-23 1509
信号灯集的相关知识,消息队列的相关知识
IO进程（学习）2024.8.21
何物爱惜雨的博客
08-21 1138
进程间通信方式的相关知识，无名管道和有名管道的相关知识，信号的相关知识
IO进程（学习）2024.8.19
何物爱惜雨的博客
08-19 1144
进程函数(创建进程，进程回收，进程退出，获取进程号)相关知识，线程的相关知识，线程函数(创建线程，线程回收，线程退出，获取线程ID，线程分离函数，取消线程)相关知识
2024.8.22（Docker）
weixin_70751278的博客
08-22 1127
日常的业务量大多很平均,但在业务量繁多时期,比如“双十一”,“春运购票”等场景,就需要对服务器进行横向扩展才能将负载均衡下来,而如果大规模地扩展服务器,待服务器满载时期过去,回到日常业务量后,就会导致剩余资源极大地浪费。Linux是一个支持多用户的操作系统,正因如此,可能会造成用户使用时,互相之间占用资源过多,以致于服务器资源空间不足,而docker具有隔离性,可以在启动时就限定好硬件的使用率,当某个容器到达或超过限定的阈值时,就会被kill,此时需要运维人员对其进行调试。
IO进程（学习）2024.8.15
何物爱惜雨的博客
08-15 772
重定向打开文件，文件IO的概念特点函数的相关知识
文件IO 2024.8.14作业
2301_77001235的博客
08-14 130
进程
2024java面试题.docx
07-25
#### 8. 解释Java中的泛型。 **解析**：泛型是Java中用于增强类型安全性和代码复用性的强大工具。 - **基本概念**：泛型通过使用类型参数（如`<T>`）来实现。 - **优点**：使用泛型可以避免类型转换错误，并提高...
浅析kubernetes中client-go Informer
期待幸福
05-25 331
之前了解了client-go中的架构设计，也就是 tools/cache 下面的一些概念，那么下面将对informer进行分析 Controller 在client-go informer架构中存在一个 controller ，这个不是 Kubernetes 中的Controller组件；而是在 tools/cache 中的一个概念，controller 位于 informer 之下，Reflector 之上。code Config 从严格意义上来讲，controller 是作为一个 sharedInfo
运维实践 | 运维打工人必备 CentOS-Linux/Stream-8 服务器系统基础安装与配置实践...
WeiyiGeek 唯一极客IT知识分享
06-15 351
本章主要记录了作者在工作生产环境中使用 redhat社区版本CentOS Linux 8 / CentOS Stream 8说明以及服务器系统安装基础设置，和CentOS发行版版本新特性配置实践，帮助各位运维人快速入手运维配置，由于CentOS即将停止维护了，本文也可能后续不在进行更新，算是针对CentOS 8 系统运维的一个总结，希望大家多多支持我哟。
[漏洞挖掘与防护] 02.漏洞利用之MS08-067远程代码执行漏洞复现及深度防御
杨秀璋的专栏
07-14 562
上一篇文章将详细介绍Windows远程桌面服务漏洞（CVE-2019-0708），该高危漏洞利用方式是通过远程桌面端口3389，RDP协议进行攻击。这篇文章将详细讲解MS08-067远程代码执行漏洞（CVE-2008-4250）及防御过程，它是Windows Server服务RPC请求缓冲区溢出漏洞，利用445端口，并通过Metasploit工具获取shell及进行深入的操作。希望对入门的同学有帮助。
Spring Boot 学习和使用
cesske的博客
09-24 1210
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
大模型输入参数学习
AI智能，无处不在
09-25 551
top_p和top_k：用于控制生成文本的多样性和连贯性。较小的值会使生成的文本更连贯但缺乏多样性，较大的值会使生成的文本更随机和多样。：用于控制生成文本的随机性。较高的值增加随机性，较低的值增加确定性。：用于控制生成文本的长度。
Nexus学习
howwickhappy的博客
09-24 1006
Nexus 是一个开源的仓库管理器，用于管理和分发软件构建的组件。
Linux入门学习：进程概念
Lvision2的博客
09-24 1093
在课本的概念中，进程程序的一个执行实例，正在执行的程序。其内核观点：担当分配系统资源（CPU时间，内存）的实体。但这些概念太笼统，并不能让我们更加清晰的知道进程是什么，实际上，进程是内核数据结构(pcb) + 程序的代码与数据。pcb(process control block)进程控制块，进程信息被放在一个叫pcb的数据结构中，可以理解为进程属性的集合。在Linux入门学习：深刻理解计算机硬件与OS体系中，我们已经了解到。
H.264学习笔记
最新发布
zfenggo的博客
09-26 787
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值