Linux系统编程：通过System V共享内存实现进程间通信

最新推荐文章于 2024-07-12 21:30:00 发布
最新推荐文章于 2024-07-12 21:30:00 发布
阅读量471 收藏 1
点赞数 3
分类专栏： Linux系统和网络 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43908419/article/details/132333120
版权

目录

一. 共享内存实现进程间通信的原理

二. 共享内存相关函数

2.1 共享内存的获取 shmget / ftok

2.2 共享内存与进程地址空间相关联 shmat

2.3 取消共享内存与进程地址空间的关联 shmdt

2.4 删除共享内存 shmctl

2.5 通信双方创建共享内存代码

三. 共享内存实现进程间通信

3.1 实现方法及特性

3.2 为共享内存添加访问控制

四. 总结

一. 共享内存实现进程间通信的原理

要实现进程间通信，就必须让相互之间进行通信的进程看到同一份资源（同一块内存空间），如通过管道实现进程间通信，本质就是让两个进程分别以读和写的方式打开同一份管道文件，一个进程向管道中写数据，另一个进程再从管道中将数据读出，这样两个进程就可以看到同一份内存空间，从而实现了进程间通信。

System V共享内存实现进程间通信的方式与管道相同，区别在于管道是基于文件的，而共享内存则是直接申请内存空间，不需用进行文件相关操作。通过System V共享内存实现通信的进程，都会使用物理内存中的同一块空间，这一块公共的物理内存空间经过通信双方进程的页表，映射到进程地址空间的共享区，通信双方进程在运行期间，拿到共享区虚拟地址，通过页表映射，就可以看到同一块物理内存，就可以实现进程间通信。

如果操作系统内有多组通过System V共享内存方式相互通信的进程处于运行状态，那么就会存在多组共享内存，操作系统需要对这些共享内存空间进行管理，管理方式为：先通过struct结构体进行描述，再利用特定的数据结构组织。

可以这样理解：共享内存 = 共享的物理内存 + 对应的内核级数据结构。

图1.1 共享内存的实现原理

二. 共享内存相关函数

共享内存实现进程间通信的步骤可以总结为：创建共享内存 -> 共享内存与地址空间相关联 -> 通信 -> 共享内存与地址空间解绑 -> 销毁共享内存。

2.1 共享内存的获取 shmget / ftok

shmget函数：获取共享内存

头文件：#include<sys/ipc.h>、#include<sys/shm.h>

函数原型：int shmget(key_t key, size_t size, int shmflg)

函数参数：

        key -- 特定共享内存的标识符

        size -- 共享内存的大小

        shmflg -- 共享内存获取的权限参数

返回值：创建成功返回共享内存的编号（称为shmid），失败返回-1

共享内存标识符key：OS中可能存在多个共享内存，需要保证通信双方看到同一块共享内存，因此，每个共享内存都需要一个特定的key值进行区分，这个key值是多少并不重要，只要保证它在OS中是唯一的即可。通信双方进程（Serve && Client）需要约定相同的算法，保证他们可以使用shmget获取到同一块共享内存。

ftok函数可以用于获取key值，只要调用ftok的实参相同，就会返回相同的key值。

ftok函数：获取共享内存标识符key

头文件： #include<sys/ipc.h>、#include<sys/types.h>

函数原型：key_t ftok(const char* pathname, int proj_id);

函数参数：

        pathname：项目（文件）路径

        proj_id：项目（文件）的id编号

返回值：成功返回特定的key值，否则返回-1。

共享内存大小size：以字节为单位，建议取页（PAGE：4096bytes）大小的整数倍，因为如果获取共享内存空间的大小不是页大小的整数倍，OS就会向上取整申请到页大小整数倍的内存空间，但是多申请的空间却不能被用户所使用。如，申请4097bytes的共享内存，OS会实际申请2*4096bytes的空间，而能被使用的只有4097bytes，剩下的都浪费掉了。

权限参数shmflg：有IPC_CREAT、IPC_EXCL、共享内存起始权限码、0这几种选项，他们之间通过竖划线 | 隔开，每个选项都有其意义。

  • IPC_CREAT：如果key标识的共享内存存在，就直接将其获取，如果不存在，就创建。
  • IPC_EXCL：单独使用没有任何意义，一般配合IPC_CREAT使用，IPC_CREAT | IPC_EXCL表示如果共享内存不存在就将其创建，如果存在直接报错，这样可以保证获取到的共享内存是一块全新的共享内存。
  • 起始权限码：用户对于这块共享内存的使用权限，如0666就表示拥有者、所属组、其他人就具有读写权限。
  • 0：只能获取已经存在的共享内存，不能创建新的，不存在就报错。

