基于nanomsg的进程间通信示例教程

最新推荐文章于 2024-05-30 09:31:53 发布
最新推荐文章于 2024-05-30 09:31:53 发布
阅读量1.9k 收藏 3
点赞数
文章标签： c/c++ python
原文链接：https://my.oschina.net/u/3346994/blog/861592
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

nanomsg是zeromq作者重新用C语言写的消息队列：http://nanomsg.org/index.html

它提供了6种通信模式，也即所谓“扩展性协议”（运行在传输层之上）——包括一对一（pair）、多对多（bus）、发布者-订阅者（pubsub）、调查者（survey）、管道（pipeline）、请求-响应（reqrep）。

本示例提供单机进程间通信运行环境作为传输层，参考教程：http://tim.dysinger.net/posts/2013-09-16-getting-started-with-nanomsg.html。由于作者有点懒，我把代码改成能够在Linux上运行的：https://github.com/begeekmyfriend/nanomsg-tutorial
标签： <无>
代码片段(5) [全屏查看所有代码]
1. [文件] pair.c ~ 2KB     下载(13)     

#include "common.h"
#include <nanomsg/pair.h>
 
#define NODE0 "node0"
#define NODE1 "node1"
#define SOCKET_ADDR "ipc:///tmp/pair.ipc"
 
int send_name(int sock, const char *name)
{
        printf("%s: SENDING \"%s\"\n", name, name);
        int sz_n = strlen(name) + 1;
        return nn_send(sock, name, sz_n, 0);
}
 
int recv_name(int sock, const char *name)
{
        char *buf = NULL;
        int result = nn_recv(sock, &buf, NN_MSG, 0);
        if (result > 0)
        {
                printf("%s: RECEIVED \"%s\"\n", name, buf);
                nn_freemsg(buf);
        }
        return result;
}
 
int send_recv(int sock, const char *name)
{
        int to = 100;
        assert(nn_setsockopt (sock, NN_SOL_SOCKET, NN_RCVTIMEO, &to, sizeof (to)) >= 0);
        while(1)
        {
                recv_name(sock, name);
                sleep(1);
                send_name(sock, name);
        }
}
 
int node0(const char *url)
{
        int sock = nn_socket(AF_SP, NN_PAIR);
        assert(sock >= 0);
        assert(nn_bind (sock, url) >= 0);
        send_recv(sock, NODE0);
        return nn_shutdown (sock, 0);
}
 
int node1(const char *url)
{
        int sock = nn_socket(AF_SP, NN_PAIR);
        assert(sock >= 0);
        assert(nn_connect(sock, url) >= 0);
        send_recv(sock, NODE1);
        return nn_shutdown (sock, 0);
}
 
int main(int argc, char **argv)
{
        if (argc == 2 && strncmp(NODE0, argv[1], strlen(NODE0)) == 0) {
                return node0(SOCKET_ADDR);
        } else if (argc == 2 && strncmp (NODE1, argv[1], strlen (NODE1)) == 0) {
                return node1(SOCKET_ADDR);
        } else {
                fprintf (stderr, "Usage: pair %s|%s <ARG> ...\n", NODE0, NODE1);
                return 1;
        }
}
2. [文件] pubsub.c ~ 2KB     

#include "common.h"
#include <nanomsg/pubsub.h>
 
#define SERVER "server"
#define CLIENT "client"
#define SOCKET_ADDR "ipc:///tmp/pubsub.ipc"
 
char *date(void)
{
        time_t raw = time(&raw);
        struct tm *info = localtime(&raw);
        char *text = asctime(info);
        text[strlen(text) - 1] = '\0';
        return text;
}
 
int server(const char *url)
{
        int sock = nn_socket(AF_SP, NN_PUB);
        assert(sock >= 0);
        assert(nn_bind (sock, url) >= 0);
 
        while (1)
        {
                char *d = date();
                int sz_d = strlen(d) + 1; // '\0' too
                printf("SERVER: PUBLISHING DATE %s\n", d);
                int bytes = nn_send(sock, d, sz_d, 0);
                assert(bytes == sz_d);
                sleep(1);
        }
 
        return nn_shutdown(sock, 0);
}
 
