用nanomsg中的PUBSUB(发布、订阅)模式实现线程、进程间的消息互相传递

最新推荐文章于 2024-07-25 00:20:00 发布
最新推荐文章于 2024-07-25 00:20:00 发布
阅读量3.2k 收藏 13
点赞数
分类专栏： C语言 nanomsg 文章标签： 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43701705/article/details/110238092
版权

不知道函数怎么用的看这篇函数说明

首先了解一下nanomsg的PUBSUB模式的原理

img
这个只能单方向从server发消息给client。

但是如果想要实现 进程与进程之间、进程与线程之间、线程与线程之间消息的互相传递，也是可以的，我个人进行如下的设计。

在这里插入图片描述
就像上面这样，每个 线程/进程 都新建两个线程，一个用来订阅接收，另一个用来发布。当然如果只需要接收不需要发布也可以不创建多个线程。

下面来写一个demo，demo功能如下

进程一 开三个线程 A B C
A线程开两个子线程，发布线程绑定一个本地地址和一个进程地址，并且会发布 05 10 的内容，订阅线程订阅 05 10 03 内容。
B线程开两个子线程，发布线程绑定一个自己的地址，发布 03 的内容，订阅线程订阅 05 的内容。
C线程只是订阅 10 的内容。

进程二 连接进程一中线程A绑定的进程地址，并且订阅 10 内容。

说明：
–> 05 和 10 的内容为线程一的A进程发布的消息，消息格式为当前时间，
–> 05 的消息是当前时间为5s的倍数且不为10s的倍数时发送消息
–> 10 的消息是当前时间为10s的倍数时发送消息
–> 03 的消息是当前时间为3s的倍数并且不为6的倍数时发送消息

代码步骤和说明都直接写在代码注释里

直接上代码：

进程一

//进程一 文件pubsub.c
#include <assert.h>
#include <nanomsg/nn.h>
#include <nanomsg/pubsub.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>

#define SOCKET_ADDRESS_A "inproc://A" //线程A的消息队列的地址
#define SOCKET_ADDRESS_B "inproc://B" //线程B的消息队列的地址
#define SOCKET_ADDRESS_IPC_A "ipc:///tmp/a.ipc" //用于进程间通讯的消息队列的地址
#define SOCKET_ADDRESS_C "inproc://c" //线程C的消息队列的地址，这里没有用到

//线程A用于发布消息的线程
void* A_pub_thread(void* arg){
    time_t now; //获取本地时间（描数）
    int flag = 0; 
    struct tm* p;
    char msg[100]; //发送消息的长度
    int rc = 0;	//
    int ret = 0;
    int sock_pub = nn_socket(AF_SP, NN_PUB); //创建一个套接字模式为发布套接字
    assert(sock_pub >= 0); //确保创建成功
    //绑定本地地址
    assert(nn_bind(sock_pub, SOCKET_ADDRESS_A) >= 0);//绑定本地消息队列的地址
    assert(nn_bind(sock_pub, SOCKET_ADDRESS_IPC_A) >= 0);//绑定用于进程间消息接收的消息队列的地址
    //pub使用来发送的
    while (1) {
        now = time(NULL); //获取本地时间
        rc = 0;
        ret = 0;
        //如果满足 10 的发送条件
        if ((now % 10 == 0) && (flag == 0)) {
            flag = 1;
            p = gmtime(&now);
            memset(&msg, 0, sizeof(msg)); //清空发送缓存
            sprintf(msg, "10|%04d-%02d-%02d %02d:%02d:%02d from A", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
            //将发送字符串写入缓存，注意格式必须是 类型|内容 这里的类型就是10 内容就是当前时间 +from A
            ret = nn_send(sock_pub, msg, sizeof(msg), NN_DONTWAIT);//发送消息
            //判断消息是否发送成功
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }
        }
        //如果满足 05 的发送条件
        if ((now % 5 == 0) && (now % 10 != 0) && (flag == 1)) {
            //和上面一样，注释就不写了
            flag = 0;
            p = gmtime(&now);
            memset(&msg, 0, sizeof(msg));
            sprintf(msg, "05|%04d-%02d-%02d %02d:%02d:%02d from A", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
            ret = nn_send(sock_pub, msg, sizeof(msg), NN_DONTWAIT);
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }
        }
        //一秒循环一次
        sleep(1);
    }
}

