进程间通信

最新推荐文章于 2022-08-18 17:35:24 发布
最新推荐文章于 2022-08-18 17:35:24 发布
阅读量272 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42487214/article/details/81835768

学习内容：

一、进程间通信方式

1、有名管道（FIFO）和管道（PIPO）。

管道：（1）单向，先进先出，把一个进程的输入和输出连接在一起。

           （2）在管道的尾部写入程序，在管道的头部读出数据。

           （3）数据被一个进程读取后，将从管道删除。

           （4）进程阻塞情况：读空管道时，或者进程已经写满。、

*（无名）管道：父进程和子进程之间的通信        int   pipe( int   fieldis[2] ) ;     数组保存两个文件描述符

                                                                                                                         fieldis[0]  用于读管道      fieldis[1]  用于写管道

父进程写程序，子进程读程序：

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

void ReadData(int fd)
{
    int ret;
    char buf[32]={0};
    while(1)
    {
        ret = read(fd,buf,sizeof(buf));
        if(-1 == ret)
        {
            perror("read");
            exit(1);
        }
        if(!strcmp(buf,"bye"))
        {
            break;
        }
        printf("read from pipe: %s\n",buf);
        memset(buf, 0, sizeof(buf));
    }
    close(fd);
}

void WriteData(int fd)
{
    int ret;
    char buf[32]={0};
    while(1)
    {
        scanf("%s",buf);

        ret = write(fd,buf,strlen(buf));
        if(-1 == ret)
        {
            perror("write");
            exit(1);
        }
        if(!strcmp(buf,"bye"))
        {
            break;
        }
        memset(buf, 0, sizeof(buf));
    }
    close(fd);
}

int main()
{
    int ret ,fd[2]={0};
    pid_t pid;
    ret = pipe(fd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }
    pid = fork();
    if(-1 == pid)
    {
        perror("fork");
        exit(1);
    }
    else if(0 == pid)               //子进程
    {
        close(fd[1]);
        ReadData(fd[0]);
    }
    else                            //父进程
    {
        close(fd[0]);
        int status;
        WriteData(fd[1]);
        wait(&status);
    }
    return 0;
}

必须在使用fork()函数之前调用pipe()创建管道，否则子进程不会继承父进程的文件描述符 

*有名管道：任意两个进程间的通信

写文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