int client(const char *url, const char *name)
{
        int sock = nn_socket (AF_SP, NN_SUB);
 
        assert(sock >= 0);
        /* TODO learn more about publishing/subscribe keys */
        assert(nn_setsockopt (sock, NN_SUB, NN_SUB_SUBSCRIBE, "", 0) >= 0);
        assert(nn_connect (sock, url) >= 0);
 
        while (1)
        {
                char *buf = NULL;
                int bytes = nn_recv(sock, &buf, NN_MSG, 0);
                assert(bytes >= 0);
                printf("CLIENT (%s): RECEIVED %s\n", name, buf);
                nn_freemsg(buf);
        }
 
        return nn_shutdown(sock, 0);
}
 
int main(const int argc, const char **argv)
{
        if (argc == 2 && strncmp(SERVER, argv[1], strlen(SERVER)) == 0) {
                return server(SOCKET_ADDR);
        } else if (argc == 3 && strncmp (CLIENT, argv[1], strlen (CLIENT)) == 0) {
                return client(SOCKET_ADDR, argv[2]);
        } else {
                fprintf(stderr, "Usage: pubsub %s|%s <ARG> ...\n", SERVER, CLIENT);
                return 1;
        }
}
3. [文件] reqrep.c ~ 2KB   
#include "common.h"
#include <nanomsg/reqrep.h>
 
#define NODE0 "node0"
#define NODE1 "node1"
#define DATE "DATE"
#define SOCKET_ADDR "ipc:///tmp/reqrep.ipc"
 
char *date(void)
{
        time_t raw = time(&raw);
        struct tm *info = localtime(&raw);
        char *text = asctime(info);
 
        text[strlen(text) - 1] = '\0';
 
        return text;
}
 
int node0(const char *url)
{
        int sz_date = strlen(DATE) + 1;
        int sock = nn_socket(AF_SP, NN_REP);
 
        assert(sock >= 0);
        assert(nn_bind(sock, url) >= 0);
 
        while (1) {
                char *buf = NULL;
                int bytes = nn_recv(sock, &buf, NN_MSG, 0);
 
                assert(bytes >= 0);
                if (strncmp(DATE, buf, sz_date) == 0) {
                        printf("NODE0: RECEIVED DATE REQUEST\n");
                        char *d = date();
                        int sz_d = strlen(d) + 1;
                        printf("NODE0: SENDING DATE %s\n", d);
                        bytes = nn_send(sock, d, sz_d, 0);
                        assert(bytes == sz_d);
                }
                nn_freemsg (buf);
        }
 
        return nn_shutdown (sock, 0);
}
 
int node1(const char *url)
{
        int sz_date = strlen(DATE) + 1;
        char *buf = NULL;
        int bytes = -1;
        int sock = nn_socket(AF_SP, NN_REQ);
 
        assert(sock >= 0);
        assert(nn_connect(sock, url) >= 0);
 
        /* Send */
        printf("NODE1: SENDING DATE REQUEST %s\n", DATE);
        bytes = nn_send (sock, DATE, sz_date, 0);
        assert(bytes == sz_date);
 
        /* Receive */
        bytes = nn_recv (sock, &buf, NN_MSG, 0);
        assert(bytes >= 0);
        printf("NODE1: RECEIVED DATE %s\n", buf);
        nn_freemsg(buf);
 
        return nn_shutdown (sock, 0);
}
 
int main (int argc, char **argv)
{
        if (argc == 2 && strncmp(NODE0, argv[1], strlen(NODE0)) == 0) {
                return node0(SOCKET_ADDR);
        } else if (argc == 2 && strncmp(NODE1, argv[1], strlen(NODE1)) == 0) {
                return node1(SOCKET_ADDR);
        } else {
                fprintf (stderr, "Usage: reqrep %s|%s <ARG> ...\n", NODE0, NODE1);
                return 1;
        }
}
4. [文件] survey.c ~ 2KB        

#include "common.h"
#include <nanomsg/survey.h>
 
#define SERVER "server"
#define CLIENT "client"
#define DATE   "DATE"
#define SOCKET_ADDR "ipc:///tmp/survey.ipc"
 
char *date(void)
{
        time_t raw = time (&raw);
        struct tm *info = localtime (&raw);
        char *text = asctime (info);
        text[strlen(text)-1] = '\0';
        return text;
}
 
