进程间的通信方式

已于 2023-09-23 15:45:42 修改
阅读量395 收藏
点赞数 1
分类专栏： linux 文章标签： linux
于 2023-09-19 09:19:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/midslucky/article/details/133012548
版权

文章目录

1.简单介绍

在计算机中，进程间通信（Inter-Process Communication，IPC）是指两个或多个进程之间交换数据或信息的机制。

首先我们通过之前的学习知道进程是具有独立性的，其交互数据成本非常高，所以通信这一机制就诞生了。

通信的本质其实就是由os参与，提供一份所有通信进程能看到的公共资源。

进程间通信的方式非常多以下是对这些方式的梳理以及分类：

进程间通信分类

​ 管道

  • 匿名管道pipe

  • 命名管道

    System V IPC

  • System V 消息队列

  • System V 共享内存

  • System V 信号量

    POSIX IPC

  • 消息队列

  • 共享内存

  • 信号量

  • 互斥量

  • 条件变量

  • 读写锁

2.管道

2.1管道的基础概念

管道是Unix中最古老的进程间通信的形式。

我们把从一个进程连接到另一个进程的一个数据流称为一个管道

在这里插入图片描述

管道读写规则:

当没有数据可读时

  • O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
  • O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

当管道满的时候

  • O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
  • O_NONBLOCK enable：调用返回-1，errno值为EAGAIN

如果所有管道写端对应的文件描述符被关闭，则read返回0

如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程

退出

当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。

当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

管道特点

  • 管道提供流式服务

  • 一般而言，进程退出，匿名管道释放，所以匿名管道的生命周期随进程

  • 一般而言，内核会对管道操作进行同步与互斥

  • 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道

在这里插入图片描述

2.2匿名管道
#include <unistd.h>
功能:创建一无名管道,管道是一种特殊的文件，它具有两个端点，一个用于写入数据，另一个用于读取数据。
原型
int pipe(int fd[2]);
参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
    是一个包含两个整数的数组，用于接收管道的两个文件描述符
返回值:成功返回0，失败返回-1
匿名管道父子进程间通信的经典案例：
使用例子：从键盘读取数据，写入管道，读取管道，写到屏幕
    
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>

int main()
{
    int pipe_fd[2] = {0};

    if(pipe(pipe_fd) < 0){
        perror("pipe");
        return 1;
    }
    printf("%d, %d\n", pipe_fd[0], pipe_fd[1]);

    pid_t id = fork();
    if(id < 0){
        perror("fork");
        return 2;
    }
    else if(id == 0) { //write
        //child
        close(pipe_fd[0]);

        //const char *msg = "hello parent, I am child";

        char c = 'x';
        int count = 0;
        //while(count){
        while(1){
            write(pipe_fd[1], &c, 1); //strlen(msg) + 1??
         //   sleep(1);
            count++;
            printf("write: %d\n", count);
        }

        close(pipe_fd[1]);
        exit(0);
    }
    else{              //read
        //parent
        close(pipe_fd[1]);

        char buffer[64];
        while(1){
            sleep(100);
            buffer[0] = 0;
            ssize_t size = read(pipe_fd[0], buffer, sizeof(buffer)-1);
            if(size > 0){
                buffer[size] = 0;
                printf("parent get messge from child# %s\n", buffer);
            }
            else if(size == 0){
                printf("pipe file close, child quit!\n");
                break;
            }
            else{
                //TODO
                break;
            }
        }

        int status = 0;
        if(waitpid(id, &status,0) > 0){
            printf("child quit, wait success!, sig: %d\n", status&0x7F);
        }
        close(pipe_fd[0]);
    }
    return 0;
}

对上端代码用fork来共享管道的原理

在这里插入图片描述

2.3命名管道
基本概念:

匿名管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。

如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。

命名管道是一种特殊类型的文件

命名管道的创建：
//命名管道可以从命令行上创建，命令行方法是使用下面这个命令：
$ mkfifo filename
//命名管道也可以从程序里创建，相关函数有：
    int mkfifo(const char *filename,mode_t mode);
