C++学习：第六章Linux高级编程 - （八）共享内存、消息队列、Socket、Socket编程模型

最新推荐文章于 2024-08-21 21:06:48 发布
最新推荐文章于 2024-08-21 21:06:48 发布
阅读量422 收藏
点赞数
分类专栏： C++
共享知识，欢迎转载
本文链接：https://blog.csdn.net/kakiebu/article/details/109314662
版权

一、 基于文件的通信

  1. 普通文件(io/mmap)
  2. 有名管道文件
  3. 匿名管道
  4. Socket

 

二、 基于内存的通信

  1. 一组内核内存的工具

ipcs //查看以下三个

ipcs -m //查看共享内存

ipcs -q //查看共享队列

ipcs -s //查看共享信号量

ipcrm -q 编号ID //删除。。。

  2. 普通的父子进程之间的匿名内存共享影射

  3. 内核共享内存

编程模型：

3.1 创建共享内存，得到一个ID  shmget

3.2 把ID影射成虚拟地址(挂载)  shmat

3.3 使用虚拟地址访问内核共享内存，使用任何内存函数与运算符号

str** mem** += ++ [] ->

3.4 卸载虚拟地址 shmdt

3.5 删除共享内存 shctl(修改/获取共享内存的属性)

共享内存的属性：

运行 ipcs -m 

key 共享内存的ID 共享内存的创建者 共享内存的参数(读写执行) 共享内存的大小 有几个内存挂在该共享内存上 共享内存的状态

案例：

A. 创建共享内存，并且修改内存数据。

  1. 创建共享内存

int shmget(
    key_t key, //为什么需要key
    int size, //共享内存大小
    int flags //共享内存的属性与权限
)

为什么要key_t：

约定创建与访问的是同一个共享内存。

第三个参数：

方式|权限

方式：

创建：IPC_CREAT  IPC_EXCL

打开：0

常见的两种方式：

创建：IPC_CREAT|IPC_EXCL | 0666;

打开：0

返回：

成功返回共享内存ID

失败返回-1

       B. 根据ID得到共享，并且访问内存数据。

void shmat(
    int id,
    void *startaddr, //0：系统指定首地址
    int flags) //挂载方式，建议0，可以使用IPC_RDONLY

       C. 删除

int shmctl(
    int id, //被操作的共享内存ID
    int how, //操作方式:一共三种操作
    struct shmid_ds*ds)//共享内存属性
how：
    IPC_STAT //获取
    IPC_SET //修改
    IPC_RMID //删除

 文件A，负责写数据

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/shm.h>
#include <sys/ipc.h>

key_t key;
int shmid;
int *p;
int i=0;

void deal(int s)
{
    if(s==SIGINT)
    {
        //4.卸载共享内存shmdt
        shmdt(p);

        //5.删除共享内存shctl
        shmctl(shmid,IPC_RMID,0);

        exit(0);
    }
}

main()
{
    signal(SIGINT,deal);

    //1.创建共享内存shmget
    key=ftok(".",255);
    if(key==-1) printf("ftok error:%m\n"),exit(-1);

    shmid=shmget(key,4,IPC_CREAT|IPC_EXCL|0666);
    if(shmid==-1) printf("get error:%m\n"),exit(-1);

    //2.挂载共享内存shmat
    p=shmat(shmid,0,0);
    if(p==(int*)-1) printf("at error:%m\n"),exit(-1);

    //3.访问共享内存
    while(1)
    {
        *p=i;
        sleep(1);
        i++;
    }

}

文件B，负责读数据

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/shm.h>
#include <sys/ipc.h>

key_t key;
int shmid;
int *p;

void deal(int s)
{
    if(s==2)
    {
        //4.卸载共享内存shmdt
        shmdt(p);

        exit(0);
    }
}

main()
{
    signal(SIGINT,deal);

    //1.创建共享内存shmget
    key=ftok(".",255);
    if(key==-1) printf("ftok error:%m\n"),exit(-1);

    shmid=shmget(key,4,0);
    if(shmid==-1) printf("get error:%m\n"),exit(-1);

    //2.挂载共享内存shmat
    p=shmat(shmid,0,0);
    if(p==(int*)-1) printf("at error:%m\n"),exit(-1);

    //3.访问共享内存
    while(1)
    {
        sleep(1);
        printf("%d\n",*p);
    }
}

 

  4. 内核共享队列(有序)

