IOday8

已于 2023-04-04 20:23:23 修改
阅读量74 收藏
点赞数
文章标签： java c++ c语言
于 2023-04-04 19:05:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69454187/article/details/129959783
版权

1.单次发送单次读

//fifo的创建
#include <head.h>
int main(int argc,const char * argv[])
{
    if(mkfifo("./fifo1",0666) < 0){
    perror("mkfifo");
    return -1;
    }
    if(mkfifo("./fifo2",0666) < 0){
    perror("mkfifo");
    return -1;
    }
    
    getchar();
    system("sudo rm fifo1");//关闭
    system("sudo rm fifo2");
    return 0;
    return 0;
}
//read.c
#include <head.h>
int main(int argc,const char * argv[])
{
    int fd = open("/home/ubuntu/xwf/IOday6/fifo1",O_RDWR);//打开管道1
    if(fd < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return -1;
    }
    int fd1 = open("/home/ubuntu/xwf/IOday6/fifo2",O_RDWR);//打开管道2
    if(fd1 < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return -1;
    }
    char buf[128] = "";
    char str[128] = "";
    while(1){//读write
        memset(buf,0,sizeof(buf));
        read(fd,buf,sizeof(buf));
        printf("read.c read:%s\n",buf);
        if(0 == strcmp(buf,"quit")){
            break;
        }

        //read.c write:
        printf("read.c write\n");//写入管道
        scanf("%s",str);
        write(fd1,str,sizeof(str));
        if(0 == strcmp(str,"quit")){
            break;
        }
        memset(str,0,sizeof(str));


    }
    return 0;
}
//write
#include <head.h>
char buf[128] = "";
char str[128] = "";
int main(int argc,const char * argv[])
{
    int fd = open("/home/ubuntu/xwf/IOday6/fifo1",O_RDWR);
    if(fd < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return -1;
    }
    int fd1 = open("/home/ubuntu/xwf/IOday6/fifo2",O_RDWR);
    if(fd1 < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return -1;
    }

    while(1){
        printf("write.c -->write:\n");//写入管道
        scanf("%s",buf);
        write(fd,buf,sizeof(buf));
        if(0 == strcmp(buf,"quit")){
            break;
        }
        memset(buf,0,sizeof(buf));

        //读出read.c中输出的
        memset(str,0,sizeof(str));//读管道
        read(fd1,str,sizeof(str));
        printf("write.c -->read:%s\n",str);
        if(0 == strcmp(str,"quit")){
            break;
        }     
    }
    return 0;
}

2.多次发送多次读