//线程A用于订阅消息的线程
void* A_sub_thread(void* arg){
    time_t now; //用于获取当前时间
    int flag = 0;
    struct tm* p; //时间结构体
    char rcvmsg[100]; //用于接收消息
    int rc = 0; //判断接收长度
    int sock_sub = nn_socket(AF_SP, NN_SUB); //创建用于接收消息的套接字
    assert(sock_sub >= 0);//确保创建套接字成功
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_A) >= 0);//连接要接收消息的地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_B) >= 0);//可以同时连接多个
    //sub是用来订阅的
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "05", 2);//订阅 05 的消息（包括两上面连接的容器的消息）
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "10", 2);//订阅 10 的消息（包括两上面连接的容器的消息）
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "03", 2);//订阅 03 的消息（包括两上面连接的容器的消息）
    //pub使用来发送的
    while (1) {
        // 清空缓存
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        //接收消息 第四个参数为0时表示租售接收
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        if (rc > 0) {
            printf("A sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, NN_MSG, NN_DONTWAIT);
        }
    }
}

//线程A
void* A_thread(void* arg){
    pthread_t thread_A_1, thread_A_2;

    pthread_create(&thread_A_1, NULL, A_pub_thread, NULL);
    pthread_create(&thread_A_2, NULL, A_sub_thread, NULL);

    pthread_join(thread_A_1, NULL);
    pthread_join(thread_A_2, NULL);
}

void* B_pub_thread(void* arg){
    time_t now;
    int flag = 0;
    struct tm* p;
    char msg[100];
    int rc = 0;
    int ret = 0;
    int sock_pub = nn_socket(AF_SP, NN_PUB);
    assert(sock_pub >= 0);
    //绑定本地地址
    assert(nn_bind(sock_pub, SOCKET_ADDRESS_B) >= 0);
    //pub使用来发送的
    while (1) {
        now = time(NULL);
        rc = 0;
        ret = 0;
        if ((now % 3 == 0) && (now % 2 != 0) && (flag == 0)) {
            flag = 1;
            p = gmtime(&now);
            memset(&msg, 0, sizeof(msg));
            sprintf(msg, "03|%04d-%02d-%02d %02d:%02d:%02d from B", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
            ret = nn_send(sock_pub, msg, sizeof(msg), NN_DONTWAIT);
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }
        }
        if ((now % 2 == 0) && (flag == 1)){
            flag = 0;
        }
        sleep(1);
    }
}

void* B_sub_thread(void* arg){
    time_t now;
    int flag = 0;
    struct tm* p;
    char msg[100];
    char rcvmsg[100];
    int rc = 0;
    int ret = 0;
    int sock_sub = nn_socket(AF_SP, NN_SUB);
    assert(sock_sub >= 0);
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_A) >= 0);
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_B) >= 0);
    //sub是用来订阅的
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "03", 2);
    while (1) {
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        if (rc > 0) {
            printf("B sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, NN_MSG, NN_DONTWAIT);
        }
    }
}

void* B_thread(void* arg){
    pthread_t thread_B_1, thread_B_2;

    pthread_create(&thread_B_1, NULL, B_pub_thread, NULL);
    pthread_create(&thread_B_2, NULL, B_sub_thread, NULL);

    pthread_join(thread_B_1, NULL);
    pthread_join(thread_B_2, NULL);
}

void* C_thread(void* arg){
    int flag = 0;
    struct tm* p;
    char rcvmsg[100];
    int rc = 0;
    int ret = 0;
    int sock_sub = nn_socket(AF_SP, NN_SUB);
    assert(sock_sub >= 0);
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_A) >= 0);
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "10", 2);
    while (1) {
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        while (rc > 0) {
            printf("C sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), NN_DONTWAIT);
        }
    }
}

int main(int argc, char** argv)
{
    pthread_t thread_A, thread_B, thread_C;

    pthread_create(&thread_A, NULL, A_thread, NULL);
    pthread_create(&thread_B, NULL, B_thread, NULL);
    pthread_create(&thread_C, NULL, C_thread, NULL);

    pthread_join(thread_A, NULL);
    pthread_join(thread_B, NULL);
    pthread_join(thread_C, NULL);

    exit(EXIT_SUCCESS);
}