//filename：一个指向要创建的命名管道的路径和名称的字符串。它是一个以 null 结尾的字符数组。

//mode：用于指定创建的命名管道的权限（访问权限和文件类型）。mode 是一个 mode_t 类型的参数，通常使用八进制表示的权限值。可以使用一些预定义的常量（如 S_IRUSR、S_IWUSR、S_IRGRP 等）来设置权限。

//创建命名管道
int main(int argc, char *argv[])
{
 mkfifo("p2", 0644);
 return 0;
}
命名管道的打开规则：

如果当前打开操作是为读而打开FIFO时

O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO

O_NONBLOCK enable：立刻返回成功

如果当前打开操作是为写而打开FIFO时

O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO

O_NONBLOCK enable：立刻返回失败，错误码为ENXIO

匿名管道与普通管道的区别

匿名管道由pipe函数创建并打开(使用了pipe函数默认该描述符对应的文件打开了)。

命名管道由mkfififo函数创建，打开用open

FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完

成之后，它们具有相同的语义。

tips:

通过 mkfifo 函数创建的命名管道在文件系统中持久存在，与创建它的进程无关。

使用 pipe 函数创建的管道是进程特有的，与创建它的进程相关联。当创建管道的进程结束时，管道会被自动关闭和销毁。而mkfifo函数所创建的管道是不会随着进程结束而销毁的，我们需要手动销毁。

//销毁命名管道所使用的函数

int unlink(const char *pathname);
pathname 是一个指向要删除的文件的路径和名称的字符串。它是一个以 null 结尾的字符数组。
    
//unlink 函数执行以下操作：

1.首先，它会检查指定路径的文件是否存在。如果文件不存在，unlink 函数会返回一个错误码，并不执行任何其他操作。

2.如果文件存在，并且调用进程对该文件具有足够的权限，unlink 函数将从文件系统中删除该文件。删除文件会将文件从目录中删除，并释放文件所占用的磁盘空间。

3.注意，删除文件并不会关闭已打开的文件描述符。如果有进程仍然持有对该文件的打开描述符，文件将继续存在于文件系统中，直到所有打开的描述符关闭。

4.当调用进程成功删除文件时，unlink 函数返回 0。如果出现错误，比如权限不足或指定的文件路径无效，unlink 函数返回 -1，并设置相应的错误码，可以通过 errno 全局变量获取错误信息。

    //删除命名管道文件并不会自动关闭已打开的管道文件描述符。在删除命名管道文件之前，需要确保所有打开的文件描述符都已关闭，以免导致资源泄漏或其他问题。
例子：用命名管道实现server&client通信

例子中使用的一些函数的解析:

1.
    mode_t umask(mode_t mask);
umask 函数接受一个参数 mask，它是一个无符号整数类型 mode_t 的值，表示要设置的权限掩码。mode_t 是一个用于表示文件权限和文件类型的数据类型。

2.
    key_t ftok(const char *pathname, int proj_id);
    用于生成一个唯一的键值（key）用于标识一个共享资源，例如共享内存、信号量或消息队列。
    pathname：一个存在的文件路径名，可以是任意合法的文件路径。
    proj_id：一个用户定义的整数，用于区分不同的共享资源。通常取值为一个非负整数。  
    生成的键值可以用于创建或访问共享资源，例如在调用 shmget 函数创建共享内存时使用。
 3.
    int shmdt(const void *shmaddr);      
    shmdt 函数用于将共享内存从当前进程的地址空间中分离，即解除共享内存的挂载。
    shmdt 函数并不会删除共享内存段，只是将其与当前进程分离。
    在调用 shmdt 函数之后，当前进程将无法再直接访问共享内存中的数据。如果需要重新访问共享内存，必须使用 shmat 函数重新将共享内存段挂载到当前进程的地址空间。

Log.hpp(一个简单的日志记录功能的实现)
    
#ifndef _LOG_H_
#define _LOG_H_

#include <iostream>
#include <ctime>

#define Debug   0
#define Notice  1
#define Warning 2
#define Error   3


const std::string msg[] = {
    "Debug",
    "Notice",
    "Warning",
    "Error"
};