一般而言，通信双方分别以 IPC_CREAT | IPC_EXCL 和 0 的方式获取共享内存，确保一方创建全新的共享内存，另一方只能获取到该共享内存（传0阻断不存在创建新共享内存的可能）。

代码2.1以 IPC_CREAT | IPC_EXCL | 0666 的方式获取共享内存，运行代码，就可以成功获取共享内存，但是当第二次运行代码，却发现运行出错了(见图2.1)，这是因为该共享内存再第一次程序运行后被创建，存在于操作系统中，IPC_CREAT | IPC_EXCL获取的共享内存一定是全新的，因此第二次运行程序会失败，删除该共享内存之后才可以再次成功运行。

结论：共享内存的生命周期是随OS内核的，而不是随进程的。

代码2.1：获取共享内存

// common.hpp -- 头文件
#pragma once

#include <iostream>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define PATH_NAME "."
#define PROJ_ID 0x66
#define SIZE 4096


// shmServe.cc -- 客户端代码源文件（用于接收信息）
#include "common.hpp"

int main()
{
    // 获取共享内存key值
    key_t k = ftok(PATH_NAME, PROJ_ID);   
    if(k == -1)
    {
        perror("ftok");
        exit(1);
    }

    // 创建共享内存
    int shmid = shmget(k, SIZE, IPC_CREAT | IPC_EXCL | 0666);
    if(shmid == -1)
    {
        perror("shmget");
        exit(2);
    }
    printf("Serve# 共享内存获取成功，shmid:%d\n", shmid);

    return 0;
}
图2.1 代码2.1的两次运行结果

这里介绍两条指令，分别用于查看共享内存信息和删除共享内存：

  • ipcs -m 指令：查看系统中所有共享内存的详细信息。
  • ipcrm -m [shmid]：通过指定共享内存的shmid来删除指定的共享内存。

当然，也可以通过代码删除共享内存，本文后面会讲解。

图2.2 通过指令查看共享内存的属性信息和删除共享内存

2.2 共享内存与进程地址空间相关联 shmat

shmat函数：将共享内存关联到进程地址空间

头文件：#include<sys/types.h>、#include<sys/shm.h>

函数原型：void* shmat(int shmid, const void* shmaddr, int shmflg)

函数参数：

        shmid：进行挂接的共享内存的shmid

        shmaddr：指定挂接的虚拟地址（传NULL表示让OS自动选择挂接地址）

        shmflg：挂接权限相关参数

返回值：若成功返回挂接到的虚拟地址，失败返回nullptr

挂接地址shmaddr参数：由于我们并不可知虚拟地址的具体使用情况，所以这个参数基本都是传NULL/nullptr来让OS自动选择虚拟地址进行关联。 

挂接权限shmflg：如果传SHM_RDONLY，这表示对应共享内存空间只有读权限，传其他都是读写权限，一般shmflg都传实参0。

当共享内存与虚拟地址关联期间，使用ipcs -m指令查看共享内存属性信息，nattch就会变为1，如果通信双方都与共享内存进行了关联，那么nattch就是2。

2.3 取消共享内存与进程地址空间的关联 shmdt

shmdt函数：让共享内存与当前进程脱离

头文件：#include<sys/types.h>、#include<sys/shm.h>

函数原型：int shmdt(const char* shmaddr)

返回值：成功返回0，失败返回-1

2.4 删除共享内存 shmctl

通过共享内存控制shmctl函数（共享内存控制函数），可以删除共享内存。

删除共享内存的操作只要通信双方有一方指向即可，否则会造成重复删除。一般而言，读取信息的进程创建新的共享内存，也负责删除共享内存，遵循谁创建、谁删除的原则。

shmctl函数：控制共享内存

头文件：#include<sys/ipc.h>  #include<sys/shm.h>

函数原型：int shmctl(int shmid, int cmd, struct shmid_ds* buf)

函数参数：

        shmid -- 共享内存的shmid

        cmd -- 控制指令，选择操作

        buf -- 指向描述共享内存属性信息的结构体指针

返回值：成功返回非负数，失败返回-1

