重头戏!ZeroMQ的独家对模式详解:ZMQ_PAIR

一、ØMQ模式总览

二、独家对模式

三、“PAIR”套接字类型

  • ZMQ_PAIR类型的套接字只能一次连接到单个对等方。对通过ZMQ_PAIR套接字发送的消息不执行消息路由或筛选
  • 当ZMQ_PAIR套接字由于已达到连接对等方的高水位线而进入静音状态时,或者如果没有连接任何对等方,则套接字上的任何zmq_send()操作都应阻塞,直到对等方可用于发送;消息不会被丢弃
  • 适用协议:
    • ZMQ_PAIR套接字设计用于通过nproc传输进行线程间通信,并且不实现自动重新连接等功能
    • 尽管ZMQ_PAIR套接字可用于inproc以外的其他传输协议,但是它们无法自动重新连接,并且当以前存在任何连接(包括关闭状态的连接)时,新的传入连接将被终止,这使得它们在大多数情况下不适合TCP
                                                                                                       ZMQ_PAIR特性摘要 
兼容的对等套接字ZMQ_PAIR
方向双向
发送/接收模式无限制
入网路由策略不适用(N/A)

外发路由策略

不适用(N/A)
静音状态下的操作阻塞

四、PAIR套接字应用场景:协调线程

  • 在编写多线程应用程序时,会遇到如何“协调线程”的问题,例如一个线程状态发生改变时同时另一个线程:
    • 如果使用以往的多线程程序,你可能会使用信号量或互斥等技术
    • 但是在ØMQ中,你可以使用ZMQ_PAIR套接字来进行线程间的通信
  • 下面是一个演示案例,下面创建三个PAIR套接字:
    • PAIR3:主线程中的PAIR套接字,等待PAIR2发来通知消息
    • PAIR2:在主线程中调用pthread_create()创建线程,在线程的回调函数中创建PAIR2套接字,该套接字等待PAIR1发来通知消息
    • PAIR1:PAIR2所在的线程再调用一次pthread_create(),在线程的回调函数中创建PAIR1套接字,PAIR1会向PAIR2发送消息
  • 整体的流程就是:PAIR1发送消息给PAIR2,PAIR2接收到PAIR1的消息之后再发送消息给PAIR3,PAIR3接收到PAIR2的消息之后退出程序

  • 代码如下:
// mtrelay.c
// 源码链接: https://github.com/dongyusheng/csdn-code/blob/master/ZeroMQ/mtrelay.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <pthread.h>
#include <zmq.h>

// PAIR2套接字执行函数, 参数为主进程的上下文对象指针
static void *step2(void *arg);

// PAIR1套接字执行函数, 参数为主进程的上下文对象指针
static void *step1(void *arg);

// 从socket套接字上接收消息
static char *s_recv(void *socket);
 
// 向socket套接字发送消息string
static int s_send(void *socket, char *string);

int main()
{
    int rc;
    
    // 1.创建新的上下文对象
    void *context = zmq_ctx_new();
    assert(context != NULL);

    // 2.创建、绑定PAIR3套接字, PAIR2会连接该套接字并向该套接字发送消息
    void *receiver = zmq_socket(context, ZMQ_PAIR);
    assert(receiver != NULL);
    rc = zmq_bind(receiver, "inproc://step3");
    assert(rc != -1);

    // 3.创建线程, 线程中创建PAIR2套接字, PAIR2套接字会向PAIR3发送消息
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, step2, context);

    // 4.阻塞等待接收PAIR2发来消息
    char *string = s_recv(receiver);
    assert(string != NULL);
    free(string);

    // 5.打印消息
    printf("Test successful!\n");

    // 6.关闭套接字、销毁上下文
    zmq_close(receiver);
    zmq_ctx_destroy(context);
    
    return 0;
}

static void *step2(void *arg)
{
    // 参数为上下文对象指针

    int rc;
    
    // 1.创建、绑定PAIR2套接字, PAIR1会连接该套接字并向该套接字发送消息
    void *receiver = zmq_socket(arg, ZMQ_PAIR);
    assert(receiver != NULL);
    rc = zmq_bind(receiver, "inproc://step2");
    assert(rc != -1);

    // 2.创建线程, 线程中创建PAIR1套接字, PAIR1套接字会向PAIR2发送消息
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, step1, arg);
    
    // 3.等待接收PAIR1发来消息
    char *string = s_recv(receiver);
    assert(string != NULL);
    free(string);
    // 关闭PAIR2套接字
    zmq_close(receiver);


    // 接收到PAIR1发来消息之后, 再开始向PAIR3发送通知

    
    // 4.重新创建一个PAIR2套接字, 该套接连接PAIR3
    void *xmitter = zmq_socket(arg, ZMQ_PAIR);
    assert(xmitter != NULL);
    rc = zmq_connect(xmitter, "inproc://step3");
    assert(rc != -1);

    // 5.向PAIR3发送通知
    printf("Step 2 ready, signaling step 3\n");
    rc = s_send(xmitter, "READY");
    assert(rc != -1);
    zmq_close(xmitter);

    return NULL;
}