进程二代码

//进程二
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <assert.h>
#include <unistd.h>

#define SOCKET_ADDRESS_IPC_A "ipc:///tmp/a.ipc"


int main(){
    time_t now;
    int flag = 0;
    struct tm* p;
    char rcvmsg[100];
    int rc = 0;
    int sock_sub = nn_socket(AF_SP, NN_SUB);
    assert(sock_sub >= 0);
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_IPC_DASS) >= 0);
    //sub是用来订阅和接收的
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "10", 2);
    while (1) {
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        while (rc > 0) {
            printf("2 sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), NN_DONTWAIT);
        }
    }
    return 0;
}

编译

gcc pubsub.c -o pubsub_1 -lnanomsg -lpthread
gcc pubsub_2.c -o pubsub_2 -lnanomsg

运行结果

在这里插入图片描述

C++高性能编程：使用 Nanomsg 实现基于共享内存的发布-订阅模型
Where there is life, there is hope.
08-06 1818
Nanomsg在发送消息的时候足够高效，但是发送文件或者图片的时候实时性却不够好。 文件将介绍如何基于Nanomsg框架 实现一个基于共享内存的发布-订阅模型。
C++编程: 使用 Nanomsg 进行 PUB-SUB 模式基准测试
最新发布
Where there is life, there is hope.
07-27 1237
Nanomsg 作为一款高性能的通信库，支持多种消息传递模式，其中包括 PUB-SUB（发布-订阅）。 本篇文章将介绍如何使用 NanoMsg 库来实现一个简单的 PUB-SUB 模式的基准测试程序，该程序能够测量消息从发布到订阅的平均延迟。
nanomsg的pub/sub模式用法
热门推荐
songtzu的专栏
04-13 1万+
作为一个MQ，pub/sub是非常常见的一个用法，nanomsg作为ZMQ的继任，很少有博客讲述nanomsg的订阅/发布模式。 官方DEMO #include #include #include #include #include #define SERVER "server" #define CLIENT "client" char *date () { time
nanomsg代码示例
07-25
├── bus.sh ├── LICENSE ├── Makefile ├── pair.sh ├── pipeline.sh ├── pubsub.sh ├── README.md ├── reqrep.sh ├── src │   ├── bus.c │   ├── common.h │   ├── pair.c │   ├── pipeline.c │   ├── pubsub.c │   ├── reqrep.c │   └── survey.c └── survey.sh
nanomsg实验——pubsub
weixin_34261415的博客
03-24 959
nanomsg实验——pubsub 发布订阅模式是很多消息中间件提供的常见功能。通过消息机制，能够将消息发布者和消息接收（消费）者 进行解耦。pubsub模式也是nanomsg直接支持的一直消息模型之一，因此通过pubsub模式实验， 同时也大致了解了下nanomsg的基础用法。 服务端 #include <stdio.h> #includ...
nanomsg(4) :pub/sub 模式
Mr.Sugarcane
08-31 772
nanomsg(4) :pub/sub 模式。
进程间的发布订阅
jisuanji_qinbuyi的博客
07-14 955
1.进程间通信，首先选择通信方式，根据发布订阅模型应该知道会较大数据量交互，所以一般选用socket通信。2.进程a为发布端，进程b为订阅端，b进程关心a进程中一些数据，所以a进程数据变化的时候，需要通告到b进程中，而不是a进程中所有的数据，b进程都会关心，所以需要b进程先向a进程订阅关键数据和b进程标识（统一规定）。3.进程间模块是异步的，所以b进程订阅a进程数据的，需要注册自己响应回调，关心a...
nanomsg新版发布：分布式系统通信协议增强
- PUBSUB模式：发布-订阅模式允许消息发布者向订阅者分发消息。这种模式适用于主题或分类消息的广播，特别适合于事件驱动架构中。 - PIPELINE模式：通过汇总来自多个来源的消息，并将它们在多个目的点之间进行负载...
【nanomsg在边缘计算中的角色】：优化策略与应用
本论文首先介绍了nanomsg边缘计算的基础知识和其核心特性，包括其架构概览、消息模式、传输协议、核心组件和异步I/O处理。接着，文章深入探讨了nanomsg在边缘计算中的应用和优化策略，关注于降低延
【nanomsg架构深入解析】：构建高性能通信系统的基石
本文系统地介绍了nanomsg的各个方面，包括基本概念、特点、传输协议及架构设计、编程实践、在高性能通信系统中的应用，以及性能优化和问题处理。nanomsg以其轻量级、高性能和易用性在分布式和实时通信系统中表现突出...
Nanomsg 代码分析
07-25
目录 一、nanomsg 简单介绍 1 1.1、概述 1 1.2、信息发送模式 2 1.3、网络通信协议 4 1.4、对外暴露的接口api 4 二、nanomsg 模块分析 5 2.1、接口 7 2.2、各大模块分析 7 2.2.1、utils 7 2.2.1、transports 8 2.2.1、protocols 8 2.2.1、core 9 2.2.1、aio 10 2.2.1、device 11 三、数据结构分析 11 四、模块状态分析 13 五、测试用例 15 六、代码详细分析 19 七、简单的个人感想 19 八、参考 20
nanomsg-req-rep流程源码分析.docx
07-20
nanomsg是一个开源的实现了几种“可扩展协议”的高性能通信库，本文针对请求/回复模式进行了简单的源码分析，包括请求的时序图，socket消息槽等
cpp-nanomsg一个简单的高性能实现多个可伸缩性协议
08-15
nanomsg - 一个简单的高性能实现多个“可伸缩性协议”
Nanomsg是现代消息传递库，它是ZeroMQ的后继者-Rust开发
05-27
Nanomsg文档Nanomsg是现代消息传递库，它是MartinSustrik及其同事用C语言编写的ZeroMQ的后继程序。 nanoms Nanomsg文档Nanomsg是现代消息传递库，它是ZeroMQ的后继程序，由Martin Sustrik及其同事用C语言编写。 nanomsg库已获得MIT / X11许可。 “ nanomsg”是250bpm sro的商标http://nanomsg.org/ https://github.com/nanomsg/nanomsg要求Nanomsg 1.1.4安装nanomsg：make deps安装[依赖项] nanomsg =“ 0.7.2”导入板条箱以使用它：extern crate nanomsg; 创建一个套接字
Linux nanomsg tcp sub pub
David_BY的博客
09-14 865
nanomsg例子，通讯封装ros sub pub模式
C++编程： 开源库Nanomsg和Iceoryx发布订阅模式的性能对比
Where there is life, there is hope.
07-25 1835
在实时通信系统中，选择合适的中间件对于确保数据传输的效率和可靠性至关重要。 本文通过对比 Nanomsg 和 Iceoryx 两种中间件在发布-订阅模式中的实现和性能表现，探索如何优化消息传递系统，并提供详细的测试代码和用例。通过实际代码实现和详细的性能测试，可以得到 Iceoryx 在实时系统中的优势。对于需要高性能和低延迟的实时通信系统，Iceoryx 是一个更好的选择。
七、Redis的发布订阅
CoderJay
04-05 231
1 是什么？ 进程间的一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。 订阅/发布消息图 2 命令 3 案列 先订阅后发布后才能收到消息， 可以一次性订阅多个，SUBSCRIBE c1 c2 c3 消息发布，PUBLISH c2 hello-redis 订阅多个，通配符*， PSUBSCRIBE new* 收取消息， PUBLISH new1 redis2015 ...
linux发布订阅通讯方式,Linux下进程间通讯方式 - UNIX Domain Socket
weixin_31703753的博客
05-15 399
概述Linux下进程通讯方式有很多,比较典型的有套接字,平时比较常用的套接字是基于TCP/IP协议的,适用于两台不同主机上两个进程间通信, 通信之前需要指定IP地址. 但是如果同一台主机上两个进程间通信用套接字,还需要指定ip地址,有点过于繁琐. 这个时候就需要用到UNIX Domain Socket, 简称UDS,UDS的优势:UDS传输不需要经过网络协议栈,不需要打包拆包等操作,只是数据的拷贝...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值