int main()
{
    int ret,fd;
    char buf[32]={0};
   /* ret = mkfifo("fifo.tmp",666);
    if(ret == -1)
    {
        perror("mkfifo");
        exit(1);
    }*/
    fd = open("fifo.tmp",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    while(1)
    {
        scanf("%s",buf);
        ret = write(fd,buf,strlen(buf));
        if(-1 == ret)
        {
            perror("write");
            exit(1);
        }
        if(!strcmp(buf,"bye"))
        {
            break;
        }
        
        memset(buf,0,sizeof(buf));
    }
    close(fd);
    return 0;
}

读文件 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

int main()
{
    int ret,fd;
    char buf[32]={0};
    ret = mkfifo("fifo.tmp",666);
    if(ret == -1)
    {
        perror("mkfifo");
        exit(1);
    }
    fd = open("fifo.tmp",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    while(1)
    {
        ret = read(fd,buf,sizeof(buf));
        if(-1 == ret)
        {
            perror("read");
            exit(1);
        }
        if(!strcmp(buf,"bye"))
        {
            break;
        }
        printf("%s\n",buf);
        memset(buf,0,sizeof(buf));
    }
    close(fd);
    unlink("fifo.tmp");
    return 0;
}

匹配到bye 则终止 

2、信号。

#include <stdio.h>
#include <signal.h>
void print(int num)
{
    printf("helloworld! %d \n",num);
}
int main()
{
    signal(2,print);
    while(1);
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void print()
{
    alarm(1);
    printf("helloworld\n");
}
int main()
{
    alarm(1);
    signal(SIGALRM,print);
    while(1);
    return 0;
}

 

3、消息队列。

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#define MSGKEY  1234
struct msgbuf
{
    long mtype;
    char mtext[64];
};
int main()
{
    int ret;
    struct msgbuf mbuf;
    int msgid = msgget(MSGKEY, IPC_CREAT | IPC_EXCL);
    if(-1 == msgid)
    {
        perror("msgget");
        exit(1);
    }
    pid_t pid = fork();
    if(-1 == pid)
    {
        perror("fork");
        exit(1);
    }
    else if(0 == pid)
    {
        while(1)
        {
            memset(&mbuf,0, sizeof(mbuf));
            mbuf.mtype = 1;
            scanf("%s",mbuf.mtext);

            ret = msgsnd(msgid,&mbuf,sizeof(mbuf.mtext),0);
            if(-1 == ret)
            {
                perror("msgsnd");
                exit(1);
            }
            if(!strcmp(mbuf.mtext,"bye"))
            {
                mbuf.mtype = 2;
                msgsnd(msgid,&mbuf,sizeof(mbuf.mtext),0);
                break;
            }
        }
    }
    else
    {
        while(1)
        {
            memset(&mbuf,0,sizeof(mbuf));
            ret = msgrcv(msgid,&mbuf,sizeof(mbuf.mtext),2,0);
            if(-1 == ret)
            {
                perror("msgrcv");
                exit(1);
            }
            if(!strcmp(mbuf.mtext,"bye"))
            {
                kill(pid,2);
                break;
            }
            printf("\t\t\t\t%s\n",mbuf.mtext);
        }
    }
    sleep(1);
    msgctl(msgid,IPC_RMID,NULL);


return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#define MSGKEY  1234
struct msgbuf
{
    long mtype;
    char mtext[64];
};
int main()
{
    int ret;
    struct msgbuf mbuf;
    int msgid = msgget(MSGKEY,0);
    if(-1 == msgid)
    {
        perror("msgget");
        exit(1);
    }
    pid_t pid = fork();
    if(-1 == pid)
    {
        perror("fork");
        exit(1);
    }
    else if(0 == pid)
    {
        while(1)
        {
            memset(&mbuf,0, sizeof(mbuf));
            mbuf.mtype = 2;
            scanf("%s",mbuf.mtext);

            ret = msgsnd(msgid,&mbuf,sizeof(mbuf.mtext),0);
            if(-1 == ret)
            {
                perror("msgsnd");
                exit(1);
            }
            if(!strcmp(mbuf.mtext,"bye"))
            {
                mbuf.mtype = 1;
                msgsnd(msgid,&mbuf,sizeof(mbuf.mtext),0);
                break;
            }
        }
    }
    else
    {
        while(1)
        {
            memset(&mbuf,0,sizeof(mbuf));
            ret = msgrcv(msgid,&mbuf,sizeof(mbuf.mtext),1,0);
            if(-1 == ret)
            {
                perror("msgrcv");
                exit(1);
            }
            if(!strcmp(mbuf.mtext,"bye"))
            {
                kill(pid,2);
                break;
            }
            printf("\t\t\t\t%s\n",mbuf.mtext);
        }
    }
    sleep(1);
    msgctl(msgid,IPC_RMID,NULL);
    
   return 0;
}

 

 

4、共享内存。

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

#define SHMKEY    1234
#define SHMSIZE   4096
#define SEMKEY    1234


union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux specific) */
};


void sem_p(int semid)
{
    int ret;
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = 1;
    sbuf.sem_flg = SEM_UNDO;
    ret = semop(semid,&sbuf,1);
    if(-1 == ret)
    {
        perror("semop");
        return;
    }
}


void sem_v(int semid)
{
    int ret;
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = -1;
    sbuf.sem_flg = SEM_UNDO;
    ret = semop(semid,&sbuf,1);
    if(-1 == ret)
    {
        perror("semop");
        return;
    }
}
int main()
{
    int shmid;
    int semid,ret;
    int count = 0;
    void *shmaddr;
    shmid = shmget(SHMKEY,SHMSIZE,IPC_CREAT | IPC_EXCL);
    if(-1 == shmid)
    {
        perror("shmget");
        exit(1);
    }
    semid = semget(SEMKEY, 1 ,IPC_CREAT | IPC_EXCL);
    if(-1 == semid)
    {
        perror("semget");
        exit(1);
    }
    union semun unsem;
    unsem.val = 1;
    ret = semctl(semid, 0, SETVAL,unsem);
    if(-1 == ret)
    {
        perror("semctl");
        exit(1);
    }
    shmaddr = shmat(shmid,NULL,0);           //映射到虚拟地址
    if(NULL == shmaddr)
    {
        perror("shmat");
        exit(1);
    }
    *(int *)shmaddr = count;                //数据写到共享内存
    while(1)
    {
        sem_p(semid);
        count = *(int *)shmaddr;           //读取数据
        usleep(100000);
        if(count >= 100)
        {
            break;
        }
        printf("Process A : count = %d\n",count);
        count++;
        *(int *)shmaddr = count;
        sem_v(semid);
    }
    shmdt(shmaddr); 
    shmctl(shmid,IPC_RMID,NULL);
    semctl(semid, 0, IPC_RMID);
    return 0;
}

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

#define SHMKEY    1234
#define SHMSIZE   4096
#define SEMKEY    1234

union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux specific) */
};