编程模型：

4.1 创建共享队列/得到队列msgget

4.2 使用队列（发送消息msgsnd/接收消息msgrcv）

4.3 删除队列msgctl

案例：

A：创建共享队列

int msgget(key_t,int);

B：发送消息

int msgsnd(
    int id, //消息队列ID
    const void *msg, //要发送消息
    size_t len, //消息的长度
    int flags //发送消息的方式，建议为0
);

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

第二个参数的消息有固定的格式

4字节：表示消息的类型

若干字节：消息内容。

第三个参数：

消息的大小，不包含类型的4个字节

 

文件A，负责写数据

#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//2构造消息

struct msgbuf
{
    long type;
    char data[32];//任意大小
};

main()
{
    key_t key;
    int msgid;
    int i;
    struct msgbuf msg;//2构造消息

    //1创建消息队列
    key=ftok(".",200);
    if(key==-1) printf("ftok err:%m\n"),exit(-1);

    msgid=msgget(key,IPC_CREAT|IPC_EXCL|0666);
    if(msgid==-1)printf("get err:%m\n"),exit(-1);

    //2构造消息


    //3发送消息
    for(i=1;i<=10;i++)
    {
        bzero(msg.data,sizeof(msg.data));
        msg.type=1;//这个值必须大于0
        sprintf(msg.data,"MessageI:%d",i);
        msgsnd(msgid,&msg,sizeof(msg.data),0);
    }

    for(i=1;i<=10;i++)
    {
        bzero(msg.data,sizeof(msg.data));
        msg.type=2;
        sprintf(msg.data,"MessageII:%d",i);
        msgsnd(msgid,&msg,sizeof(msg.data),0);
    }

    //4删除队列
    //msgctl(msgid,IPC_RMID,0);
}

 

文件B，负责读数据

#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct msgbuf
{
    long type;
    char data[32];
};

main()
{
    key_t key;
    int msgid;
    int i;
    struct msgbuf msg;

    //1得到消息队列
    key=ftok(".",200);
    if(key==-1) printf("ftok err:%m\n"),exit(-1);

    msgid=msgget(key,0);
    if(msgid==-1)printf("get err:%m\n"),exit(-1);

    //2构造消息


    //3接收消息
    while(1)
    {
        bzero(&msg,sizeof(msg));
        msg.type=2;
        msgrcv(msgid,&msg,sizeof(msg.data),2,0);
        printf("%s\n",msg.data);
    }
}

 

三、 基于socket文件的IPC

socket文件的通信方式，比较重要，原因：网络采用这种通信模型。

两种模型：

对等模型

C/S模型（主客模型）

  1. 对等模型：

接收数据模型

1.1 建立socket:socket

int socket(

int domain, //地址族的类型AF_UNIX AF_INET

int type, //支持的数据格式：流SOCK_STREAM/报文SOCK_DGRAM

int protocol); //支持的协议，建议为0

返回值：

成功返回文件描述符号。

失败返回-1;

1.2 绑定在地址上(文件目录地址)URL(Universe Resource Location)

协议：//路径/文件名

 

file:///usr/bin/ls

http://192.168.0.72/index.php

 

struct sockaddr;

struct sockaddr_un; un=unix

struct sockaddr_in; in=internet

 

int bind(int fd, //socket描述符号

struct sockaddr*addr, //绑定地址

socklen_t size); //地址长度

1.3 接收数据

read/recv/recvfrom

1.4 关闭socket

 

发送数据模型

  1. 建立socket:socket
  2. 连接到目标:connect(可选)
  3. 发送数据:write/send/sendto
  4. 关闭close

 

2. C/S模型

Server Client

建立socket:socket 建立socket:socket

绑定地址:bind 建立连接:connect

监听：listen

接收:accept

read/write read/write

close close

int listen(int fd,int num);
返回
     0：监听成功
    -1：失败
int accept(
    int fd,
    struct sockaddr*addr, //返回连接着的地址
    socklen_t* len) //接收返回地址的缓冲长度

返回：
    -1：接收失败
    >=0:对应客户的文件描述符号

 

总结：

共享内存

共享队列

socket文件通信

课堂练习：

CS模型代码

CS模型把socket文件替换成IP地址

 

ipA

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