int server(const char *url)
{
        int sock = nn_socket(AF_SP, NN_SURVEYOR);
 
        assert(sock >= 0);
        assert(nn_bind(sock, url) >= 0);
        sleep(1); /* wait for connections */
 
        /* Send */
        printf("SERVER: SENDING DATE SURVEY REQUEST\n");
        int sz_d = strlen(DATE) + 1;
        int bytes = nn_send(sock, DATE, sz_d, 0);
        assert (bytes == sz_d);
 
        while (1) {
                /* Receive */
                char *buf = NULL;
                bytes = nn_recv(sock, &buf, NN_MSG, 0);
                if (bytes == ETIMEDOUT) {
                        break;
                }
                if (bytes >= 0) {
                        printf("SERVER: RECEIVED \"%s\" SURVEY RESPONSE\n", buf);
                        nn_freemsg (buf);
                }
        }
 
        return nn_shutdown(sock, 0);
}
 
int client(const char *url, const char *name)
{
        int sock = nn_socket(AF_SP, NN_RESPONDENT);
 
        assert(sock >= 0);
        assert(nn_connect(sock, url) >= 0);
        while (1) {
                char *buf = NULL;
                int bytes = nn_recv(sock, &buf, NN_MSG, 0);
                if (bytes >= 0) {
                        printf("CLIENT (%s): RECEIVED \"%s\" SURVEY REQUEST\n", name, buf);
                        nn_freemsg(buf);
                        char *d = date();
                        int sz_d = strlen(d) + 1; // '\0' too
                        printf("CLIENT (%s): SENDING DATE SURVEY RESPONSE\n", name);
                        int bytes = nn_send (sock, d, sz_d, 0);
                        assert(bytes == sz_d);
                }
        }
 
        return nn_shutdown(sock, 0);
}
 
int main(int argc, char **argv)
{
        if (argc == 2 && strncmp(SERVER, argv[1], strlen(SERVER)) == 0) {
                return server (SOCKET_ADDR);
        } else if (argc == 3 && strncmp(CLIENT, argv[1], strlen(CLIENT)) == 0) {
                return client (SOCKET_ADDR, argv[2]);
        } else {
                fprintf(stderr, "Usage: survey %s|%s <ARG> ...\n", SERVER, CLIENT);
                return 1;
        }
}
5. [文件] bus.c ~ 3KB     下载(10) 

#include "common.h"
#include <nanomsg/bus.h>
 
#define NODE0_SOCKET_ADDR "ipc:///tmp/node0.ipc"
#define NODE1_SOCKET_ADDR "ipc:///tmp/node1.ipc"
#define NODE2_SOCKET_ADDR "ipc:///tmp/node2.ipc"
#define NODE3_SOCKET_ADDR "ipc:///tmp/node3.ipc"
 
