8.5IO进程线程

最新推荐文章于 2024-09-10 20:56:43 发布
最新推荐文章于 2024-09-10 20:56:43 发布
阅读量1.3k 收藏 10
点赞数 47
文章标签： 服务器 linux 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81236242/article/details/140930972
版权

笔记

进程

三.进程间通信（IPC）

3.1进程间通信的引入

        1> 对于多个线程之间通信，我们可以使用临界资源来完成，通过一个线程任务对临界资源进行修改，另一个线程也可以使用已经修改过的临界资源，但是要注意使用同步互斥机制完成对临界资源的保护

        2> 多个进程之间不能使用全局变量来进行进程间通信，多个进程之间的用户空间是相互独立的，每个进程的全局变量是各个进程独立拥有的，更改一个进程的全局变量，另一个进程不会受到影响，故而不能使用全局变量来完成通信

        3> 使用文件来完成进程间通信是可行的，但是要求写进程先完成向文件中写入数据，然后读进程才能读取数据，必须要加入进程的同步操作

        4> 多个进程之间内核空间是共享的，我们可以通过将数据放入到内核空间，来完成两个进程之间信息的交流

        5> 进程间通信方式：

                        1、内核提供的原始通信方式

                                无名管道 有名管道 信号

                        2、system V提供三种

                                 消息队列 共享内存 信号量集

3.2无名管道

        1> 顾名思义就是没有名字的管道文件，所以只能适用于亲缘进程间的通信

        2> 原理：通过内核，在内存中创建出一个管道文件，存放在内存空间，并不在文件系统中真实存在。当打开该文件时，会返回该文件的两个文件描述符，分别对应读端和写端。可以通过读端从管道中读取数据，从写端向管道中写入数据。当该文件的读写两端全部被关闭后，该管道文件会在内存中消失

        3> 注意：由于打开管道时返回的是文件描述符，所以，对该文件的操作，只能使用文件IO

对于存入管道中的数据的读取是一次性的，当数据读取结束后，数据就不存在于管道文件中了

        4> 无名管道的API接口函数

       #include <unistd.h>

       int pipe(int pipefd[2]);
       功能：在通过内核在内存中创建一个无名管道，并通过参数将该管道文件的两个文件描述符返回
       参数：接收文件描述符的数组，pipefd[0]表示管道文件的读端，pipefd[1]表示管道的写端
       返回值：成功返回0，失败返回-1并置位错误码
3.3有名管道

        1> 顾名思义就是有名字的管道文件，会在文件系统中创建一个有名字的管道文件

        2> 可以用于亲缘进程间的通信，也可以用于非亲缘进程间的通信

        3> 有名管道的API函数

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

       int mkfifo(const char *pathname, mode_t mode);
    功能：在文件系统中创建一个有名管道，但是并没有打开该文件
    参数1：有名管道的名称
    参数2：管道文件的权限
    返回值：成功返回0，失败返回-1并置位错误码
3.4信号通信

1> 信号通信原理图：两个异步通信的进程之间，通过发送相关信号，完成任务间的通信

        2> 信号是linux中软件模拟硬件的“中断”的一种方式。信号是软件部分的名词，中断是硬件部分的名词

        3> 能够发送的信号可以通过指令：kill -l进行查看

        4> 对于信号的处理方式有三种：默认、捕获、忽略

有两个信号既不能被捕获，也不能被忽略：SIGKILL、SIGSTOP

        5> 上面的信号触发条件以及默认处理方式可以通过指令 man 7 signal进行查看

        6> 信号的发送者可以是内核、其他进程、用户自己

        7> 将信号与信号处理方式连接函数

       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);
       功能：将信号与信号处理函数绑定到一起
       参数1：要绑定的信号
       参数2：信号处理函数
               SIG_IGN：表示忽略信号
               SIG_DFL：表示默认处理
               填自定义函数的入口地址
        返回值：成功返回处理方式的起始地址，失败返回 SIG_ERR
3.5特殊的信号处理

        1> SIGCHLD信号：以非阻塞的形式回收僵尸进程

#include<myhead.h>

//自定义信号处理函数
void handler(int signo)
{
    if(signo == SIGCHLD)
    {
        while(1)
        {
            //判断是否将僵尸进程全部回收了
            if(waitpid(-1, NULL, WNOHANG) == 0)
            {
                break;
            }
        }
    }
}

