Linux系统编程_进程间通信(IPC)

最新推荐文章于 2024-08-01 16:15:20 发布
最新推荐文章于 2024-08-01 16:15:20 发布
阅读量437 收藏 1
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LXiangRegisterd/article/details/80624540
版权
  • 进程间通信即完成两个进程间数据的传递。需要借助操作系统提供特殊的方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。比如其中的文件，之所以能通过文件进行IPC，是因为每个文件的文件描述符指向的文件结构体在内核中。注意，用不同进程打开同一文件得到的文件描述符不同。
  • 现今常用的进程间通信方式有：
    ① 管道 (使用最简单)
    ② 信号 (开销最小)
    ③ 共享映射区 (无血缘关系)
    ④ 本地套接字 (最稳定)

文件

利用文件进行进程间通信的程序示例：

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

int main() {
        pid_t pid;
        int fd1, fd2;
        char buf[1024];
        char* str = "------test for shared fd in parent child process---\n";

        pid = fork();
        if(pid == -1) {
                perror("fork error");
                exit(1);
        }
        if(pid == 0) {
                fd1 = open("test.txt", O_RDWR | O_CREAT, 0644);
                if(fd1 < 0) {
                        perror("open error");
                        exit(1);
                }
                write(fd1, str, strlen(str));
                printf("child wrote over\n");
        }
        if(pid > 0) {
                fd2 = open("test.txt", O_RDWR | O_CREAT, 0644);
                if(fd2 < 0) {
                        perror("open error");
                        exit(1);
                }
                sleep(1);

                int ret = read(fd2, buf, sizeof(buf));
                write(STDOUT_FILENO, buf, ret);

                wait(NULL);
        }

        return 0;
}

管道（pipe）

  • pipe函数
  • 管道一般读写行为
    程序示例：利用管道实现ls | wc -l命令
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

void sys_err(char* str) {
        perror(str);
        exit(-1);
}

int main() {
        int fd[2];
        pid_t pid;

        int ret = pipe(fd);
        if(ret == -1) 
                sys_err("pipe error");
        pid = fork();
        if(pid == -1) 
                sys_err("fork error");
        if(pid == 0) {
                close(fd[0]);
                dup2(fd[1], STDOUT_FILENO);
                execlp("ls", "ls", NULL);
                sys_err("execlp ls error");
        } else if(pid > 0) {
                close(fd[1]);
                dup2(fd[0], STDIN_FILENO);
                execlp("wc", "wc", "-l", NULL);
                sys_err("execlp wc -l error");
        }

        return 0;
}

FIFO（命名管道）

  • 用于非血缘关系IPC
//fifo_w.c
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

void sys_err(char *str)
{
    perror(str);
    exit(-1);
}

int main(int argc, char *argv[])
{
    int fd; 
    char buf[4096];

    if (argc < 2) {
        printf("Enter like this: ./a.out fifoname\n");
        return -1; 
    }   

    int ret = access(argv[1], F_OK);
    if (ret != 0) {
        mkfifo(argv[1], 0664);
    }

    fd = open(argv[1], O_WRONLY);
    if (fd < 0)
        sys_err("open");

    while (1) {
        fgets(buf, sizeof(buf), stdin);
        write(fd, buf, strlen(buf));
    }
    close(fd);

    return 0;
}
//fifo_r.c
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

void sys_err(char *str)
{
    perror(str);
    exit(1);
}
int main(int argc, char *argv[])
{
    int fd, len;
    char buf[4096];

    if (argc < 2) {
        printf("./a.out fifoname\n");
        return -1; 
    }   
    fd = open(argv[1], O_RDONLY);
    if (fd < 0)  
        sys_err("open");
    while (1) {
        len =read(fd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, len);
    }
    close(fd);

    return 0;
}

共享存储映射

  • mmap函数
    1）参数
    2）返回值

  • 借助共享内存存放磁盘文件

  • 父子进程、血缘关系进程间的通信

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

int var = 0;

