欢迎光临
我们一直在努力
当前位置：云搜网 聚合分类 正文

IPC之共享内存·即时通讯小程序（二）

2024-03-27 分类：聚合分类

上次说到，使用消息队列可以做到简易的登录、退出功能。那么，该思考一下，聊天的用户列表和聊天记录应该存在哪儿呢？当然是服务器上，那么，就需要用到共享内存了。

共享内存

  • 共享内存允许两个不相关的进程去访问同一部分逻辑内存
  • 如果需要在两个运行中的进程之间传输数据，共享内存将是一种效率极高的解决方案
  • 共享内存是由IPC为一个进程创建的一个特殊的地址范围，它将出现在进程的地址空间中。
  • 其他进程可以把同一段共享内存段“连接到”它们自己的地址空间里去。
  • 所有进程都可以访问共享内存地址，就好像它们是有malloc分配的一样
  • 如果一个进程向这段共享内存写了数据，所做的改动会立刻被有权访问同一段共享内存的其他进程看到

    共享内存函数

    共享内存涉及到的函数，与消息队列相似，如下

    shmget

       #include < sys/ipc.h>
   #include < sys/shm.h>
   int shmget(key_t key, size_t size, int shmflg);

    作用：用来创建共享内存

  • key：这个共享内存段的名字
  • size：需要共享的内存大小
  • shflg：由9个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
  • 返回值：成功-返回一个非负整数，即该段共享内存的标识码，失败-返回‘-1’

    shmat

    void *shmat(int shmid, const void *shmaddr, int shmflg);

    作用：共享内存刚被创建的时候，任何进程还都不能访问它，为了建立对这个共享内存段的访问渠道，必须由我们来把它连接到某个进程的地址空间，shmat函数就是用来完成这项工作的。

  • shmid：shmget返回的共享内存标识
  • shmaddr：把共享内存连接到当前进程去的时候准备放置它的那个地址
  • shmflg：shmflg是一组按位OR(或)在一起的标志。它的两个可能取值是SHM_RND和SHM_RDONLY
  • 返回值：成功-返回一个指针，指针指向共享内存的第一个字节；失败-返回‘-1’
    shmaddr为0，核心自动选择一个地址
    shmaddr不为０且shmflg无SHM_RND标记，则以shmaddr为连接地址。
    shmaddr不为０且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr – (shmaddr % SHMLBA)
    shmflg=SHM_RDONLY，表示连接操作用来只读共享内存
    在fork() 后，子进程继承已连接的共享内存

    shmdt

    int shmdt(const void *shmaddr);

    作用：把共享内存与当前进程脱离开

  • shmaddr：由shmat返回的地址指针
  • 成功-返回‘0’；失败-返回“-1”
  • 脱离共享内存并不等于删除它，只是当前进程不能再继续访问它

    shmctl

    int shmctl(int shmid, int cmd, struct shmid_ds *buf);

    作用：共享内存的控制函数

  • shmid：由shmget返回的共享内存标识码
  • cmd：将要采取的动作
  • buf：指向一个保存着共享内存的模式状态和访问权限的数据结构

  • 返回值：成功-‘0’；失败-‘-1’
    cmd将要采取的动作有以下三个值：

    即

    练习

    写一段测试代码练练：
    shmwrite.c

    #include < stdio.h>
#include < sys/msg.h>
#include < sys/ipc.h>
#include < sys/types.h>
int main()
{
int shmid;
char * addr;

//先检测该key的共享内存是否存在，如果存在，将原来的删除，重建
shmid = shmget(1000,0,0);
if(shmid != -1)
{
    //已经存在，删除
    shmctl(shmid,IPC_RMID,NULL);
}
shmid = shmget(1000,1024,IPC_CREAT);
if(shmid == -1)
{
    perror("error");
}
//  printf("shmid: %d\n",shmid);
//地址映射
addr = (char*)shmat(shmid,NULL,0);
strcpy(addr,"hello world!");

return 0;
}

    shmread.c

    #include < stdio.h>