int node0(void)
{
        int sock = nn_socket(AF_SP, NN_BUS);
 
        assert(sock >= 0);
        assert(nn_bind(sock, NODE0_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        assert(nn_connect(sock, NODE1_SOCKET_ADDR) >= 0);
        assert(nn_connect(sock, NODE2_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        return sock;
}
 
int node1(void)
{
        int sock = nn_socket(AF_SP, NN_BUS);
 
        assert(sock >= 0);
        assert(nn_bind(sock, NODE1_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        assert(nn_connect(sock, NODE2_SOCKET_ADDR) >= 0);
        assert(nn_connect(sock, NODE3_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        return sock;
}
 
int node2(void)
{
        int sock = nn_socket(AF_SP, NN_BUS);
 
        assert(sock >= 0);
        assert(nn_bind(sock, NODE2_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        assert(nn_connect(sock, NODE3_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        return sock;
}
 
int node3(void)
{
        int sock = nn_socket(AF_SP, NN_BUS);
 
        assert(sock >= 0);
        assert(nn_bind(sock, NODE3_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        assert(nn_connect(sock, NODE0_SOCKET_ADDR) >= 0);
        sleep(1); /* wait for connections */
 
        return sock;
}
 
int bus_on(int sock, const char *name)
{
        int to = 100;
        assert(nn_setsockopt(sock, NN_SOL_SOCKET, NN_RCVTIMEO, &to, sizeof(to)) >= 0);
 
        /* SEND */
        int sz_n = strlen(name) + 1;
        printf("%s: SENDING '%s' ONTO BUS\n", name, name);
        int send = nn_send(sock, name, sz_n, 0);
        assert (send == sz_n);
 
        while (1) {
                /* RECV */
                char *buf = NULL;
                int recv = nn_recv(sock, &buf, NN_MSG, 0);
                if (recv >= 0) {
                        printf("%s: RECEIVED '%s' FROM BUS\n", name, buf);
                        nn_freemsg(buf);
                }
        }
 
        return nn_shutdown(sock, 0);
}
 
int node(const char *name)
{
        int sock;
 
        if (!strcmp(name, "node0")) {
                sock = node0();
        } else if (!strcmp(name, "node1")) {
                sock = node1();
        } else if (!strcmp(name, "node2")) {
                sock = node2();
        } else if (!strcmp(name, "node3")) {
                sock = node3();
        } else {
                return -1;
        }
 
        return bus_on(sock, name);
}
 
int main(int argc, char **argv)
{
        if (argc == 2) {
                return node(argv[1]);
        } else {
                fprintf (stderr, "Usage: bus <NODE_NAME> ...\n");
                return 1;
        }
}

转载于:https://my.oschina.net/u/3346994/blog/861592

weixin_33810302
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
nanomsg-req-rep流程源码分析.docx
07-20
nanomsg是一个开源的实现了几种“可扩展协议”的高性能通信库，本文针对请求/回复模式进行了简单的源码分析，包括请求的时序图，socket消息槽等
nanomsg的协议
qilimi1053620912的博客
03-21 5302
      nanomsg的前身是zeromsg，zeromq估计很多人都见过，是一个消息队列，而nanomq的模式很多和zeromq是类似的，我们这里就简单的解析一下（如果和官方不相同，请以官方为准）。1.One-to-one protocol             一对一协议，这个就是字面意思，只能一对一通信，为通讯双向。关键字：NN_PAIR。2.Request/reply protoco...
探索轻量级消息总线：Nanobus 深度解析与应用指南
最新发布
gitblog_00030的博客
05-30 286
探索轻量级消息总线：Nanobus 深度解析与应用指南 项目地址:https://gitcode.com/choojs/nanobus 在纷繁复杂的软件开发世界里，寻找一个简单、高效的通信机制至关重要。今天，我们将一起揭开 Nanobus 这一微型消息总线的神秘面纱，它以其轻巧而强大的特性，在Node.js的世界中脱颖而出。 项目介绍 Nanobus，正如其名，是一个微小而敏捷的消息传递框架。它提...
nanomsg接口函数以及功能列举大全
weixin_43701705的博客
11-11 4627
nanomsg接口函数以及用法 nanomsg函数官网 包含以下函数 int nn_socket (int domain, int protocol); int nn_close (int s); int nn_setsockopt (int s, int level, int option, const void *optval, size_t optvallen); int nn_getsockopt (int s, int level, int option, void *optval, size_t
nanomsg的SURVEY 模式 设置 接收超时时间
woquNOKIA的专栏
11-12 720
使用SURVEY 模式 使用 nn_setsockopt(m_fd, NN_SOL_SOCKET, NN_RCVTIMEO, &timeout,sizeof(int)); 修改默认的超时时间 没有起作用。各种查找 设置只找到python使用类似的方法设置。 nn_recv(m_fd, &buf, NN_MSG, 0); //这里超时默认时间是1s 最后在官方自带的例子中 int deadline = 500; rc = nn_setsockopt (surveyor, NN_SU
nanomsg使用笔记-1
兼容并蓄终宽阔，若谷虚怀鱼自游
01-16 6759
目前大致的使用情况是使用pollfd, begin: nn_rep no nn_push no nn_pub can out nn_req can out nn_survey can in can out 但是如果没有survey就去recv,会报错EFSM. 使用nn_errno和nn_strerror打印错误信息
Python RabbitMQ实现简单的进程间通信示例
01-21
进程Queue 父进程与子进程，或同一父进程下的多个子进程进行交互 缺点：两个不同Python文件不能通过上面两个Queue进行交互 erlong 基于这个语言创建的一种中间商 win中需要先安装erlong才能使用 rabbitmq_server ...
.NET 进程间通信框架以及示例demo.zip
08-11
本压缩包`.NET 进程间通信框架以及示例demo.zip`包含了一个名为LeslieXin.SimpleMMF的项目，这是一个基于.NET的简单内存映射文件（Memory-Mapped File, MMF）实现的进程间通信框架。下面将详细介绍.NET IPC、内存...
Qt进程间通信与同步示例
04-29
总结起来，Qt进程间通信与同步示例通过QFile的内存映射文件实现了高效的数据共享，而QSystemSemaphore则确保了对共享资源的正确同步，避免了潜在的数据冲突。这个示例对于理解Qt中的并发和多进程编程具有重要的实践...
android中的AIDL进程间通信示例
01-04
因此不能共享内存，就出现了问题，于是，需要提供一些机制在不同进程之间进行数据通信，这个机制就是AIDL了。 一、一个android中AIDL的简单例子 假如是这样，现在有一个项目中提供了比较成熟的计算的方法，而现在我...
Android进程间通信实践的示例代码
01-05
本文介绍了Android进程间通信实践的示例代码，分享给大家，具体如下： 因为线程间的内存是共享的，所以它们之间的通信简单，比如可以通过共享变量等方式实现。而进程间想要通信就要麻烦许多了。要想实现进程间通信...
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
mongos、nanomsg、zeroMQ简述和go-mongos使用实例
逍遥游的博客
07-14 2169
mongos、nanomsg、zeroMQ简述和go-mongos使用实例 文章目录mongos、nanomsg、zeroMQ简述和go-mongos使用实例1. mongos、nanomsg简述2. zeroMQ、nanomsg和可扩展协议PAIR（双向通信）REQREP（客户端请求、服务器回复）PIPELINE（单向数据流）BUS（多对多通信）PUBSUB（主题广播）SURVEY（向小组提问）3. mongos及实例 1. mongos、nanomsg简述 来自：https://cloud.tence
Nanomsg使用说明 Pipeline (A One-Way Pipe)
Tyrant的博客
08-17 3183
最近在看一个项目，里面有很多第三方库，里面有一个就是Nanomsg。不知道为什么我对这个库的名字和他的主页特别有感觉 嘿嘿！介于这个项目是我今年主力要看完并且改造的项目，所以我决定把他的第三方库都学习一下，之后还会有rxcpp这个特别刺激。。。。。。 这个系列主要是讲使用，具体原理，不考究。原理牵涉到很多很多很多别的东西。 回归主题 Nanomsg 这是一个可以跨进程（当然也可以单进程）的通信库，...
使用nanomsg库实现多线程之间的通信（三）
Dancer__Sky的博客
10-30 2753
概述：    这次使用nanomsg库实现多线程一对多的双向通信，其实类似一个服务器，其他均为客户端，且它们之间是长连接，所以服务器可以主动和客户端通信，客户端也可以和服务器通信，这样的一个方式。 多线程一对多双向通信Demo #include &lt;stdio.h&gt; #include &lt;pthread.h&gt; #include &lt;stdlib.h&gt; #inc...
第一个nanomsg的程序
qilimi1053620912的博客
03-21 7418
    这是我学习nanomsg的第一个程序，主要还是模仿nanomsg的例子写得，这里使用的模式为NN_PAIR，即一对一通信这里实现了一个客户端和一个服务端。    本人英文比较差，很多翻译都不准确，见谅    首先我们先来看一下，程序中会调用到的函数，这里我推荐大家想要学习的可以去看nanomsg的官方文档，讲得挺详细的。1.nn_socket    int nn_socket (int d...
使用nanomsg库实现多线程之间的通信（一）
Dancer__Sky的博客
10-30 4513
概述：       这次主要是使用nanomsg库实现多线程之间的通信，在我们复杂的多线程编程中可能各个线程需要共用一些信息，平常加互斥锁等等，有时候也是相当麻烦，这里是使用nanomsg库实现多线程的通信，主要这次是一对一线程双向通信和单向通信的demo。   多线程一对一双向通信demo #include &lt;stdio.h&gt; #include &lt;pthread.h&...
libev+nanomsg实现多线程通信及事件轮询实例demo
zzhongcy的专栏
04-19 2829
概述： 在我们刚接触程序编码的时候，我们要轮询数据有没有发过来，我们最多的可能还是使用while+sleep这样的组合，这对于处理来说是一个效率很低的方法同时还消耗cpu,那么在多线程编程中使用libev+nanomsg会不会提高效率呢。下面实例主要工作如下：A B C 三个线程通过nanomsg通信，A线程作为主线程，控制中枢，B C请求均通过A.那么在实际应用中，比如B模块是接收...
NanoMsg框架|C++的相关函数介绍及AndroidNDK的简单使用
Vaccae的博客
03-02 699
学更好的别人，做更好的自己。——《微卡智享》本文长度为6389字，预计阅读11分钟写在最前前面的文章我们已经把C#通过NNanoMsg实现通讯的Demo说完了，本章开始介绍Android...
linux下c语言编程4-使用共享内存实现进程间通信.pdf
11-01
在Linux环境下，C语言编程中一个重要的实践是使用共享内存作为进程间通信（Inter-Process Communication, IPC）的一种手段。本篇文章主要关注共享内存的使用方法以及一个具体的示例，涉及的关键函数和步骤如下： 1....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值