std::ostream &Log(std::string message, int level)
{
    std::cout << " | " << (unsigned)time(nullptr) << " | " << msg[level] << " | " << message;
    return std::cout;
}


#endif   

Makefile
    
.PHONY:all
all:shmClient shmServer

shmClient:shmClient.cc
	g++ -o $@ $^ -std=c++11
shmServer:shmServer.cc
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -f shmClient shmServer

comm.hpp

#pragma once

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <cassert>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "Log.hpp"

using namespace std; //不推荐

#define PATH_NAME "/home/whb"
#define PROJ_ID 0x66
#define SHM_SIZE 4096 //共享内存的大小，最好是页(PAGE: 4096)的整数倍

#define FIFO_NAME "./fifo"

class Init
{
public:
    Init()
    {
        umask(0);//表示没有遮掩任何权限
        int n = mkfifo(FIFO_NAME, 0666);
        assert(n == 0);
        (void)n;
        Log("create fifo success",Notice) << "\n";
    }
    ~Init()
    {
        unlink(FIFO_NAME);
        Log("remove fifo success",Notice) << "\n";
    }
};

#define READ O_RDONLY
#define WRITE O_WRONLY

int OpenFIFO(std::string pathname, int flags)
{
    int fd = open(pathname.c_str(), flags);
    assert(fd >= 0);
    return fd;
}

void Wait(int fd)
{
    Log("等待中....", Notice) << "\n";
    uint32_t temp = 0;//为了确保读取的值可以正确地存储和比较
    ssize_t s = read(fd, &temp, sizeof(uint32_t));
    assert(s == sizeof(uint32_t));
    (void)s;
}

void Signal(int fd)
{
    uint32_t temp = 1;   //为了确保读取的值可以正确地存储和比较
    ssize_t s = write(fd, &temp, sizeof(uint32_t));
    assert(s == sizeof(uint32_t));
    (void)s;
    Log("唤醒中....", Notice) << "\n";
}

void CloseFifo(int fd)
{
    close(fd);
}

shmClient.cc

#include "comm.hpp"

int main()
{
    Log("child pid is : ", Debug) << getpid() << endl;
    key_t k = ftok(PATH_NAME, PROJ_ID);
    if (k < 0)
    {
        Log("create key failed", Error) << " client key : " << k << endl;
        exit(1);
    }
    Log("create key done", Debug) << " client key : " << k << endl;

    // 获取共享内存
    int shmid = shmget(k, SHM_SIZE, 0);
    if(shmid < 0)
    {
        Log("create shm failed", Error) << " client key : " << k << endl;
        exit(2);
    }
    Log("create shm success", Error) << " client key : " << k << endl;

    // sleep(10);

    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    if(shmaddr == nullptr)
    {
        Log("attach shm failed", Error) << " client key : " << k << endl;
        exit(3);
    }
    Log("attach shm success", Error) << " client key : " << k << endl;
    // sleep(10);

    int fd = OpenFIFO(FIFO_NAME, WRITE);
    // 使用
    // client将共享内存看做一个char 类型的buffer
    while(true)
    {
        ssize_t s = read(0, shmaddr, SHM_SIZE-1);
        if(s > 0)
        {
            shmaddr[s-1] = 0;
            Signal(fd);
            if(strcmp(shmaddr,"quit") == 0) break;
        }
    }

    CloseFifo(fd);
    // char a = 'a';
    // for(; a <= 'z'; a++)
    // {
    //     shmaddr[a-'a'] = a;
    //     // 我们是每一次都向shmaddr[共享内存的起始地址]写入
    //     // snprintf(shmaddr, SHM_SIZE - 1,\
    //     //     "hello server, 我是其他进程,我的pid: %d, inc: %c\n",\
    //     //     getpid(), a);
    //     sleep(5);
    // }

    // strcpy(shmaddr, "quit");

    // 去关联
    int n = shmdt(shmaddr);
    assert(n != -1);
    Log("detach shm success", Error) << " client key : " << k << endl;
    // sleep(10);

    // client 要不要chmctl删除呢？不需要！！

    return 0;
}