#include < sys/msg.h>
#include < sys/ipc.h>
#include < sys/types.h>
int main()
{
int shmid;
char * addr = NULL;

//先检测该key的共享内存是否存在，如果存在，将原来的删除，重建
shmid = shmget(1000,0,0);
if(shmid == -1)
{
    perror("error");
}
printf("shmit: %d\n",shmid);

addr = (char*)shmat(shmid,NULL,0);
printf("%s\n",addr);
//解除映射
shmdt(&addr);

return 0;
}

    运行：

    查看ipc状态：

    即时通讯小程序

    接下来，可以继续我们的小程序了。当有用户上线的时候，每个客户端都需要更新在线用户列表，也就是说服务器收到用户登录的消息之后，需要发消息（signal,kill）给每一个在线用户，客户端在重写消息的处理函数中，进行用户列表的打印工作。
    那么，登录用户的状态信息就应该放在共享内存中，这样，服务器和客户端都可以访问。设计共享内存如下：

    假设最大连接用户数位100，可开辟一块空间，前100个单位存放每个用户的状态，后100个单位存放相应的用户信息。每当一位新用户登录时，服务器在共享内存里寻找一个空闲块（标志为0），比如找到userAddr+3的位置，将标志置为1，同时移动pUser指针，指向user3，将用户信息插入。同理，用户退出的是时候，需要将标志置为0。同时，发送信号，通知客户端读取共享内存的内容，这样客户端就能及时更新用户列表了。（由于发送信号的时候，需要遍历所有用户的id，所以可以用容器来存储用户信息）
    基于上次，具体代码如下：
    public.h:
    #ifndef _PUBLICH
    #define _PUBLICH

    #include < stdio.h>
#include < string.h>
#include < sys/types.h>
#include < sys/ipc.h>
#include < sys/msg.h>
#include < sys/shm.h>
#include < signal.h>
#include < string>
#include < map>
#include < iostream>
using namespace std;

//用户信息结构体
typedef struct user_t
{
    pid_t pid;
    char uname[10]; //后面加上用户名不重名、密码验证
}USER_T;

//登录消息结构体
typedef struct login_msg_t
{
    long type;
    USER_T user;
}LMSG_T;

//消息队列：用户登录
#define LOGIN_TYPE          1
#define EXIT_TYPE           2
#define MSG_KEY             1000
#define MSG_SIZE            sizeof(LMSG_T)-sizeof(long)

//共享内存：用户列表（空闲块：0-空闲，1-占用）
#define SHM_USER_KEY        1001
#define MAX_USER            100
#define SHM_USER_SIZE       MAX_USER + MAX_USER * sizeof(USER_T)

#define SIGNAL_USERS        34
#endif

    server.cpp:
    #include "public.h"
    int main()
    {
    int msg_id;
    int shm_id;
    LMSG_T loginMsg = {0};
    char userAddr;
    USER_T     pUser; //用户真正写入的地址
    map<int,string> userMap; //用户列表
    map<int,string>::iterator it;
    int i;

    /*1、创建消息队列：用户登录*/
msg_id = msgget(MSG_KEY,0);
if(msg_id == -1)
{
    msg_id = msgget(MSG_KEY,IPC_CREAT);
    if (msg_id == -1)
    {
        perror("server msgget");
        return -1;
    }
}

/*2、创建共享内存：用户列表*/
shm_id = shmget(SHM_USER_KEY,0,0);
if (shm_id != -1)
{//已经存在，删除
    shmctl(shm_id,IPC_RMID,NULL);
}
shm_id = shmget(SHM_USER_KEY,SHM_USER_SIZE,IPC_CREAT);
userAddr = (char *)shmat(shm_id,NULL,0);//映射
pUser = (USER_T *)(userAddr + MAX_USER);
memset(userAddr,0,SHM_USER_SIZE);//初始化

//一直监听，是否有用户上线
while (1)
{
    memset(&loginMsg,0,sizeof(LMSG_T));
    msgrcv(msg_id,&loginMsg,MSG_SIZE,0,0);  //任何消息都接收
    switch(loginMsg.type)
    {
    case LOGIN_TYPE:
        //登录
        cout<<"client "<<loginMsg.user.uname<<":"<<loginMsg.user.pid<<" is logining..."<<endl;
        //2.1 将登录信息写入共享内存(先找到空闲块)
        for (i = 0 ; i < MAX_USER ; i++)
        {
            if (*(userAddr + i) == 0)
            {
                //空闲
                break;
            }
        }
        if (i < MAX_USER)
        {
            *(userAddr + i) = 1;
            *(pUser + i) = loginMsg.user;
            userMap.insert( pair<int,string>(loginMsg.user.pid,loginMsg.user.uname) );
        }
        else
        {
            cout<<"online users are full.\n"<<endl;
            return 1;
        }
        //2.2 发消息通知所有在线用户
        for (it = userMap.begin();it != userMap.end();it++)
        {
            kill((*it).first,SIGNAL_USERS);
        }

        break;
    case EXIT_TYPE:
        //退出
        cout<<"client "<<loginMsg.user.uname<<":"<<loginMsg.user.pid<<" is exiting..."<<endl;
        for (i = 0 ; i < MAX_USER ; i++)
        {
            if ((pUser+i)->pid == loginMsg.user.pid)
            {
                *(userAddr+i) = 0;
                break;
            }
        }
        for (it = userMap.begin();it != userMap.end();it++)
        {
            if ((*it).first == loginMsg.user.pid)
            {
                continue;   //自己退出，不用再通知自己
            }
            kill((*it).first,SIGNAL_USERS);
        }
        break;
    }

}

return 0;

    }