//1.
#include <netinet/in.h>
#include <arpa/inet.h>


main()
{
    int fd;
    int r;
    char buf[200];

    //1.建立socket

    //2
    fd=socket(AF_INET,SOCK_DGRAM,0);
    if(fd==-1) printf("socket err:%m\n"),exit(-1);
    printf("socket成功!\n");

    //2.构造本地文件地址

    //3.
    struct sockaddr_in addr={0};
    addr.sin_family=AF_INET;
    addr.sin_port=htons(9999);
    addr.sin_addr.s_addr=inet_addr("192.168.180.92");

    //3.把socket绑定在地址上
    r=bind(fd,(struct sockaddr*)&addr,sizeof(addr));
    if(r==-1) printf("bind err:%m\n"),exit(-1);
    printf("地址绑定成功!\n");

    //4.接收数据
    while(1)
    {
        bzero(buf,sizeof(buf));
        r=read(fd,buf,sizeof(buf));
        buf[r]=0;
        printf("%s\n",buf);
    }

    //5.关闭
    close(fd);

    //6.删除socket文件
    unlink("my.sock");

}

 

ipB

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

//1
#include <netinet/in.h>
#include <arpa/inet.h>

main()
{
    int fd;
    int r;

    //2
    struct sockaddr_in addr={0};

    //1.建立socket

    //3
    fd=socket(AF_INET,SOCK_DGRAM,0);

    //2.连接到指定的地址

    //4
    addr.sin_family=AF_INET;
    addr.sin_port=htons(9999);
    addr.sin_addr.s_addr=inet_addr("192.168.180.92");
    r=connect(fd,(struct sockaddr*)&addr,
    sizeof(addr));

    //3.发送数据
    write(fd,"Hello!Maomaochong!",strlen("Hello!Maomaochong!"));

    //4.关闭
    close(fd);dd

}

 

server

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/un.h>


main()
{
    int sfd;
    int cfd;
    struct sockaddr_un addr;
    int r;
    char buf[100];

    //1.建立socket
    sfd=socket(AF_UNIX,SOCK_STREAM,0);
    if(sfd==-1) printf("socket err:%m\n"),exit(-1);
    printf("建立socket成功!\n");

    //2.绑定地址
    bzero(&addr,sizeof(addr));
    addr.sun_family=AF_UNIX;
    memcpy(addr.sun_path,"cs.sock",strlen("cs.sock")+1);
    r=bind(sfd,(struct sockaddr*)&addr,sizeof(addr));
    if(r==-1) printf("bind err:%m\n"),exit(-1);
    printf("bind成功!\n");


    //3.监听
    r=listen(sfd,10);
    if(r==-1) printf("listen err:%m\n"),exit(-1);
    printf("listen成功!\n");


    //4.接收客户
    cfd=accept(sfd,0,0);
    if(cfd==-1) printf("accept err:%m\n"),exit(-1);
    printf("建立连接者的状态成功!\n");

    //5.接收这个客户的数据
    while(1)
    {
        r=read(cfd,buf,sizeof(buf));
        if(r==0)
        {
            printf("连接者退出");
            break;
        }

        if(r==-1)
        {
            printf("scoket故障!\n");
            break;
        }

        buf[r]=0;
        printf("::%s\n",buf);
        write(cfd,"Hi",2);
    }

    //6.关闭客户
    close(cfd);

    //7.关闭整个socket
    close(sfd);

}

 

socketA

#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/un.h>

main()
{
    int fd;
    int r;
    char buf[200];

    //1.建立socket
    fd=socket(AF_UNIX,SOCK_DGRAM,0);
    if(fd==-1) printf("socket err:%m\n"),exit(-1);
    printf("socket成功!\n");


    //2.构造本地文件地址
    struct sockaddr_un addr={0};
    addr.sun_family=AF_UNIX;
    memcpy(addr.sun_path,"my.sock",
    strlen("my.sock"));


    //3.把socket绑定在地址上
    r=bind(fd,(struct sockaddr*)&addr,sizeof(addr));
    if(r==-1) printf("bind err:%m\n"),exit(-1);
    printf("地址绑定成功!\n");

    //4.接收数据
    while(1)
    {
        bzero(buf,sizeof(buf));
        r=read(fd,buf,sizeof(buf));
        buf[r]=0;
        printf("%s\n",buf);
    }

    //5.关闭
    close(fd);

    //6.删除socket文件
    unlink("my.sock");
}

 