//管道创建
#include <head.h>
int main(int argc,const char * argv[])
{
    if(mkfifo("./fifo1",0666) < 0){
    perror("mkfifo");
    return -1;
    }
    if(mkfifo("./fifo2",0666) < 0){
    perror("mkfifo");
    return -1;
    }
    
    getchar();
    system("sudo rm fifo1");
    system("sudo rm fifo2");
    return 0;
    return 0;
}
//read.c
#include <head.h>
char buf[128] = "";
char str[128] = "";
pthread_t tid,tid1;
void* READ(void* arg){//第一个线程打开管道1
    int fd = open("/home/ubuntu/xwf/IOday6/fifo1",O_RDWR);
    if(fd < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return NULL;
    }
    while(1){//读管道1
        memset(str,0,sizeof(str));
        read(fd,str,sizeof(str));
        printf("01_read.c -->read:%s\n",str);
        if(0 == strcmp(str,"quit")){
            break;
        } 
    }
    close(fd);//退出后要请求第二个线程退出
    pthread_cancel(tid1);
    pthread_exit(NULL);
}
void* WRITE(void* arg){//第二个线程打开管道2
    int fd1 = open("/home/ubuntu/xwf/IOday6/fifo2",O_RDWR);
    if(fd1 < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return NULL;
    }
    while(1){//写入管道2
        printf("01_read.c -->write:\n");
        scanf("%s",buf);
        write(fd1,buf,sizeof(buf));
        if(0 == strcmp(buf,"quit")){
            break;
        }
        memset(buf,0,sizeof(buf));   
    }
    close(fd1);//退出后要请求第一个线程退出
    pthread_cancel(tid);
    pthread_exit(NULL);
}
int main(int argc,const char * argv[])
{

    //创建两个线程
    if(pthread_create(&tid,NULL,WRITE,NULL) != 0){
        printf("error\n");
        return -1;
    }
    if(pthread_create(&tid,NULL,READ,NULL) != 0){
        printf("error\n");
        return -1;
    }


    pthread_join(tid,NULL);
    pthread_join(tid1,NULL);

    return 0;
}
//write.c
#include <head.h>
char buf[128] = "";
char str[128] = "";
pthread_t tid,tid1;
void* WRITE(void* arg){
    int fd = open("/home/ubuntu/xwf/IOday6/fifo1",O_RDWR);
    if(fd < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return NULL;
    }
    while(1){
        printf("01_write.c -->write:");
        scanf("%s",buf);
        write(fd,buf,sizeof(buf));
        if(0 == strcmp(buf,"quit")){
            break;
        }
        memset(buf,0,sizeof(buf));  
    }
    close(fd);
    pthread_cancel(tid1);
    pthread_exit(NULL);
}
void* READ(void* arg){
    int fd1 = open("/home/ubuntu/xwf/IOday6/fifo2",O_RDWR);
    if(fd1 < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return NULL;
    }
    while(1){
        memset(str,0,sizeof(str));
        read(fd1,str,sizeof(str));
        printf("01_write.c -->read:%s\n",str);
        if(0 == strcmp(str,"quit")){
            break;
        }  
    }
    close(fd1);
    pthread_cancel(tid);
    pthread_exit(NULL);
}
int main(int argc,const char * argv[])
{

    //创建两个线程
    if(pthread_create(&tid,NULL,WRITE,NULL) != 0){
        printf("error\n");
        return -1;
    }
    if(pthread_create(&tid1,NULL,READ,NULL) != 0){
        printf("error\n");
        return -1;
    }


    pthread_join(tid,NULL);
    pthread_join(tid1,NULL);

    return 0;
}


//第二种方法
//fifo文件一致
//read.c
#include <head.h>
int main(int argc,const char * argv[])
{
    char str[128] = "";
    char buf[128] = "";
    pid_t pid;
    pid = fork();
    if(pid > 0){//实现读
        int fd = open("/home/ubuntu/xwf/IOday6/fifo1",O_RDWR);
        if(fd < 0){
            perror("open");
            printf("__%d__",__LINE__);
            return -1;
        }
        while(1){
            memset(str,0,sizeof(str));
            read(fd,str,sizeof(str));
            printf("02_read.c -->read:%s\n",str);
            if(0 == strcmp(str,"quit")){
                break;
            } 
        }
        close(fd);
        kill(pid,9);

    }else if(0 == pid){//子进程实现写
        int fd1 = open("/home/ubuntu/xwf/IOday6/fifo2",O_RDWR);
    if(fd1 < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return -1;
    }
    while(1){
        printf("02_read.c -->write:\n");
        scanf("%s",buf);
        write(fd1,buf,sizeof(buf));
        if(0 == strcmp(buf,"quit")){
            break;
        }
        memset(buf,0,sizeof(buf));   
    }
    close(fd1);
    kill(getppid(),9);

    }else{//创建错误
        printf("error\n");
        return -1;
    }


    wait(NULL);
    return 0;
}
//write.c
#include <head.h>
int main(int argc,const char * argv[])
{
    char str[128] = "";
    char buf[128] = "";
    pid_t pid;
    pid = fork();
    if(pid > 0){//实现读
        int fd = open("/home/ubuntu/xwf/IOday6/fifo2",O_RDWR);
        if(fd < 0){
            perror("open");
            printf("__%d__",__LINE__);
            return -1;
        }
        while(1){
            memset(str,0,sizeof(str));
            read(fd,str,sizeof(str));
            printf("02_write.c -->read:%s\n",str);
            if(0 == strcmp(str,"quit")){
                break;
            } 
        }
        kill(pid,9);
        close(fd);
        
    }else if(0 == pid){//子进程实现写
        int fd1 = open("/home/ubuntu/xwf/IOday6/fifo1",O_RDWR);
    if(fd1 < 0){
        perror("open");
        printf("__%d__",__LINE__);
        return -1;
    }
    while(1){
        printf("02_write.c -->write:\n");
        scanf("%s",buf);
        write(fd1,buf,sizeof(buf));
        if(0 == strcmp(buf,"quit")){
            break;
        }
        memset(buf,0,sizeof(buf));

    }
    kill(getppid(),9);
    close(fd1);
    }else{//创建错误
        printf("error\n");
        return -1;
    }


    wait(NULL);
    return 0;
}