client.cpp：
#include "public.h"

char *userAddr;
USER_T *pUser;

void PrtUserList(int sig_no)
{
    //读取共享内存里的用户列表数据
    cout<<"==== online users ===="<<endl;
    for (int i = 0 ;i < MAX_USER ; i++)
    {
        if(*(userAddr + i) == 1)
        {
            cout<<(pUser + i)->uname<<endl;
        }
    }
}

int main()
{
    char acBuf[20] = "";
    int msg_id;
    LMSG_T loginMsg = {0};
    char uname[10] = "";
    int shm_id;

    cout<<"------------onlineChat-------------"<<endl;
    cout<<"username:";
    cin>>uname;

    //2.3 注册消息（放在最前面）
    signal(SIGNAL_USERS,PrtUserList);

    /*2、打开用户列表共享内存（要比写消息队列早）*/
    shm_id = shmget(SHM_USER_KEY,0,0);
    if (shm_id == -1)
    {
        perror("client shmget");
        return -1;
    }
    userAddr = (char*)shmat(shm_id,NULL,0);
    pUser = (USER_T*)(userAddr + MAX_USER);

    /*1、打开消息队列*/
    msg_id = msgget(MSG_KEY,0);
    if(msg_id == -1)
    {
        perror("client msgget");
        return -1;
    }
    //登录，写消息队列
    loginMsg.type = LOGIN_TYPE;     //设置登录的消息类型为1
    loginMsg.user.pid = getpid();
    memcpy(loginMsg.user.uname,uname,strlen(uname));
    cout<<loginMsg.user.uname<<" is logining..."<<endl;
    msgsnd(msg_id,&loginMsg,MSG_SIZE,0);

    //等待写
    while(1)
    {
        putchar('#');
        fflush(stdout);
        scanf("%s",acBuf);
        if (strcmp(acBuf,"exit") == 0)
        {
            cout<<loginMsg.user.uname<<" is exiting..."<<endl;
            break;
        }
    }

    loginMsg.type = EXIT_TYPE;      //设置退出的消息类型为2
    msgsnd(msg_id,&loginMsg,MSG_SIZE,0);

    return 0;
}

运行结果：
首先运行服务器，然后登陆Julia，再登陆Tomy，再退出Tomy。