static void *step1(void *arg)
{
    // 参数为上下文对象指针
    int rc;
    
    // 创建一个PAIR1套接字, 然后连接PAIR2套接字
    void *xmitter = zmq_socket(arg, ZMQ_PAIR);
    assert(xmitter != NULL);
    rc = zmq_connect(xmitter, "inproc://step2");
    assert(rc != -1);

    // 5.向PAIR2发送通知
    printf("Step 1 ready, signaling step 2\n");
    rc = s_send(xmitter, "READY");
    assert(rc != -1);
    zmq_close(xmitter);

    return NULL;
}

static char *s_recv(void *socket)
{
    int size;
    
    zmq_msg_t msg;
    zmq_msg_init(&msg);
    
    size = zmq_msg_recv(&msg, socket, 0);
    if(size == -1)
        return NULL;
 
    char *string = (char*)malloc(size + 1);
    if(string == NULL)
        return NULL;
    memcpy(string, zmq_msg_data(&msg), size);
 
    zmq_msg_close(&msg);
 
    string[size] = 0;
 
    return string;
}
 
static int s_send(void *socket, char *string)
{
    int rc;
    
    zmq_msg_t msg;
    zmq_msg_init_size(&msg, strlen(string));
 
    memcpy(zmq_msg_data(&msg), string, strlen(string));
    
    rc = zmq_msg_send(&msg, socket, 0);
    
    zmq_msg_close(&msg);
 
    return rc;
}
  • 编译运行如下:
gcc -o mtrelay mtrelay.c -lzmq

案例分析

  • 这是使用ØMQ进行多线程编程的一个经典模式:
    • 1.两个线程通过inproc通信,使用的是共享的上下文
    • 2.父线程创建一个套接字,将其绑定到一个inproc端点,然后启动子线程,将上下文传递给它
    • 3.子线程创建第二个套接字,将它连接到该inproc端点,然后发信号告诉父线程,它已准备就绪
  • 使用这种模式的多线程代码是不可扩展到进程的。如果你使用inproc和套接字对,你就正在构建一个紧耦合的应用程序,也就是说,其中你的线程在结构是相互依存的,只有在低延迟真的很重要的时候才这样做。另一种设计模式是一个松耦合的应用程序,其中的线程有自己的上下文并通过ipc或tcp通信。你可以轻松地将松耦合的线程分解为单独的进程

为什么选择的是PAIR?

  • 此处使用的是PAIR套接字,其他套接字组合也能够完成上面相同的工作,但是其他台套接字都有副作用,可能会干扰信令:
    • 你可以让发送者使用PUSH并让接收者使用PULL,但是PUSH会把消息发送给所有存在的接收者,假设你启动了2个接收者,那么就会“丢失”一半的信号。PAIR具有拒绝多个连接,两个连接的组成的对是独占的
    • 你可以让发送者使用DEALER并让接收者使用ROUTER,但是ROUTER将你的信息包装在一个“封包”中,这意味着你的大小为0的信号变成了一个多部分消息。如果你不关心数据并把任何东西都当做一个有效的信号,并且如果你不会不止一次地从套接字上读取,这并不重要。但是,如果你决定要发送实际数据时,你会突然发现ROUTER为你提供了“错误”的消息。DEALER也分发传出消息,这带来与PUSH相同的风险
    • 你可以让发送者使用PUB,而让接收者使用SUB,这将完全按照你发送它们的原样正确地传递你的消息,而且PUB不像PUSH或DEALER那样分发消息。但是,你需要用空订阅配置订阅者,这比较麻烦,更糟的是,PUB-SUB链接的可靠性是与实践相关的,并且如果在PUB套接字发送消息时,SUB套接字正在连接,信息就有可能会丢失
  • 综合以上的原因,使得PAIR成为线程对之间协调的最佳选择

五、节点协调


  • 我是小董,V公众点击"笔记白嫖"解锁更多【ZeroMQ】资料内容。

相关推荐
©️2020 CSDN 皮肤主题: 1024 设计师:白松林 返回首页