形参cmd可以选择具体的控制策略：

  • IPC_STAT -- 以buf为输出型参数，获取共享内存的属性信息。
  • IPC_SET -- 设置共享内存的属性为buf指向的内容。
  • IPC_RMID -- 删除共享内存，此时buf传空指针NULL。

2.5 通信双方创建共享内存代码

代码2.2：头文件common.hpp -- 由通信双方共同包含

#pragma once

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define PATH_NAME "."
#define PROJ_ID 0x66
#define SIZE 4096

代码2.3：服务端代码shmServe.cc -- 用于数据读取

#include "common.hpp"

int main()
{
    // 获取共享内存key值
    key_t k = ftok(PATH_NAME, PROJ_ID);   
    if(k == -1)
    {
        perror("Serve ftok");
        exit(1);
    }
    printf("Serve# 成功获取key值，key:%d\n", k);

    // 创建共享内存
    int shmid = shmget(k, SIZE, IPC_CREAT | IPC_EXCL | 0666);
    if(shmid == -1)
    {
        perror("Sreve shmget");
        exit(2);
    }
    printf("Serve# 共享内存获取成功，shmid:%d\n", shmid);

    // 将共享内存与进程相关联
    char* shmaddr = (char*)shmat(shmid, NULL, 0);
    if(shmaddr == nullptr)
    {
        perror("Serve shmat");
        exit(3);
    }
    printf("Serve# 共享内存与进程成功关联，shmid:%d\n", shmid);

    // 通信代码
    // ... ...
    
    // 让共享内存脱离当前进程
    int n = shmdt(shmaddr);
    if(n == -1)
    {
        perror("Serve shmdt");
        exit(4);
    }
    printf("Serve# 共享内存成功脱离进程，shmid:%d\n", shmid);

    // 删除共享内存
    n = shmctl(shmid, IPC_RMID, NULL);
    if(n == -1)
    {
        perror("Serve shmctl");
        exit(5);
    }
    printf("Serve# 共享内存删除成功，shmid:%d\n", shmid);

    return 0;
}

代码2.4：客户端代码shmClient.cc -- 用于数据发送

#include "common.hpp"

int main()
{
    // 获取共享内存key值
    key_t k = ftok(PATH_NAME, PROJ_ID);   
    if(k == -1)
    {
        perror("Client ftok");
        exit(1);
    }
    printf("Client# 成功获取key值，key:%d\n", k);

    // 创建共享内存
    int shmid = shmget(k, SIZE, 0);
    if(shmid == -1)
    {
        perror("Client shmget");
        exit(2);
    }
    printf("Client# 共享内存获取成功，shmid:%d\n", shmid);

    // 将共享内存与进程相关联
    char* shmaddr = (char*)shmat(shmid, NULL, 0);
    if(shmaddr == nullptr)
    {
        perror("Client shmat");
        exit(3);
    }
    printf("Client# 共享内存与进程成功关联，shmid:%d\n", shmid);

    // 通信代码
    // ... ...
    
    // 让共享内存脱离当前进程
    int n = shmdt(shmaddr);
    if(n == -1)
    {
        perror("Client shmdt");
        exit(4);
    }
    printf("Client# 共享内存成功脱离进程，shmid:%d\n", shmid);

    return 0;
}

三. 共享内存实现进程间通信

3.1 实现方法及特性

在数据输入端（shmClient），我们可以将共享内存视为一块通过malloc得来的char*指向的一段动态内存空，可以使用printf系列函数向这块空间写数据，或者将共享内存空间视为数组，使用下标的形式给每个位置赋值，这样就实现了将数据写入共享内存。

在数据读取端（shmServe），可以将共享内存视为一个大字符串，通过特定的方式，从这个大字符串中获取数据即可。

代码3.1和代码3.2实现了共享内存进程间通信的简单逻辑，在shmClient端，通过下标访问的方式，每隔3s写一次数据，在shmServe端，每隔1s读取一次数据。先运行shmServe端代码，间隔几秒后运行shmClient端代码，根据图3.1展示的运行结果，shmServe端在shmClient端开始运行之前就开始读取共享内存中的内容，在shmClient运行起来后，由于读快写慢，shmClient写入的内容在shmServe端被多次读取，可见，共享内存，没有访问控制。

结论1：共享内存没有访问控制。

代码3.1：shmClient端发送数据

    // 通信代码
    char ch = 'a';
    int count = 0;
    for(; ch <= 'c'; ++ch)
    {
        shmaddr[count++] = ch;
        printf("write succsee# %s\n", shmaddr);
        sleep(3);
    }
    
    snprintf(shmaddr, SIZE, "quit");