至此，可以进行聊天的功能设计了，聊天内容同样存储在共享内存。由于私聊和群聊的功能，我们需要获取在线用户列表，所以同样，客户端也需要一个容器来暂时存储用户信息。（list也可以，直接存放用户结构体）
代码如下：
public.h
#ifndef _PUBLICH
#define _PUBLICH

    #include < stdio.h>
    #include < string.h>
    #include < sys/types.h>
    #include < sys/ipc.h>
    #include < sys/msg.h>
    #include < sys/shm.h>
    #include < signal.h>
    #include < string>
    #include < map>
    #include < iostream>
    using namespace std;

    //用户信息结构体
    typedef struct user_t
    {
        pid_t pid;
        char uname[10]; //后面加上用户名不重名、密码验证
    }USER_T;

    //登录消息队列结构体
    typedef struct login_msg_t
    {
        long type;
        USER_T user;
    }LMSG_T;

    //聊天消息结构体
    typedef struct msg_t
    {
        USER_T user;
        char acMsg[100];
    }MSG_T;

    //消息队列：用户登录
    #define LOGIN_TYPE          1
    #define EXIT_TYPE           2
    #define MSG_KEY             1000
    #define MSG_SIZE            sizeof(LMSG_T)-sizeof(long)

    //共享内存：用户列表（空闲块：0-空闲，1-占用）
    #define SHM_USER_KEY        1001
    #define MAX_USER            100
    #define SHM_USER_SIZE       MAX_USER + MAX_USER * sizeof(USER_T)

    //共享内存：聊天内容
    #define SHM_MSG_KEY         1002
    #define SHM_MSG_SIZE        sizeof(MSG_T)

    //信号：更新用户列表，读消息
    #define SIGNAL_USERS        34
    #define SIGNAL_CHAT         35

    #endif

server.cpp
服务器这边只需要再开一块共享内存就可以了

/*3、创建共享内存：聊天信息*/
int shm_msg_id = shmget(SHM_MSG_KEY,0,0);
if (shm_msg_id != -1)
{
    shmctl(shm_msg_id,IPC_RMID,NULL);
}
shm_msg_id = shmget(SHM_MSG_KEY,SHM_MSG_SIZE,IPC_CREAT);
char *msgAddr = (char *)shmat(shm_msg_id,NULL,0);
memset(msgAddr,0,SHM_MSG_SIZE);

client.cpp

#include "public.h"

char *userAddr;
USER_T *pUser;

char *msgAddr;
MSG_T *pMsg;

map<int,string> userMap;    //用户列表
map<int,string>::iterator it;

void PrtUserList(int sig_no)
{
    //读取共享内存里的用户列表数据
    userMap.clear();
    cout<<"==== online users ===="<<endl;
    for (int i = 0 ;i < MAX_USER ; i++)
    {
        if(*(userAddr + i) == 1)
        {
            cout<<(pUser + i)->uname<<endl;
            userMap.insert(pair<int,string>( (pUser+i)->pid, (pUser+i)->uname ));
        }
    }
}

void GetChatMsg(int sig_no)
{
    //读取共享内存里的聊天内容
    MSG_T msg = {0};
    msg = *pMsg;
    cout<<"receive msg from "<<msg.user.uname<<" : "<<msg.acMsg<<endl;
}