shmServer.cc
 
#include "comm.hpp"

// 是不是对应的程序，在加载的时候，会自动构建全局变量，就要调用该类的构造函数 -- 创建管道文件
// 程序退出的时候，全局变量会被析构，自动调用析构函数，会自动删除管道文件
Init init; 

string TransToHex(key_t k)
{
    char buffer[32];
    snprintf(buffer, sizeof buffer, "0x%x", k);
    return buffer;
}

int main()
{
    // 我们之前为了通信，所做的所有的工作，属于什么工作呢：让不同的进程看到了同一份资源(内存)
    // 1. 创建公共的Key值
    key_t k = ftok(PATH_NAME, PROJ_ID);
    assert(k != -1);

    Log("create key done", Debug) << " server key : " << TransToHex(k) << endl;

    // 2. 创建共享内存 -- 建议要创建一个全新的共享内存 -- 通信的发起者
    int shmid = shmget(k, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666); //
    if (shmid == -1)
    {
        perror("shmget");
        exit(1);
    }
    Log("create shm done", Debug) << " shmid : " << shmid << endl;

    // sleep(10);
    // 3. 将指定的共享内存，挂接到自己的地址空间
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    Log("attach shm done", Debug) << " shmid : " << shmid << endl;

    // sleep(10);

    // 这里就是通信的逻辑了
    // 将共享内存当成一个大字符串
    // char buffer[SHM_SIZE];
    // 结论1： 只要是通信双方使用shm，一方直接向共享内存中写入数据，另一方，就可以立马看到对方写入的数据。
    //         共享内存是所有进程间通信(IPC)，速度最快的！不需要过多的拷贝！！（不需要将数据给操作系统）
    // 结论2： 共享内存缺乏访问控制！会带来并发问题 【如果我想一定程度的访问控制呢? 能】
    
    int fd = OpenFIFO(FIFO_NAME, READ);
    for(;;)
    {
        Wait(fd);

        // 临界区
        printf("%s\n", shmaddr);
        if(strcmp(shmaddr, "quit") == 0) break;
        // sleep(1);
    }
    // 4. 将指定的共享内存，从自己的地址空间中去关联
    int n = shmdt(shmaddr);
    assert(n != -1);
    (void)n;
    Log("detach shm done", Debug) << " shmid : " << shmid << endl;
    // sleep(10);

    // 5. 删除共享内存,IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
    n = shmctl(shmid, IPC_RMID, nullptr);
    assert(n != -1);
    (void)n;
    Log("delete shm done", Debug) << " shmid : " << shmid << endl;

    CloseFifo(fd);
    return 0;
}

3.system v ipc

3.1system v 共享内存 基础介绍

在这里插入图片描述

实际上，system v本质也是创建虚拟内存进而映射到实际内存上，不过跟上面管道不同的是，进程间信息交互的处理不在由内核系统那一套来处理，而是由操作系统直接处理，因此其是最快的ipc模式。

3.2system v 共享内存常用接口介绍
功能：用来创建共享内存
原型
    int shmget(key_t key, size_t size, int shmflg);
参数
    key:这个共享内存段名字
    size:共享内存大小
    shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

功能：将共享内存段连接到进程地址空间
原型
    void *shmat(int shmid, const void *shmaddr, int shmflg);参数
    shmid: 共享内存标识
    shmaddr:指定连接的地址
    shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1

shmaddr为NULL，核心自动选择一个地址
shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr - (shmaddr % SHMLBA)
shmflg=SHM_RDONLY，表示连接操作用来只读共享内存

功能：将共享内存段与当前进程脱离
原型
    int shmdt(const void *shmaddr);
参数
    shmaddr: 由shmat所返回的指针
返回值：成功返回0；失败返回-1
注意：将共享内存段与当前进程脱离不等于删除共享内存段

功能：用于控制共享内存
原型
    int shmctl(int shmid, int cmd, struct shmid_ds *buf);参数
    shmid:由shmget返回的共享内存标识码
    cmd:将要采取的动作（有三个可取值）
    buf:指向一个保存着共享内存的模式状态和访问权限的数据结构