代码3.2：shmServe端读取数据 

    // 通信代码
    while(true)
    {
        printf("[Client say]# %s\n", shmaddr);
        if(strcmp(shmaddr, "quit") == 0) break;
        sleep(1);
    }
图3.1 共享内存通信读写双方代码执行结果

通过观察上面的代码我们发现，用户可以直接向共享内存中写数据和从共享内存中读取数据，不需要经过用户级缓冲区，共享内存的读或写操作最少只需要一次拷贝即可完成。而通过管道进行读写，则需要将数据预先写入或读入缓冲区，才可以写入管道文件或读出。图3.2为使用管道和共享内存的方法进行进程间通信时，读和写操作涉及的数据拷贝情况，管道通信至少要进行两次数据拷贝，而共享内存可以只进行一次数据拷贝，因此共享内存是一种高效的进程间通信手段。

结论2：共享内存进行进程间通信，通信的一方向共享内存中写入数据，通信的另一方马上就能读取到数据，不需要向操作系统中拷贝数据，共享内存是所有进程间通信方法中效率最高的。

图3.2 管道和共享内存实现进程间通信的资源拷贝情况

管道通信的特性总结：

  1. 不具有访问控制，存在并发问题。
  2. 不需要向OS内核中拷贝数据，通信效率高。

3.2 为共享内存添加访问控制

通过使用命名管道加以辅助，就可以为共享内存添加访问控制，具体的实现方法和原理为：

  • 在读端（shmServe）程序开始运行时创建命名管道文件，程序运行结束后管道文件销毁。
  • 在写端（shmClient）向共享内存中写入数据后，向管道文件中写入任意的、少量的数据，在读端（shmServe）获取共享内存内容之前，先读取管道中的资源，如果写端没有将期望的数据全部写入共享内存，那么就不会向管道中写数据，读端就必须阻塞等待管道中被写入数据，也就无法获取共享内存中的数据。只有当写端完成向共享内存中写入一次数据，然后向管道文件中写入数据让读端读到了管道资源后，读端代码才可以继续运行，获取到共享内存中的资源。

代码3.3 ~ 3.5，为通过管道为共享内存添加访问控制的实现代码。

代码3.3：common.hpp头文件 -- 被通信双方源文件包含

#pragma once

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

#define PATH_NAME "."
#define PROJ_ID 0x66
#define SIZE 4096

#define FIFO_NAME "fifo.ipc"
#define MODE 0666

// 定义类，其构造和析构函数可以创建和销毁管道文件
class Init
{
public:
    Init()
    {
        int n = mkfifo(FIFO_NAME, MODE);
        if(n == -1) perror("mkfifo");
        assert(n != -1);
        (void)n;
    }

    ~Init()
    {
        int n = unlink(FIFO_NAME);
        assert(n != -1);
        (void)n;
    }
};

#define READ O_RDONLY 
#define WRITE O_WRONLY

// 管道文件打开函数
int OpenFifo(const char* pathname, int flags)
{
    int fd = open(pathname, flags);
    assert(fd != -1);
    return fd;
}

// 等待函数 -- 用于读端访问控制
// 管道内没有资源时就阻塞
void Wait(int fd)
{
    uint32_t temp = 0;
    ssize_t sz = read(fd, &temp, sizeof(uint32_t));
    assert(sz == sizeof(uint32_t));
    (void)sz;
}

// 唤醒函数 -- 用于写端进程控制
// 向管道内写数据，终止读端进程的阻塞等待
void WakeUp(int fd)
{
    uint32_t temp = 1;
    ssize_t sz = write(fd, &temp, sizeof(uint32_t));
    assert(sz == sizeof(uint32_t));
    (void)sz;
}

// 管道关闭函数
void CloseFifo(int fd)
{
    close(fd);
}

代码3.4：读端源文件（shmServe.cc）代码

#include "common.hpp"

// 全局类对象
// 构造和析构函数分别负责管道文件的创建和销毁
Init init;