void sem_p(int semid)
{
    int ret;
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = -1;
    sbuf.sem_flg = SEM_UNDO;
    ret = semop(semid,&sbuf,1);
    if(-1 == ret)
    {
        perror("semop");
        return;
    }
}


void sem_v(int semid)
{
    int ret;
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = 1;
    sbuf.sem_flg = SEM_UNDO;
    ret = semop(semid,&sbuf,1);
    if(-1 == ret)
    {
        perror("semop");
        return;
    }
}
int main()
{
    int shmid;
    int semid,ret;
    int count = 0;
    void *shmaddr;
    shmid = shmget(SHMKEY,SHMSIZE,0);
    if(-1 == shmid)
    {
        perror("shmget");
        exit(1);
    }
    semid = semget(SEMKEY ,1, 0);
    if(-1 == semid)
    {
        perror("semget");
        exit(1);
    }

    shmaddr = shmat(shmid,NULL,0);           //映射到虚拟地址
    if(NULL == shmaddr)
    {
        perror("shmat");
        exit(1);
    }
    while(1)
    {
        sem_p(semid);
        count = *(int *)shmaddr;           //读取数据
        usleep(100000);
        if(count >= 100)
        {
            break;
        }
        printf("Process B : count = %d\n",count);
        count++;
        *(int *)shmaddr = count;
        sem_v(semid);
    }
    shmdt(shmaddr); 
    return 0;
}

 

 

 