int main() {
        int fd;
        int* p;
        pid_t pid;

        fd = open("temp.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
        if(fd < 0) {
                perror("open error");
                exit(1);
        }
        unlink("temp.txt");
        ftruncate(fd, 4);
        p = mmap(NULL, 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        //p = mmap(NULL, 4, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
        if(p == MAP_FAILED) {
                perror("mmap error");
                exit(1);
        }
        close(fd);

        pid = fork();
        if(pid == 0) {
                *p = 100;
                var = 100;
                printf("child: *p = %d, var = %d\n", *p, var);
        } else if(pid > 0) {
                sleep(1);
                printf("parent: *p = %d, var = %d\n", *p, var);
                wait(NULL);

                int ret = munmap(p, 4);
                if(ret == -1) {
                        perror("munmap error");
                        exit(1);
                }
        }

        return 0;
}
  • 匿名映射区
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>

int var = 0;

int main() {
        int* p;
        pid_t pid;
        //int fd = open("/dev/zero", O_RDWR);//类unix操作系统下的通行匿名映射方法
        //p = mmap(NULL, 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 
        p = mmap(NULL, 4, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); 
        if(p == MAP_FAILED) {
                perror("mmap error");
                exit(1);
        }

        pid = fork();
        if(pid == 0) {
                *p = 100;
                var = 100;
                printf("child: *p = %d, var = %d\n", *p, var);
        } else if(pid > 0) {
                sleep(1);
                printf("parent: *p = %d, var = %d\n", *p, var);
                wait(NULL);

                int ret = munmap(p, 4);
                if(ret == -1) {
                        perror("munmap error");
                        exit(1);
                }
        }

        return 0;
}
  • 非血缘关系进程间通信：
    mmap借助一个文件在内核区创建了一个映射区，多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享，因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可（MAP_SHARED）。关键点是各个进程在创建映射区时必须打开的是同一个文件。
//mmap_nonpc_write.c
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <stdlib.h>

struct STD {
        char name[20];
        int age;
        char sex;
};

void sys_err(const char* str) {
        perror(str);
        exit(-1);
}

int main(int argc, char** argv) {
        int fd;
        struct STD m_std = {"xl", 10, 'm'};

        struct STD* mm;

        if(argc < 2) {
                printf("input error\n");
                exit(-1);
        }

        fd = open(argv[1], O_RDWR | O_CREAT, 0644);
        if(fd < 0) {
                sys_err("open error");
        }
        int ret = ftruncate(fd, sizeof(struct STD));
        if(ret < 0)
                sys_err("ftruncate error");
        mm = mmap(NULL, sizeof(struct STD), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if(mm == MAP_FAILED)
                sys_err("mmap error");

        close(fd);

        while(1) {
                memcpy(mm, &m_std, sizeof(struct STD));
                m_std.age++;
                sleep(1);
        }

        munmap(mm, sizeof(struct STD));

        return 0;
}
//mmap_nonpc_read.c
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <stdlib.h>

struct STD {
        char name[20];
        int age;
        char sex;
};

void sys_err(const char* str) {
        perror(str);
        exit(-1);
}

int main(int argc, char** argv) {
        int fd;
        struct STD m_std;
        struct STD* mm;

        if(argc < 2) {
                printf("a.out file_shared\n");
                exit(-1);
        }

        fd = open(argv[1], O_RDONLY);
        if(fd < 0) {
                sys_err("open error");
        }
        mm = mmap(NULL, sizeof(struct STD), PROT_READ, MAP_SHARED, fd, 0);
        if(mm == MAP_FAILED)
                sys_err("mmap error");

        close(fd);

        while(1) {
                printf("name = %s, age = %d, sex = %c\n", mm->name, mm->age, mm->sex);
                sleep(1);
        }

        munmap(mm, sizeof(struct STD));

        return 0;
}

并且，由于open、write、read函数的底层实现是借助mmap函数，因此非血缘关系进程间通信也可以借助文件的方式。

//file_mmap_w.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

void sys_err(char *str) {
        perror(str);
        exit(-1);
}

#define N 5

int main() {
        int ret;
        char buf[1024];
        char* str = "-------write into file:file_mmap.txt\n";
        int fd = open("file_mmap.txt", O_RDWR |O_TRUNC | O_CREAT, 0644);
        if(fd < 0)  
                sys_err("open error");

        write(fd, str, strlen(str));
        printf("write into file:file_mmap.txt finished\n");

        sleep(N);

        lseek(fd, 0, SEEK_SET); //把读写指针位置移至起始

        ret = read(fd, buf, sizeof(buf));
        ret = write(STDOUT_FILENO, buf, ret);
        if(ret < 0) {
                perror("write second error");
                exit(1);
        }

        close(fd);

        return 0;
}
//file_mmap_r.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

void sys_err(char *str) {
        perror(str);
        exit(-1);
}

int main() {
        char buf[1024];
        char* str = "read and write into file: file_mmap.txt\n";

        int fd = open("file_mmap.txt", O_RDWR);
        if(fd < 0)  
                sys_err("open error");

        int ret = read(fd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, ret);

        write(fd, str, strlen(str));
        printf("read and write finished\n");

        close(fd);

        return 0;
}

本地套接字（domain socket）

  • 虽然网络socket也可用于同一台主机的进程间通讯（通过 loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。
  • UNIX Domain Socket是全双工的，API接口语义丰富，相比其它IPC机制有明显的优越性，目前已成为使用最广泛的IPC机制。
  • UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同，用结构体sockaddr_un表示，网络编程的socket地址是IP地址加端口号，而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。
LXiangRegistered
关注
专栏目录
Linux 系统应用编程——进程间通信（下）
知秋一叶
01-11 3284
在前面，我们学习了传统的进程间通信方式——无名管道（pipe）、有名管道（fifo）和信号（signal）。         下面我们来学习 System V  IPC 对象： 1、共享内存（share memory）； 2、信号灯（semaohore）； 3、消息队列（message queue）；          IPC对象是活动在内核级别的一种进程间通信的工具。存在的IPC对象
Linux进程间通信IPC的几种方式简介
Sunshine的专栏
05-27 7351
Linux进程通信的源头       linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。而对Unix发展做出重大贡献的两大主力AT&T（原为American Telephone & Telegraph的缩写，也是中文译名美国电话电报公司由来）的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间通信方面的侧重点有所不同。前者对Unix早期的进程间通信手段
Linux系统编程——进程间通信概述
热门推荐
秋叶原 && Mike || 麦克
05-26 1万+
进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源（例如打开的文件描述符）。 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信( IPC：Inter Processes Communication )。
Linux IPC解析：匿名命名管道与共享内存
最新发布
喜欢就坚持吧
08-01 1093
进程间通信）是计算机系统中不同进程之间交换数据和同步操作的机制。由于现代计算机系统中，程序通常会由多个进程组成，这些进程可能需要相互通信以完成任务，因此IPC非常重要。数据交换：允许不同进程共享数据或传递信息。同步：协调多个进程之间的操作，以避免竞态条件和资源冲突。互斥：控制多个进程对共享资源的访问，确保同一时间只有一个进程能够访问资源管道（Pipes）：匿名管道：用于相关进程之间的单向通信，如父子进程或兄弟进程。
Linux系统编程——进程间通信（IPC）
qq_42102650的博客
06-01 268
一. 概述 1.1单机通信 半双工管道 （FIFO） 全双工管道 （命名全双工管道） 消息队列 信号量 共享存储 1.2多机通信： 套接字 STREAMS 二.管道通信 管道，通常指无名管道，最古老的IPC形式 2.1特点 半双工（数据只能在同一方向流动），有固定的读端和写端。管道中的数据，读走就没了 只用于具有亲缘关系的进程之间通信 可看成一种特殊的文件，但只存在于内存中 2.2原型 #include <unistd.h> int pipe(int fd[2]); //成功返
linux系统编程之进程间通信(IPC)（一）
fengllin的博客
07-06 283
由于个人理解局限性和笔误，以下内容难免有误，忘谅解。欢迎指正。 进程间通讯大致可以分为以下4类： 管道(pipe) 信号(signal) 共享内存 套接字(socket) 一、管道（pipe） pipe又称匿名管道。 1.特点： 双向全双工。同一时刻管道的只能在一端进行读操作，一端进行写操作。 只能在有血缘关系的的进程之间通讯。 管道属于伪文件。 Linux系统文件类型有7种...
ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc
09-23
本文将深入探讨标题“ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc”所涉及的知识点，包括Linux下的管道（pipe）、进程以及进程间通信的基本概念、工作原理和应用实例。 首先，让我们理解什么是进程。在Linux...
ipc.rar_ ipc_IPC_linux ipc_pipes_进程间通信ipc
09-23
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间进行数据交换的重要机制。本文将深入探讨几种常见的Linux IPC机制，包括管道（Pipes）、命名管道（Named Pipes, FIFOs）、信号...
ipc.rar_IPC_IPC Linux_ipc 进程通信_linux ipc_linux 多进程
09-19
在Linux操作系统中，IPC（Inter-Process Communication，进程间通信）是多个进程间进行数据交换和协调工作的重要机制。这个名为“ipc.rar”的压缩包包含了关于IPC在Linux环境下的实践案例，主要使用C语言实现。下面...
《Linux系统编程、网络编程》第7章 进程间通信（本机IPC）
06-12
本文将深入探讨“《Linux系统编程、网络编程》第7章 进程间通信（本机IPC）”所涵盖的知识点，帮助读者理解和掌握进程间通信（IPC）的基本原理和实现方式。 首先，我们要理解为什么需要进程通信。在多任务操作系统...
Linux进程间通信测试程序.zip_linux_linux 程序_linux 网络_linux网络_进程间通信
09-24
在Linux操作系统中，进程间通信（Inter-Process Communication, IPC）是实现多个进程协同工作、交换数据的关键技术。本测试程序旨在帮助用户理解和实践Linux下的各种进程间通信机制。通过提供的详细注释，用户可以...
linux----进程间通信
我思故我在-笛卡尔
11-25 317
IPC方法 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。   在进程间
Linux系统编程之进程间通信（IPC）
Mount姚的博客
07-22 340
进程间的通信方式IPC
Linux C编程--进程间通信（IPC）5--System V IPC 机制3--共享内存
张勤一
03-05 2959
共享内存 最为高效的进程间通信方式   进程直接读写内存，不需要任何数据的拷贝 　　•为了在多个进程间交换信息，内核专门留出了一块内存区 　　•由需要访问的进程将其映射到自己私有地址空间 　　•进程直接读写这一内存区而不需要进行数据的拷贝，提高了效率   多个进程共享一段内存，需要依靠某种同步机制，如互斥锁和信号量等   l共享内存编程步骤： 　　1.
Linux ipc 编程以及线程同步
坚持自我
11-28 314
摘要：本文主要介绍管道，ystemv ipc机制，包括消息队列、信号量，共享内存。套接字也是进程间通信的一种机制。只是前面的机制都是在一台主机上的进程间通信。共享内存shmget shmat shmdt shmctl消息队列msgget msgctl msgsnd msgrcv信号量semget semctl semop
Linux进程与线程之 进程间通信IPC
编程一时爽爽一时
05-04 313
进程间通信：管道,FIFO,消息队列， 信号量， 共享内存 管道 管道， 通常指无名管道， 是 UNIX 系统 IPC 最古老的形式 ①特点1. 半双工（即数据只能在一个方向上流动） ， 具有固定的写端和读端 2. 它只能用于具有亲缘关系的进程之间的（父子进程或兄弟进程之间） 3. 万物皆文件， 可以被看成是一种特殊的文件， 可以使用普通的读些 write,read 等函数。 但它不是普通文件， 并不属于其他文件系统， 只存于内存中。 ②原型 4. #include <unistd.h> 5.
linux编程之ipc
程序员的专栏
11-11 389
ipc：进程间通信。 消息队列  消息队列的访问具备锁机制处理,即一个进程在访问时另一个进程不能访问.”
linux系统编程：进程间通信-pipe
CCPP Blog
07-15 1479
进程间通信-pipe 进程间通信 每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。 pipe 管道（pipe）就是一项基本的进程间通信的方法。
Linux系统编程之多任务编程(IPC - 管道)
s669988的博客
11-30 508
多任务并发（2）IPC - 管道 进程间通信方式 一、管道   1、无名管道 pipe：适用于亲缘关系进程间的、一对一的通信 特点：   （1）管道文件：这个文件很特殊，其实就是一块内存，不能使用open打开，也不可以使用lseek，可以使用read write读写。   （2）半双工：同一时刻只能单方向传输数据   （3）大小为 64K   （4）关闭读端，能够正常写入数据 ，如果缓冲区已满，那...
Linux系统编程：进程间通信之管道详解
"Linux系统编程中的进程间通信是一个重要的主题，特别是管道(Pipe)作为一种常见的通信机制，被广泛用于父子进程或兄弟进程之间的数据传递。管道是半双工的，即数据只能单向流动，需要双向通信时需要两个独立的管道。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值