int main()
{
    // 获取共享内存key值
    key_t k = ftok(PATH_NAME, PROJ_ID);   
    if(k == -1)
    {
        perror("Serve ftok");
        exit(1);
    }
    printf("Serve# 成功获取key值，key:%d\n", k);

    // 创建共享内存
    int shmid = shmget(k, SIZE, IPC_CREAT | IPC_EXCL | 0666);
    if(shmid == -1)
    {
        perror("Sreve shmget");
        exit(2);
    }
    printf("Serve# 共享内存获取成功，shmid:%d\n", shmid);

    // 将共享内存与进程相关联
    char* shmaddr = (char*)shmat(shmid, NULL, 0);
    if(shmaddr == nullptr)
    {
        perror("Serve shmat");
        exit(3);
    }
    printf("Serve# 共享内存与进程成功关联，shmid:%d\n", shmid);

    // 通信代码
    int fd = OpenFifo(FIFO_NAME, READ);   // 只读方式打开管道文件
    while(true)
    {
        Wait(fd);   // 等待读取
        printf("[Client say]# %s\n", shmaddr);
        if(strcmp(shmaddr, "quit") == 0) break;
    }

    // while(true)
    // {
    //     printf("[Client say]# %s\n", shmaddr);
    //     if(strcmp(shmaddr, "quit") == 0) break;
    //     sleep(1);
    // }
    
    // 让共享内存脱离当前进程
    int n = shmdt(shmaddr);
    if(n == -1)
    {
        perror("Serve shmdt");
        exit(4);
    }
    printf("Serve# 共享内存成功脱离进程，shmid:%d\n", shmid);

    // 删除共享内存
    n = shmctl(shmid, IPC_RMID, NULL);
    if(n == -1)
    {
        perror("Serve shmctl");
        exit(5);
    }
    printf("Serve# 共享内存删除成功，shmid:%d\n", shmid);

    CloseFifo(fd);

    return 0;
}

代码3.5：写端源文件（shmClient.cc）代码

#include "common.hpp"

int main()
{
    // 获取共享内存key值
    key_t k = ftok(PATH_NAME, PROJ_ID);   
    if(k == -1)
    {
        perror("Client ftok");
        exit(1);
    }
    printf("Client# 成功获取key值，key:%d\n", k);

    // 创建共享内存
    int shmid = shmget(k, SIZE, 0);
    if(shmid == -1)
    {
        perror("Client shmget");
        exit(2);
    }
    printf("Client# 共享内存获取成功，shmid:%d\n", shmid);

    // 将共享内存与进程相关联
    char* shmaddr = (char*)shmat(shmid, NULL, 0);
    if(shmaddr == nullptr)
    {
        perror("Client shmat");
        exit(3);
    }
    printf("Client# 共享内存与进程成功关联，shmid:%d\n", shmid);

    // 通信代码
    int fd = OpenFifo(FIFO_NAME, WRITE);
    while(true)
    {
        ssize_t sz = read(0, shmaddr, SIZE);    // 共享内存从键盘中读入数据(换行符也被写入)
        assert(sz >= 0);
        shmaddr[sz - 1] = '\0';   //末尾添加'\0'表示终止
        WakeUp(fd);    // 唤醒读端进程
        if(strcmp(shmaddr, "quit") == 0) break;
    }

    // char ch = 'a';
    // int count = 0;
    // for(; ch <= 'c'; ++ch)
    // {
    //     shmaddr[count++] = ch;
    //     printf("write succsee# %s\n", shmaddr);
    //     sleep(3);
    // }
    
    // snprintf(shmaddr, SIZE, "quit");
    
    // 让共享内存脱离当前进程
    int n = shmdt(shmaddr);
    if(n == -1)
    {
        perror("Client shmdt");
        exit(4);
    }
    printf("Client# 共享内存成功脱离进程，shmid:%d\n", shmid);

    CloseFifo(fd);

    return 0;
}

四. 总结

  • System V共享内存实现进程间通信的底层原理是通信双方进程看到同一块内存，位于物理内存上的共享内存块，通过页表映射到通信双方的进程地址空间的共享区，通信双方拿到共享区的虚拟地址，通过页表映射，访问到同一块物理内存。
  • 使用System V共享内存实现进程间通信的操作流程为：通过ftok函数获取唯一的共享内存标识符key -> 通过shmget函数获取共享内存 -> 通过shmat函数让共享内存和进程绑定 -> 【进行进程通信】-> 通过shmdt函数让共享内存和进程脱离 -> 通过shmctl删除共享内存。
  • System V共享内存 进程间通信的特点为：（1）不需要向操作系统内核中拷贝数据，是所有进程间通信的方法中效率最高的。（2）没有访问控制。
  • 通过管道的辅助，可以为 System V共享内存 进程间通信添加访问控制。