返回值：成功返回0；失败返回-1

在这里插入图片描述

3.3system v 信息队列 以及信号量

这一块学有余力的同学再去详细了解，这里便不在一一呈现了。

4.一些基础概念的讲解

为了之后获取更好的阅读文章体验，我将提前把一些经常出现的基础概念在此总结一下，强烈介意第一次打基础的同学阅读。

当多个进程对同一份资源进行来回操作时，因为时序问题，可能会造成数据不一致的问题，为了解决这一问题，我们将定制一套基础方案，下面先对其中涉及到的专有名词的含义进行讲解。

临界资源：多个进程执行流看到的公用的一份资源

临界区：进程访问临界资源的代码

互斥性：为了更好的临界区的保护，可以让各执行流在同一时刻只有一个进程进入临界区

原子性：一件事情要么不做，要么做完，没有中间状态

信号量：信号量是一种用于实现进程间同步和互斥的机制。可以将信号量看作是一个计数器，它的值可以被多个进程或线程修改和读取。信号量的值表示可用的资源数量或某种条件的状态。

主要有两种类型的信号量：

  1. 二进制信号量（Binary Semaphore）：也称为互斥信号量，它的值只能为0或1。用于实现互斥访问共享资源，只允许一个进程或线程访问资源。
  2. 计数信号量（Counting Semaphore）：它的值可以是任意非负整数。用于控制一定数量的资源，多个进程或线程可以同时访问资源，但受限于信号量的计数值。