3.捕捉2，3，20号信号

#include <head.h>
void hander(int arg){
    printf("信号2响应了一次\n");
    return ;
}
void hander1(int arg){
    printf("信号3响应了一次\n");
    return ;
}
void hander2(int arg){
    printf("信号20响应了一次\n");
    return ;
}
int main(int argc,const char * argv[])
{
    __sighandler_t s = signal(2,hander);
    if(SIG_ERR == s){
        printf("__%d__\n",__LINE__);
        perror("signal");
        return -1;
    }
    __sighandler_t s1 = signal(3,hander1);
    if(SIG_ERR == s1){
        printf("__%d__\n",__LINE__);
        perror("signal");
        return -1;
    }
    __sighandler_t s2 = signal(20,hander2);
    if(SIG_ERR == s2){
        printf("__%d__\n",__LINE__);
        perror("signal");
        return -1;
    }

    while(1){
        printf("./sig....\n");
        sleep(1);

    }
    return 0;
}

椛榯
关注
IODAY8
rryy3344的博客
08-14 435
通过共享内存，实现2个终端之间的互相聊天。
IOday 8
fh2331的博客
08-06 152
1.附加题写的有点问题xmind。
IOday8作业
Djdbds的博客
12-11 272
【代码】IOday8作业。
华清学习IOday8
weixin_57603834的博客
08-06 129
思维导图。
IOday8PIC通信
xiaohuoxingdezhu的博客
08-05 121
【代码】IOday8PIC通信。
IODay8作业
weixin_57136489的博客
02-26 415
【代码】IODay8作业。
2024/4/9 IOday8
m0_67764503的博客
04-09 300
2：将昨天的作业(使用管道让2个终端之间互相聊天) 使用共享内存 + 信号灯集去实现。
王杰IOday8
wwjj26的博客
09-14 225
【代码】王杰IOday8。
IOday8作业（2023/12/14）
weixin_45340901的博客
12-14 87
Java_IO流02：文件流
小贺想改变
10-19 677
对Java中IO流的部分关于文件流的一个详解和文本复制、图片复制的详解
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1224
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 933
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 364
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 705
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 377
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 365
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 195
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1374
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
租拼车平台|小区租拼车管理|基于java的小区租拼车管理信息系统小程序设计与实现(源码+数据库+文档)
伟庭的博客
10-06 862
在设计小区租拼车管理信息平台时，功能模块充分融合了用户与管理员的实际需求，实现了多元化且全面的小区租拼车管理信息功能。介绍了微信小程序小区租拼车管理信息系统的系统分析部分，包括可行性分析等，系统设计部分主要介绍了系统功能设计和数据库设计。本微信小程序小区租拼车管理信息系统功能有个人中心，用户管理，汽车信息管理，汽车入库管理，汽车出库管理，汽车租赁管理，汽车归还管理，汽车拼车管理，拼车信息管理，留言板管理，系统管理等。因而具有一定的实用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值