【Shine】光芒
关注
专栏目录
IPC之七：使用 System V 共享内存段进行进程间通信的实例
whowin
12-15 454
IPC是Linux编程中一个重要的概念，IPC有多种方式，本文主要介绍共享内存(Shared Memory)，因为没有像管道、消息队列这样的中介介入，所以通常认为共享内存是迄今为止最快的IPC方式；Linux既支持UNIX SYSTEM V的共享内存，也支持POSIX的共享内存，本文针对System V共享内存段，本文给出了多个具体的实例，每个实例均附有完整的源代码；本文所有实例在Ubuntu 20.04上编译测试通过；本文的实例中涉及多进程编程和信号处理等，对初学者有一定难度。
IPC之八：使用 POSIX 共享内存进行进程间通信的实例
whowin
12-19 1055
IPC是Linux编程中一个重要的概念，IPC有多种方式，本文主要介绍共享内存(Shared Memory)，因为没有像管道、消息队列这样的中介介入，所以通常认为共享内存是迄今为止最快的IPC方式；Linux既支持UNIX SYSTEM V的共享内存段，也支持POSIX的共享内存对象，本文针对POSIX共享内存对象，本文给出了多个具体的实例，每个实例均附有完整的源代码；本文的实例中涉及多进程编程和号处理等，阅读本文还需要一些基本的内存管理知识，本文对 Linux 编程的初学者有一些难度。
【进程间通信】System V共享内存通信 {共享内存通信原理；相关函数：shmget, ftok, shmat, shmdt, shmctl；消息队列和信号量；IPC相关命令}
52Herzt的博客
10-11 192
【进程间通信】System V共享内存通信 {共享内存通信原理；相关函数：shmget, ftok, shmat, shmdt, shmctl；消息队列和信号量；IPC相关命令}
linux网络编程之System V 共享内存 和 系列函数
Meditation
06-14 4056
跟消息队列一样，共享内存也有自己的数据结构，如下： struct shmid_ds { struct ipc_perm shm_perm;    /* Ownership and permissions */ size_t     shm_segsz;   /* Size of segment (bytes) */ time_t     shm_atime;   /* Last a
利用共享内存机制实现进程通信
weixin_43662044的博客
06-20 518
利用共享内存机制实现进程间通信
Linux通信：基于System V共享内存方式实现进程间通信
最新发布
Zhenyu_Coder的博客
07-12 1952
一、基于共享内存通信方式原理 二、共享内存优缺点 2.1 共享内存优缺点 2.2 基于文件通信 vs 共享内存通信 三、相关函数调用接口 2.1 创建共享内存（shmget） 2.1.1 key 2.1.2 size 2.1.3 shmflg 2.1.4 返回值 2.2 共享内存段挂接到进程地址空间（shmat） 2.3 将共享内存段与当前进程脱离（shmdt） 2.4 用于控制共享内存（删除）（shmctl） 四、基于System V共享内存实现进程间通信
linux下C语言实现进程通信与共享内存
weixin_43643793的博客
07-26 841
先执行sem_P.c（./sem_P 1 -10），输入一个-10传给灯ss1的value，让该进程处于阻塞状态，然后执行sem_V.c（./sem_V.c 1 2），每次执行灯ss1就会加2，执行5次后ss1的value会加到10，此时原来ss1的value = -10会被抵消为0，sem_P.c解除阻塞，打印“NO WAIT”，这就是进程的同步。进程通信的操作并不难，难就难在函数多，参数多，参数还结合了结构体联合体，就很恶心，这也是我大部分代码都是介绍函数的原因，重点在对各种API函数的介绍上。
Linux系统编程第05期：进程间通信
06-14
本视频教程为《Linux系统编程》第05期，本期课程将会带领大家学习Linux下将近15种进程间通信IPC工具的使用，了解它们的通信机制、编程实例、使用场景、内核中的实现以及各自的优缺点。 本课程会提供PDF版本的PPT课件...
Linux系统编程：进程间通信之管道详解
"Linux系统编程中的进程间通信是一个重要的主题，特别是管道(Pipe)作为一种常见的通信机制，被广泛用于父子进程或兄弟进程之间的数据传递。管道是半双工的，即数据只能单向流动，需要双向通信时需要两个独立的管道。...
Linux系统编程：深入理解进程间通信机制
"深入解析LINUX系统编程中的进程间通信机制，包括信号机制、管道以及System V IPC机制。" 在LINUX系统编程中，进程间通信（IPC）是至关重要的，它使得不同进程能够共享信息、协调工作。本资料详细探讨了这一主题，...
历史or技术科普（3）认识UNIX System V
二进制君
03-07 1175
UNIX System V是Unix操作系统众多版本中的一支。它最初由AT&T开发，在1983年第一次发布，因此也被称为AT&T System V。一共发行了4个System V的主要版本：版本1、2、3和4。System V Release 4，或者称为SVR4，是最成功的版本，成为一些UNIX共同特性的源头，例如“SysV 初始化脚本”（/etc/init.d），用来控制系统启动和关闭，System V Interface Definition（SVID）是一个System V如何工作的
linux ftok（）函数
weixin_33981932的博客
05-31 533
      系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。通常情况下，该id值通过ftok函数得到。ftok原型如下：key_t ftok( char * fname, int id )fname就时你指定的文件名(该文件必须是存在而且可以访问的)，id是子序号，虽然为int，但是只有8个比特被使用(0-255)。当成功执行的时候，一个key_t值将会被返回，否则 -1 被返回。...
Linux系统调用函数shmget()、shmat()，标准C库函数ftok()（创建共享内存段，创建共享内存段的键，把共享内存段加入当前的进程的地址空间中）
weixin_49503250的博客
05-09 4045
如果，想要深入的学习Linux系统调用中的shmget、shmat函数与标准C库中的ftok函数，还是需要去自己阅读Linux系统中的帮助文档。即可查阅到完整的资料信息。
linux shmget ftok shmat shmdt shmctl函数
weixin_59349642的博客
05-01 1135
这里写目录标题一 上一节的回顾二 上一节的补充三 ftok shmget 函数配合生成的key值四 shmat 函数五 shmdt函数六 shmctl函数1 shmctl函数的使用第一种方法2 shmctl函数的使用第二种方法3 不使用shmctl函数第三种方法 一 上一节的回顾 用 shmget 函数 创建了 共享内存 用 icps -m xxx 删除了指定的内存 二 上一节的补充 删除的是映射 为什么不是内核呢 映射的过程 相当于 内核的东西换了一个位置 输出 方便用户使用 节省了
【Linux】进程间通信 --- 管道 共享内存 消息队列 信号量
The porters of knowledge
04-16 1098
进程间通信的本质，匿名管道，命名管道，基于管道的进程池设计，共享内存，消息队列、信号量，IPC资源的组织方式…
8.进程间通信：共享内存（shmget）、信号(signal)
lidaxia_it的博客
01-27 825
4 信号(Signal) 信号是Linux系统中用于进程间互相通信或者操作的一种机制，信号可以在任何时候发给某一进程，而无需知道该进程的状态。 如果该进程当前并未处于执行状态，则该信号就有内核保存起来，知道该进程回复执行并传递给它为止。 如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消是才被传递给进程。 Linux系统中常用信号： （1）SIGHUP：用户从终端注销，所有已启动进程都将收到该进程。系统缺省状态下对该信号的处理是终止进程。 （2）SIGINT：程序终止信号。程序运行
进程间通信之共享内存
k5426244的博客
07-19 2193
1.进程间通信的分类：（1）管道：1、匿名管道pipe;2、命名管道mkfifo（2）System V IPC：1、System V 消息队列;2、System V 共享内存;3、System V 信号量。（3）POSIX IPC：1、消息队列;2、共享内存;3、信号量;4、互斥量;5、条件变量;6、读写锁。前面已经了解了进程间管道通信，那么共享内存又是什么原理？
Linux操作系统~基于systemV共享内存的进程间通信
Zebra的博客
12-04 1047
首先我们先来看一下进程间通信总共有哪些方式？管道System V IPCPOSIX IPC这里我讨论的是基于systemV共享内存的进程间通信 命名管道和匿名管道都是基于文件的通信方式，还有systemV标准的通信方式：在同一主机内的进程间通信方案——system V方案注意进程间通信的本质：让不同进程看到同一份资源1.通过某种调用,在内存中创建一份内存空间2.通过某种调用,让进程（参与通信的多个进程）“挂接”到这份新开辟的内存空间上（挂接就是通过页表映射到这片物理空间）-让不同的进程看到了同
Linux——进程间通信——system V系列
qq_63943454的博客
10-02 666
system V 版本进程间通信的机制。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值