Jury吖
关注
Linux--进程间通信之消息队列
我的博客
06-20 675
什么是消息队列 1.消息队列，是消息的链接表，存放在内核中。 2.一个消息队列由一个标识符（即队列ID）来标识。 3.因为消息队列其实就是一个链表，所以往消息队列里面发送数据就等价于向链表里面插入一个消息结点，从消息队列里面取数据就等价于访问该结点，访问完后再删除这个结点。 消息队列的特点 1.消息队列可用于任意两个进程进行进程间通信（只要这两个进程能够看到同一个消息队列就可以）； 2...
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
《TCP/IP详解：实现》: mbuf 详解一
yexiangCSDN的专栏
03-12 5999
一、mbuf 介绍 在BSD TCP/IP协议栈代码设计中的一个基本概念就是存储器缓存，称作一个mbuf，全称为"memory buffer"，用于存储各种信息。mbuf的主要用途是保存在进程和网络接口间互相传递的用户数据。但mbuf也用于保存其他各种数据：源与目标地址、插口选项等等。mbuf相当于Linux内核中的skb。 mbuf的相关定义在文件/4.4BSD-Lite/usr/src/...
线程通信
ZCzhouchao1的博客
08-20 245
线程概念 线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。一个进程由几个线程组 （拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。 进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线...
pipe
weixin_34417635的博客
01-14 215
管道在unix类系统中是一个很重要的概念，文件的重定向就是使用管道来实现的，在shell中也提供了"|"来直接使用管道，那么在C中，如何使用管道呢？管道在unix中是通过pipe函数来实现的。头文件：　#include &lt;unistd.h&gt;函数定义：int pipe(int filedes[2]);函数说明：函数返回文件描述符，其中filedes[0]为管道的写入端，filedes[1...
pipe fifo
yishizhu的专栏
06-08 174
#include #include #include #include int main(){ int pipe_fd[2]; if(pipe(pipe_fd) < 0){ printf("pipe create error\n"); return -1; }else{ printf("pipe cr...
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
UNIX Linux实验教程 4实验四Linux进程间通信.doc
09-26
UNIX/Linux 进程间通信实验教程 UNIX/Linux 操作系统提供了一组系统调用作为用户使用其进程间通信机制的接口。进程间通信是指在多任务计算机系统中，每个进程都具有自己独立的全局变量和局部变量，子进程几乎完全...
ipcs命令 多进程间通信常用的工具
01-09
ipcs命令是用于报告Linux中进程间通信设施的状态，显示的信息包括消息列表、共享内存和信号量的信息 。 语法格式：ipcs [参数] 常用参数： -a 默认的输出信息 -m 打印出使用共享内存进行进程间通信的信息 -q ...
linux编程之pipe()函数
weixin_30706691的博客
03-18 577
管道是一种把两个进程之间的标准输入和标准输出连接起来的机制，从而提供一种让多个进程间通信的方法，当进程创建管道时，每次 都需要提供两个文件描述符来操作管道。其中一个对管道进行写操作，另一个对管道进行读操作。对管道的读写与一般的IO系统函数一 致，使用write()函数写入数据，使用read()读出数据。 #include<unistd.h> int pipe(int fil...
TCP/IP网络编程(9) 进程间通信
开到荼蘼的博客
08-18 909
但是，进程具有完全独立的内存结构，即使通过fork()函数创建的子进程，也不会与父进程共享内存，因此进程间通信需要通过其他的特殊方法完成。为完成进程之间的通信，需要创建管道，管道不属于进程的资源(即不是fork复制的对象)，而是和套接字一样，属于操作系统资源，因此通过管道首实现IPC的原理是，两个进程通过操作系统提供的内存进行通信。通过创建两个管道，各自在进程间负责不同的数据流，即可方便的实现进程间双向通信，采用两个管道即可避免程序运行流程的预测或控制。方案1：通过一个管道实现两个进程间的双向通信。...
linux无名管道实验代码,Linux 进程间通讯之创建无名管道和读写无名管道
weixin_31856057的博客
05-12 573
Linux进程间通讯的方式：1. 管道(pipe)和有名管道(FIFO).2. 信号(signal)3. 消息队列4. 共享内存5. 信号量6. 套接字(socket)管道通讯：无名管道：由pipe()函数创建，int pipe(int filedis[2]), 当管道建立时有两个文件描述符，filedis[0]用于读管道，filedis[1]用于写管道。关闭管道，仅需将两个文件描述符关闭即可。...
基于微信小程序的社区垃圾回收管理-基于微信小程序的社区垃圾回收管理系统-基于微信小程序的社区垃圾回收管理系统源码-基于微信小程序的社区垃圾回收管理管理系统-基于微信小程序的社区垃圾回收管理管理系统ja
最新发布
09-03
基于微信小程序的社区垃圾回收管理-基于微信小程序的社区垃圾回收管理系统-基于微信小程序的社区垃圾回收管理系统源码-基于微信小程序的社区垃圾回收管理管理系统-基于微信小程序的社区垃圾回收管理管理系统java代码-基于微信小程序的社区垃圾回收管理系统设计与实现-基于ssm的基于微信小程序的社区垃圾回收管理系统-基于Web的基于微信小程序的社区垃圾回收管理系统设计与实现-基于微信小程序的社区垃圾回收管理网站-基于微信小程序的社区垃圾回收管理网站代码-基于微信小程序的社区垃圾回收管理平台-基于微信小程序的社区垃圾回收管理平台代码-基于微信小程序的社区垃圾回收管理项目-基于微信小程序的社区垃圾回收管理项目代码-基于微信小程序的社区垃圾回收管理代码
VMD-MFRFNN_VMD-MFRFNN.zip
09-03
VMD-MFRFNN_VMD-MFRFNN.zip
无人船航行路径规划算法综述.docx
09-03
无人船航行路径规划算法综述.docx
用于物理知情动态模式分解（piDMD）的MATLAB代码_MATLAB codes for physics-inform
09-03
用于物理知情动态模式分解（piDMD）的MATLAB代码_MATLAB codes for physics-informed dynamic mode decomposition (piDMD).zip
生成式人工智能在智能治理中的风险识别与防控策略研究.docx
09-03
生成式人工智能在智能治理中的风险识别与防控策略研究.docx
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值