midslucky
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java进程间通讯方式有哪些_java 进程间通讯的有几种方法？
weixin_33340674的博客
02-24 1818
展开全部进程间通信的方法主要有以下几种：(1)管道(Pipe)：管道可用于具有亲缘关系进程间的通信，允许一个进程和另32313133353236313431303231363533e78988e69d8331333332616461一个与它有共同祖先的进程之间进行通信。(2)命名管道(named pipe)：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关 系进...
Linux 进程间通信
人生一世 草木一秋
08-12 2530
Linux进程通信继承了传统的UNIX进程间通信方式，包括无名管道、有名管道以及信号；还有System V进程间通信（IPC），包括System V消息队列、System V信号量以及System V共享内存；套接字。
进程间通信方式
记录各种Bug解决案例及日常学习内容
08-04 477
管道：速度慢，容量有限，只有父子进程能通讯；FIFO：任何进程间都能通讯，但速度慢；消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题；共享内存：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题；信号：有入门版和高级版两种，区别在于入门版注重动作，高级版可以传递消息。只有在父子进程或者是共享内存中，才可以发送字符串消息；信号量：不能传递复杂消息，只能用来同步。......
进程间的六种通信方式
GMLGDJ的博客
05-07 3万+
概述 每个进程的用户地址空间都是独立的，一般而言是不能互相访问的，但内核空间是每个进程都共享的， 所以进程之间要通信必须通过内核。 进程间通信目的一般有共享数据，数据传输，消息通知，进程控制等。以 Unix/Linux为例，介绍几种重要的进程间通信方式：管道、消息队列、共享内存、信号量、信号、Socket。 六种通信方式 管道 如果你学过Linux命令，那你肯定很熟悉 ｜ 这个竖线。 $ ps auxf ｜ grep mysql 上面命令行里的｜ 竖线就是一个管道，它的功能是将前一.
一文彻底搞懂进程间通信方式
最新发布
永远在路上
03-17 1332
每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）
进程间通讯的7种方式
热门推荐
zhaohong_bo的专栏
04-26 26万+
** 1、常见的通信方式 ** 管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 命名管道FIFO：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流...
进程间的通信方式（六种）
OYMNCHR的博客
05-12 6万+
进程之间的通信 参考文章：https://blog.csdn.net/qq_34827674/article/details/107678226 前提知识：每个进程都有自己的用户空间，而内核空间是每个进程共享的。因此进程之间想要进行通信，就需要通过内核来实现。 管道： 管道是最简单，效率最差的一种通信方式。 管道本质上就是内核中的一个缓存，当进程创建一个管道后，Linux会返回两个文件描述符，一个是写入端的描述符，一个是输出端的描述符，可以通过这两个描述符往管道写入或者读取数据。 如果想要实现两个进程通过
进程间通信方式和线程间通信方式
qq_40076192的博客
11-03 593
进程间通信方式： 1.管道( pipe )： 管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。缺点：速度慢，容量有限，只有父子进程能通讯 2.有名管道 (namedpipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。但速度慢。 3.信号量(semophore ) ： 信号量是一个计数器，可以用来控制多...
面试题：进程间通信方式，线程间通信方式
燕然一勒的博客
12-21 4940
一、进程间通信(IPC，Inter-Process Communication)是指在不同进程间传播或交换信息 1. 无名管道 特点 半双工(数据流向仅有一个方向)，具有固定的读端和写端 只能用于父进程或兄弟线程之间通信(具有血缘关系的线程之间) 一种特殊文件，可以用普通的read、write函数进行读写，但又不是普通文件，不属于任何其它文件系统，仅存在于内存之中 通信的数据是无格式的流并且大小受限 2. 命名管道（先进先出队列） 特点 不同于无名管道之处在于它提供一个与之关联的路径名，以F
最快进程间通信方式——共享内存
Zhang_1218的博客
11-21 1371
共享内存共享内存1、概念2、共享内存数据结构3、共享内存操作函数 共享内存 最快的进程间通信方式—— 共享内存 。 1、概念 共享内存即多个进程共享指定的一块物理内存空间，一旦此物理内存映射到共享它的进程的虚拟地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据 共享内存允许多个进程共享指定的物理内存空间。 共享内存少了两次涉及用户态和内核态数据拷贝的时间和资源消耗 ，带来极高的效率； 2、共享内存数据结构 3、共享内存操作函数 创建或打开共享内存
浅谈Linux进程间通信方式及优缺点
01-11
无名管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用.进程的亲缘关系一般指的是父子关系。无明管道一般用于两个不同进程之间的通信。当一个进程创建了一个管道,并调用fork创建自己...
linux-linux进程间通信方式汇总.zip
02-26
本文将全面解析Linux中的各种进程间通信方式，帮助你深入理解这一核心概念。 首先，我们来了解一下什么是进程。在操作系统中，进程是程序执行时的一个实例，每个进程都有自己的内存空间和系统资源。为了实现进程间...
Linux进程间通信方式之socket使用实例
09-15
主要介绍了Linux进程间通信方式之socket使用实例，具有一定参考价值，需要的朋友可以了解下。
Python中的进程间通信
12-20
以下是几种常见的Python进程间通信方式： 1. **信号量（Semaphore）**：信号量是一个整型变量，用于控制对共享资源的访问。当进程想要访问资源时，它会尝试获取信号量，如果信号量可用，则进程可以继续，否则会被...
Linux进程间的通信方式和原理
01-27
普通管道和流管道是单工的，用于父子进程或兄弟进程间通信；命名管道则允许非相关进程间通信，支持双向传输。 2. **信号量(Semaphore)**: 信号量是一个计数器，用于多进程对共享资源的访问控制，实现同步和互斥，...
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
详解Android 进程间通信的几种实现方式
08-31
总结来说，Android的四种进程间通信方式各有特点，选择哪种方式取决于具体的需求。Activity适用于启动其他应用功能，Content Provider用于数据共享，Broadcast适合全局通知，而Service和AIDL适用于需要稳定高效数据...
四种进程间通信的方式demo
12-14
通过这些示例，开发者可以深入理解每种IPC方式的使用场景和实现原理，从而在实际开发中灵活选择最适合的进程间通信方式。无论是在服务端处理长期任务，还是在不同应用之间共享数据，抑或是实现全局事件监听，Android...
"深入理解进程间通信方式与目的
在实际工作中，多个进程之间需要共享大量的数据，如果使用传统的进程间通信方式来进行数据传输，会造成大量的系统资源浪费和性能损失。而通过共享内存，多个进程可以直接访问同一个内存段，实现高效的数据传输和共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值