int main()
{
    char acOrder[20] = "";
    int msg_id;
    LMSG_T loginMsg = {0};
    char uname[10] = "";
    int shm_id;
    char toWho[10] = "";    //聊天对象
    MSG_T msg = {0};    //聊天消息结构体
    char acMsg[100] = "";   //聊天内容

    cout<<"------------onlineChat-------------"<<endl;
    cout<<"username:";
    cin>>uname;

    //2.3 注册消息（放在最前面）
    signal(SIGNAL_USERS,PrtUserList);
    signal(SIGNAL_CHAT,GetChatMsg);

    /*2、打开用户列表共享内存（要比写消息队列早）*/
    shm_id = shmget(SHM_USER_KEY,0,0);
    if (shm_id == -1)
    {
        perror("client userlist shmget");
        return -1;
    }
    userAddr = (char*)shmat(shm_id,NULL,0);
    pUser = (USER_T*)(userAddr + MAX_USER);

    /*3、打开聊天信息共享内存*/
    int shm_msg_id = shmget(SHM_MSG_KEY,0,0);
    if (shm_msg_id == -1)
    {
        perror("client chatmsg shmget");
        return -1;
    }
    msgAddr = (char *)shmat(shm_msg_id,NULL,0);
    pMsg = (MSG_T *)msgAddr;

    /*1、打开消息队列*/
    msg_id = msgget(MSG_KEY,0);
    if(msg_id == -1)
    {
        perror("client msgget");
        return -1;
    }
    //登录，写消息队列
    loginMsg.type = LOGIN_TYPE;     //设置登录的消息类型为1
    loginMsg.user.pid = getpid();
    memcpy(loginMsg.user.uname,uname,strlen(uname));
    cout<<loginMsg.user.uname<<" is logining..."<<endl;
    msgsnd(msg_id,&loginMsg,MSG_SIZE,0);

    //等待写
    while(1)
    {
        putchar('#');
        fflush(stdout);
        scanf("%s",acOrder);
        if (strcmp(acOrder,"exit") == 0)    //退出
        {
            cout<<loginMsg.user.uname<<" is exiting..."<<endl;
            loginMsg.type = EXIT_TYPE;      //设置退出的消息类型为2
            msgsnd(msg_id,&loginMsg,MSG_SIZE,0);
            break;
        }
        else if (strcmp(acOrder,"users") == 0)  //查看在线用户列表
        {
            kill(getpid(),SIGNAL_USERS);
        }
        else if (strcmp(acOrder,"chat") == 0)   //进入聊天模式
        {
            cout<<"to who: ";
            cin>>toWho;
            cout<<"say: ";
            memset(acMsg,0,100);
            cin>>acMsg;

            // 3.1 把聊天内容写进共享内存
            memcpy(msg.acMsg,acMsg,strlen(acMsg));
            msg.user = loginMsg.user;
            memcpy(msgAddr,&msg,SHM_MSG_SIZE);

            if (strcmp(toWho,"all") == 0)   //群聊
            {
                //通知所有人去读
                for (it = userMap.begin();it != userMap.end();it++)
                {
                    if ((*it).first != getpid())
                    {
                        kill((*it).first,SIGNAL_CHAT);
                    }
                }
            }
            else    //私聊
            {
                for (it = userMap.begin();it != userMap.end();it++)
                {
                    if (strcmp((*it).second.c_str() , toWho) == 0)
                    {
                        kill((*it).first,SIGNAL_CHAT);
                        break;
                    }
                }
            }
        }
        memset(acOrder,0,sizeof(acOrder));
    }

    //解除映射
    shmdt(&userAddr);
    shmdt(&msgAddr);

    return 0;
}

运行结果：

那么，共享内存里开辟一块空间用来存储一条聊天记录的话，考虑并发的问题，如果消息发送的太快，还来不及读取，那么消息就会被覆盖。如图：让读取消息的函数sleep一下，连续发送两条消息，结果第一条消息的内容会被覆盖。这是我们不想看到的。

所以，又需要用到信号量的知识了，下次复习（先写着聊天试试）~

赞(0)
【声明】：本博客不参与任何交易，也非中介，仅记录个人感兴趣的主机测评结果和优惠活动，内容均不作直接、间接、法定、约定的保证。访问本博客请务必遵守有关互联网的相关法律、规定与规则。一旦您访问本博客，即表示您已经知晓并接受了此声明通告。
分享到

相关推荐

热门推荐

分类目录

香港VPS 欧洲VPS 日本VPS 印尼VPS 外贸VPS 美国VPS 迪拜VPS 德国VPS 韩国VPS 便宜VPS 英国VPS 荷兰VPS 南非VPS 印度VPS 越南VPS 法国VPS 埃及VPS 巴林VPS 波兰VPS 巴西VPS 台湾VPS 纽约VPS 高防VPS 西雅图VPS 圣何塞VPS 芝加哥VPS 达拉斯VPS 土耳其VPS 新加坡VPS 菲律宾VPS 俄罗斯VPS 柬埔寨VPS 搬瓦工VPS 大硬盘VPS 卢森堡VPS 孟加拉国VPS 澳大利亚VPS 保加利亚VPS 马来西亚VPS 印度尼西亚VPS 沙特阿拉伯VPS CDN 高防CDN 云服务器 香港服务器 日本服务器 欧洲服务器 美国服务器 德国服务器 韩国服务器 英国服务器 荷兰服务器 南非服务器 外贸服务器 印度服务器 非洲服务器 站群服务器 越南服务器 台湾服务器 高防服务器 新加坡服务器 菲律宾服务器 俄罗斯服务器