/******************主程序**********************/
int main(int argc, const char *argv[])
{
    //将SIGCHLD信号与信号处理函数绑定到一起
    if(signal(SIGCHLD, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }


    for(int i=0; i<10; i++)
    {
        if(fork() == 0)
        {
            exit(EXIT_SUCCESS);
        }
    
    }

    while(1);

    /*
    for(;;)
    {
        printf("我是小妖怪，逍遥游自在\n");
        sleep(1);
    }*/

    return 0;
}

        2> SIGALRM：定时器信号

程序允许启动一个定时器，当所定的时间到位后，会发送一个SIGALRM信号，我们可以将该信号绑定到对应的信号处理函数中，从而导致，给定时间后，处理自定义函数。该信号需要使用一个函数来发送超时信号：alarm闹钟函数

  #include <unistd.h>

       unsigned alarm(unsigned seconds);
    功能：给进程设置一个定时器，以秒为单位，当定时器到位后，后向该进程发送一个SIGALRM的信号
    参数：秒数，如果参数设置成0，表示删除定时器
    返回值：>0:表示返回的上一个定时器剩余的秒数，并且重置上一个定时器
            0：表示之前没有设置定时器
#include<myhead.h>

//定义信号处理函数
void handler(int signo)
{
    if(signo == SIGALRM)
    {
        printf("阎王叫你三更死，怎可留人到五更\n");
        sleep(2);
        exit(EXIT_SUCCESS);
    }
}


/********************主程序******************/
int main(int argc, const char *argv[])
{

    //将SIGALRM信号与信号处理函数绑定
    if(signal(SIGALRM, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }


    printf("%d\n", alarm(10));          //0

    sleep(5);


    printf("%d\n", alarm(10));          //5


    int count = 0;
    while(1)
    {
        printf("能活一秒是一秒\n");
        sleep(1);
        /*
        count++;
        if(count == 3)
        {
            alarm(0);           //删除定时器
        }
        */
    }

    return 0;
}

        3> 信号的发送函数

       #include <signal.h>

       int kill(pid_t pid, int sig);
       功能：向指定的进程发送指定的信号
       参数1：要发送的进程号
           >0:表示向指定的进程发送信号
           =0：表示向某个进程组（当前进程所在的进程组）中发送信号
           =-1：向所有进程发送信号
           <-1:表示向其他进程组（组id为给定pid的绝对值）发送信号
       参数2：要发送的信号号
       返回值：      成功返回0，失败返回-1并置位错误码
       
       #include <signal.h>

       int raise(int sig);
       功能：向自己所在的进程发送指定的信号
       参数：要发送的信号
       返回值：成功返回0，失败返回非0数字

作业

1> 使用有名管道实现，一个进程用于给另一个进程发消息，另一个进程收到消息后，展示到终端上，并且将消息保存到文件上一份

#include<myhead.h>
int main(int argc, char const *argv[])
{
    if(mkfifo("./fifo",0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }
    return 0;
}
#include<myhead.h>
int main(int argc, char const *argv[])
{
    int fp=-1;
    if((fp=open("./fifo",O_WRONLY))==-1)
    {
        perror("open fp error");
        return -1;
    }
    char buf[128]="";
    printf("对方已上线\n");
    while(1)
    {
        printf("请输入：\n");
        fgets(buf,sizeof(buf),stdin);
        buf[strlen(buf)-1]=0;
        write(fp,buf,strlen(buf)); 
        if(strcmp(buf,"quit")==0)
        {
            break;
        }
        
    }
    close(fp);
    return 0;
}
#include<myhead.h>
int main(int argc, char const *argv[])
{
    int fp=-1;
    int fd=-1;
    if((fp=open("./fifo",O_RDONLY))==-1)
    {
        perror("open fp error");
        return -1;
    }
    if((fd=open("./1.txt",O_WRONLY|O_APPEND|O_CREAT,0664))==-1)
    {
        perror("open fd error");
        return -1;
    }
    char buf[128]="";
    printf("对方已上线\n");
    while(1)
    {
        bzero(buf,sizeof(buf));
        read(fp,buf,sizeof(buf)); 
        if(strcmp(buf,"quit")==0)
        {
            break;
        }
        printf("输出：%s\n",buf);
        fflush(stdout);
        write(fd,buf,strlen(buf));
    }
    close(fp);
    close(fd);
    return 0;
}

2> 使用有名管道实现两个进程间相互通信

#include<myhead.h>
int main(int argc, char const *argv[])
{
    if(mkfifo("./fifo1",0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }
    if(mkfifo("./fifo2",0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }
    return 0;
}
#include<myhead.h>
void*output(void *fd)
{
    int fp=*((int*)fd);
    char sbuf[128]="";
    while(1)
    {  
        bzero(sbuf,sizeof(sbuf));
        read(fp,sbuf,sizeof(sbuf));
        if(strcmp(sbuf,"quit")==0)
        {
            break;
        }
        printf("\t\t\t%s:user2\n",sbuf);
    }
    close(fp);
    pthread_exit(NULL);
}
void*input(void *fd)
{
    int fp=*((int*)fd);
    printf("对方已上线\n");
    char sbuf[128]="";
    while(1)
    {
        usleep(10);
		fgets(sbuf,sizeof(sbuf),stdin);
		sbuf[strlen(sbuf)-1]=0;
		write(fp,sbuf,strlen(sbuf));
		if(strcmp(sbuf,"quit")==0)
		{
			break;
		}
    }
    close(fp);
    pthread_exit(NULL);
} 
int main(int argc, char const *argv[])
{
    int outfd=open("./fifo1",O_RDONLY);
    if(outfd==-1)
    {
        perror("open error");
        return-1;
    }
    int infd=open("./fifo2",O_WRONLY);
    if(infd==-1)
    {
        perror("open error");
        return-1;
    }
    pthread_t tid1=-1;
    if(pthread_create(&tid1,NULL,output,&outfd)!=0)
    {
        printf("pthread_create error\n");
        return-1;
    }
    pthread_t tid2=-1;
    if(pthread_create(&tid2,NULL,input,&infd)!=0)
    {
        printf("pthread_create error\n");
        return-1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);

    return 0;
}
#include<myhead.h>
void*output(void *fd)
{
    int fp=*((int*)fd);
    char sbuf[128]="";
    while(1)
    {  
        bzero(sbuf,sizeof(sbuf));
        read(fp,sbuf,sizeof(sbuf));
        if(strcmp(sbuf,"quit")==0)
        {
            break;
        }
        printf("\t\t\t%s:user1\n",sbuf);
    }
    close(fp);
	pthread_exit(NULL);
}
void*input(void *fd)
{
    int fp=*((int*)fd);
    printf("对方已上线\n");
    char sbuf[128]="";
    while(1)
    {
        usleep(10);
		fgets(sbuf,sizeof(sbuf),stdin);
		sbuf[strlen(sbuf)-1]=0;
		write(fp,sbuf,strlen(sbuf));
		if(strcmp(sbuf,"quit")==0)
		{
			break;
		}
    }
    close(fp);
	pthread_exit(NULL);
} 
int main(int argc, char const *argv[])
{
	int infd=open("./fifo1",O_WRONLY);
    if(infd==-1)
    {
        perror("open error");
        return-1;
    }
    int outfd=open("./fifo2",O_RDONLY);
    if(outfd==-1)
    {
        perror("open error");
        return-1;
    }
    
    pthread_t tid1=-1;
    if(pthread_create(&tid1,NULL,output,&outfd)!=0)
    {
        printf("pthread_create error\n");
        return-1;
    }
    pthread_t tid2=-1;
    if(pthread_create(&tid2,NULL,input,&infd)!=0)
    {
        printf("pthread_create error\n");
        return-1;
    }
    pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
    return 0;
}

思维导图

木旻舟
关注
  • 47
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
8.5 IO进程线程
m0_60082979的博客
08-05 68
B进程将共享内存中的整型以及字符串读取出来。A进程写入一个整型，在该整型后，写入一个字符串。1、AB进程能够随时收发数据。
8.5（IO进程线程）Day 1
weixin_69367386的博客
08-06 312
【代码】8.5（IO进程线程）Day 1。
8.5-IO进程线程-作业
m0_72775916的博客
08-05 133
直到A进程或者B进程收到quit，退出AB进程；B进程任意时刻发送给A进程一句话，A进程接收打印。A进程写入一个整型，在该整型后，写入一个字符串。B进程将共享内存中的整型以及字符串读取出来。A进程任意时刻发送一句话，B进程接收打印。1）要求AB进程做通信。...
IO与进线程
qq_64076967的博客
10-24 686
使用fork()函数得到的子进程时父进程的一个复制品，它从父进程那里继承了整个进程的地址空间，包括父进程的上下文、代码段、进程堆栈、内存信息、打开的文件描述符、信号处理函数、进程优先级、进程组id、当前工作目录、根目录等，而子进程独有的只有进程id、资源使用和计数器等。执行完后，当前进程除了进程外，其它内容都被替换。​ 线程的基本操作有线程创建(pthread_create())，线程资源回收(pthread_join()、pthread_detach())，线程退出(pthread_exit())等。
Linux系统编程【文件IO、进程、进程间通信、信号、线程、互斥】
weixin_45045804的博客
09-29 1680
个人通过学习，手打了一份48000字的Linux系统编程的笔记，包含了【文件IO、进程、进程间通信、信号、多线程、互斥】等知识点，并给出了大量的代码案例对每个重要的知识点进行了代码演示，通过理论和实操的结合，更好的透析每个知识点，为后续的unix网络编程打下基础。
IO进程线程day1作业
2301_79612992的博客
05-06 181
【代码】IO进程线程day1作业。
io多线程 性能 扯犊子
weixin_34405332的博客
12-30 118
2019独角兽企业重金招聘Python工程师标准>>> ...
Python异常处理和进程线程
weixin_30484739的博客
07-01 833
写在前面 　　　　最坏的结果，不过是大器晚成； 一、异常处理 　　- 1.语法错误导致的异常 　　　　-这种错误，根本过不了python解释器的语法检测，必须在程序运行前就修正； 　　- 2.逻辑上的异常 　　　　- 即逻辑错误，例如除零错误； 　　　　- 异常相关信息：异常的追踪信息 + 异常类型 + 异常值 　　　　- 异常种类 1 Arithm...
IO进程线程第八天（8.5）IPC机制（无名管道，有名管道，信号）+XMind
yymbxqdm的博客
08-06 134
要求实现AB进程对话 A进程先发送一句话给B进程，B进程接收后打印 B进程再回复一句话给A进程，A进程接收后打印 重复1.2步骤，当收到quit后，要结束AB进程
Linux多线程服务端编程：使用muduo C++网络库
08-17
4.6多线程与IO . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . 98 4.7用RAII 包装文件描述符.. . . . . . . . . . . . . . . . . . . . . . . . . . 99 4.8RAII 与fork() . . . . . . . . . ....
IO协议栈前沿技术研究动态（2015存储峰会分享）
PMC的专栏
12-25 1992
冬瓜哥在由DOIT传媒举办的12月10日的中国存储峰会上做了一次有关IO协议栈前沿技术和动态的技术分享，以下是演讲的精华内容。
09.线程优化实践操作
杨充
06-26 271
线程优化实践操作
本地Linux服务器使用docker搭建DashDot并实现公网实时监测服务器信息
小沈.的博客
09-10 746
本地Linux服务器使用docker搭建DashDot并实现公网实时监测服务器信息
Linux：五种IO模型
MaoRuofeng的博客
09-09 787
阻塞IO: 在内核将数据准备好之前,系统调用会一直等待.所有的套接字,默认 都是阻塞方式。非阻塞 IO: 如果内核还未将数据准备好, 系统调用仍然会直接返回, 并且返回EWOULDBLOCK 错误码。 非阻塞 IO 往往需要循环的方式反复尝试读写文件描述符(对于CPU会有较大的浪费), 这个过程称为轮询。 信号驱动 IO: 内核将数据准备好的时候, 使用 SIGIO 信号通知应用程序进行 IO操作。IO 多路转接: 虽然从流程图上看起来
配置全新服务器深度学习一套流程
最新发布
weixin_70379932的博客
09-10 539
NCU服务器配置深度学习环境
Linux下基于TCP协议的简易服务器实现（C语言）
S13352784013的博客
09-03 1638
Linux下基于TCP协议的简易服务器实现（C语言）
如何选择国内大带宽服务器租用？
wanhengwangluo的博客
09-07 391
企业在进行选择服务器时，带宽的大小是决定数据信息传输速率的关键因素，大带宽服务器一般都是指可以为企业提供高于传统带宽的服务器，对于流量比较大和用户访问较为密集的网站和企业来说，大带宽能够保证在高峰时段用户仍然享受到快速响应和流量体验。国内的大带宽服务器租用一般是指能够提供较大的网络带宽的服务器租用服务，以此来满足对高速网络访问需求比较高的用户和业务，企业在选择国内的大带宽服务器租用能需要考虑到哪些因素呢？
【银河麒麟高级服务器操作系统】虚拟机服务器执行systemctl提示timeout——分析全过程及处理建议
银河麒麟操作系统的博客
09-10 698
了解全新产品，请点击访问产品信息产品名称银河麒麟高级服务器操作系统（海光版）V10ISO环境信息主机型号虚拟机systemd崩溃，后续systemd连接异常，systemctl失败。需要查明systemd崩溃原因根据sosreport中的messages信息，systemd发生了coredump，收到了信号SIGQUIT。见图2.1.1图2.1.1使用gdb分析systemd的coredump文件，显示systemd是收到了SIGQUIT后发生的coredump。并未调用错误处理函数。
理解IO与线程进程：标准IO库和缓冲机制
"IO与线程进程" 在计算机科学中，IO（Input/Output）是指程序与外部设备（如硬盘、键盘、显示器等）之间交换数据的过程。线程和进程则是操作系统中并行处理任务的基本单位。理解IO和线程进程的关系对于编写高效、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值