socketB

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <linux/un.h>
#include <string.h>
#include <unistd.h>

main()
{
    int fd;
    int r;
    char buf[100];
    struct sockaddr_un addr={0};

    //1.建立socket
    //fd=socket(AF_UNIX,SOCK_DGRAM,0);
    fd=socket(AF_UNIX,SOCK_STREAM,0);

    //2.连接到指定的地址
    addr.sun_family=AF_UNIX;
    memcpy(addr.sun_path,"cs.sock",strlen("cs.sock"));
    r=connect(fd,(struct sockaddr*)&addr,
    sizeof(addr));

    //3.发送数据
    while(1)
    {
        write(fd,"Hello!MaomaoYu!",strlen("Hello!MaomaoYu!"));
        read(fd,buf,100);
        printf("%s\n",buf);
        sleep(1);
    }

    //4.关闭
    close(fd);
}

 

Thomas会写字
关注
专栏目录
C++共享内存实现
CyberWarpX的博客
09-09 160
共享内存是一种在多个进程之间共享数据的机制，它允许进程在不进行显式的通信的情况下访问相同的内存区域。然后使用shmget函数创建一个共享内存区域，指定共享内存的大小为1024字节，并指定权限为0666|IPC_CREAT，表示创建一个新的共享内存区域。shmat函数的第一个参数是共享内存的标识符，第二个参数是指定连接的地址，传入0表示由系统自动分配地址。第三个参数指定连接的模式，传入0表示读写模式。请注意，由于共享内存是直接操作内存的，因此在使用共享内存时需要特别小心，避免出现数据竞争和同步问题。
c++进程间共享内存
超级丹的专栏
12-02 4351
通过文件映射对象共享内存 1.1往共享内存里写数据 // ServerCom.cpp : Defines the entry point for the console application. #include <stdio.h> #include <windows.h> #pragma endregion #define MAP_PREFIX L"Local\\" #def
转:标准C＋＋类string的Copy-On-Write技术
ztj111的专栏
11-27 1426
1、             概念 Scott Meyers在《More Effective C++》中举了个例子，不知你是否还记得？在你还在上学的时候，你的父母要你不要看电视，而去复习功课，于是你把自己关在房间里，做出一副正在复习功课的样子，其实你在干着别的诸如给班上的某位女生写情书之类的事，而一旦你的父母出来在你房间要检查你是否在复习时，你才真正捡起课本看书。这就是“拖延战术”，直到你
进程间的共享内存，socket编程
最新发布
qq_63641691的博客
08-21 1462
IPv6是较新的版本，由128位二进制数组成，以冒号分隔的十六进制表示，如2001:0db8:85a3:0000:0000:8a2e:0370:7334。删除共享内存：最后，当所有进程都不再需要共享内存时，创建共享内存的进程或拥有足够权限的进程可以删除共享内存段，释放资源。分离共享内存：当进程不再需要访问共享内存时，它会从自己的地址空间中分离共享内存段，这通常通过shmdt函数实现。公共地址：也称为公网地址，是分配给互联网上可访问的设备的IP地址，它们是唯一的，可以在全球范围内被识别。
Linux高级编程复习 第八章 共享内存 消息队列 socket编程
学峰的学习笔记
04-30 657
Linux高级编程 此处是截图   原文件下载地址是：
消息队列和共享内存
shanggamo的博客
10-24 5669
共享内存和消息队列都是在进程间传递数据的工具。 消息队列也是队列的一种，在同一类型上先进先出，可以完成多进程间的通讯，每个数据都带有类型，读取数据的进程只会读取自己关注的类型的数据，并且同一种类型的数据在内存是分段存储的，读取端口一次只能读一段数据。 消息队列操作函数： int msgget((key_t)key, int flag); int msgsnd(int msgid, const vo...
linux-socket-2.rar_Linux C socket_linux c++ socket_linux socke
09-22
本资料主要探讨了在C和C++语言环境下如何进行Linux Socket编程，涵盖了客户端和服务器端的实现。 一、Socket基础概念 Socket是操作系统提供的一种接口，允许应用程序通过它与其他计算机上的程序进行通信。它支持TCP...
C++中Socket网络编程实例详解
08-30
C++中的Socket网络编程是构建网络应用程序的基础，它允许程序通过网络进行通信。Socket接口是操作系统提供的标准API，用于在不同主机之间交换数据。本文将深入探讨C++中Socket网络编程的基本概念、步骤以及示例代码...
linux_program.rar_Linux 线程通信_linux socket 文件_linux文件编程_linux编程_进
09-14
Linux提供了多种进程间通信（IPC）方式，如管道（pipe）、共享内存、消息队列、信号量和套接字对等。理解这些机制以及它们在多进程环境中的作用是编写高效并发程序的关键。 接下来，"线程&线程间通信"。线程是轻量...
Linux下使用C++进行Socket编程
10-29
Linux下使用C++进行Socket编程是一门涉及网络通信的高级技术。在Linux操作系统中，Socket编程通常采用C语言，因为传统的GNU C库提供了丰富的Socket API函数，但这些函数是面向过程设计的，没有面向对象的封装，使用...
Linux-select-TCP.rar_C++并发编程_LINUX TCP _TCP客户端_linux C++ TCP_并发
09-24
在IT行业中，C++并发编程是一项关键技能，特别是在网络服务开发中。Linux系统以其开源、稳定和高效的特点，成为许多服务器应用的首选平台。本文将深入探讨如何在Linux环境下使用C++实现TCP并发服务器和客户端的编程...
Linux共享内存与消息队列
12-18
Linux采用共享内存与消息队列，进程间通信，完成视频推流功能
使用消息队列与共享内存完成一个简单的终端聊天程序
08-09
使用消息队列与共享内存完成一个简单的终端聊天程序
c++共享内存（一）：用CreateFileMapping实现的程序A放数据，程序B取数据
weixin_43935474的博客
02-05 2630
最新学习共享内存，网上查看了一些资料，自己写了个demo，在此记录一下，欢迎各位路过的大神提供宝贵意见及建议_ 程序分为CreateFileMapping_ProgramA和CreateFileMapping_ProgramB两个， 1.程序A和B同时创建了名为NameOfMappingObject的共享内存 【注：两个程序中的共享内存名必须相同，否则无法共同访问该内存！】 2.程序A接受到用户输...
关于进程间通信
zj
09-23 270
原文：凉了！张三同学没答好「进程间通信」，被面试官挂了…_小林coding-CSDN博客 转载只为了个人做一些批注 文章目录前言正文管道消息队列共享内存信号量信号Socket总结个人记录 前言 开场小故事 炎炎夏日，张三骑着单车去面试花了 1 小时，一路上汗流浃背。 结果面试过程只花了 5 分钟就结束了，面完的时候，天还是依然是亮的，还得在烈日下奔波 1 小时回去。 面试五分钟，骑车两小时。 你看，张三因面试没准备好，吹空调的时间只有 5 分钟，来回路上花了 2 小时晒太阳，你说惨不惨？ 所以啊，
共享内存
linkfunlee的专栏
10-21 111
https://blog.csdn.net/qq_27664167/article/details/81277096
linux 进程间通过socket进行匿名内存共享
SecularBird的专栏
10-11 476
linux进程间通信的时候，需要使用共享内存进行数据的交换共享内存在两个进程间共享的方式可以通过这里介绍的就是3方式进行共享内存在进程间的句柄共享。
学习嵌入式第二十九天
m0_71234514的博客
08-21 802
IPv6是较新的版本，由128位二进制数组成，以冒号分隔的十六进制表示，如2001:0db8:85a3:0000:0000:8a2e:0370:7334。IP地址（Internet Protocol Address）是互联网协议地址，它是分配给网络中每个设备的唯一标识符，用于在互联网上进行通信。：最后，当所有进程都不再需要共享内存时，创建共享内存的进程或拥有足够权限的进程可以删除共享内存段，释放资源。：也称为公网地址，是分配给互联网上可访问的设备的IP地址，它们是唯一的，可以在全球范围内被识别。
linux共享内存队列,linux下消息队列和共享内存示例
weixin_29944883的博客
05-02 160
1.[代码][C/C++/Objective-C]代码#include #include #include #include #include #include #include void msg_show_attr(int msg_id, struct msqid_ds msg_info){int ret = -1;sleep(1);ret = msgctl(msg_id, IPC_STAT, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值