zmq python 客户端脚本

通常socket都有超时、noblock相关用法，zmq基于socket也带有类似用法如下

## 防止无限等待

参考 https://www.codenong.com/7538988/

1、设置超时

client_receiver.RCVTIMEO = 1000 # in milliseconds

2、使用轮询器【推荐】

1 2	`poller` `=` `zmq.Poller()` `poller.register(client_receiver, zmq.POLLIN)` `# POLLIN for recv, POLLOUT for send`

poller.poll()超时：等待内容

1	`evts` `=` `poller.poll(1000)` `# wait up to one second for a message to arrive.`

如果没有任何内容，evts将是一个空列表。eg：

def consumer：        
        context = zmq.Context()
 
        reciver = context.socket(zmq.PULL)
        reciver.connect('tcp://127.0.0.1:****')
 
        sender = context.socket(zmq.PUSH)
        sender.connect('tcp://127.0.0.1:****')       
        while not stop:
            sockets = dict(poller.poll(1000))
            if sockets:
                if sockets.get(reciver) == zmq.POLLIN:
                    try:
                        data = reciver.recv(zmq.NOBLOCK)
                        sender.send(data, zmq.NOBLOCK)
                        print("reposting...")
                    except Exception as rev_err:
                        print(rev_err)

参考：

https://www.cnblogs.com/silence-cho/p/12657234.html

https://learning-0mq-with-pyzmq.readthedocs.io/en/latest/pyzmq/patterns/pushpull.html

https://segmentfault.com/a/1190000012010573

ZeroMQ：基于socket，跨进程、跨ip通信。

　ZeroMQ的三种通信模式分别是：

1 Request-Reply：req-reply：一问一答

2 Publisher-subscriber

import time
import threading
import zmq
 
topic = "" # <strong>数据开头可带过滤标签，sub订阅标签，空标签表示全收</strong>def start_server():
    context = zmq.Context()
    socket = context.socket(zmq.PUB)
    socket.bind("tcp://*:5557")
    data = '{"client1": 1, "client2": 0}'
    while True:
 
        msg = "{}{}".format(topic, data)
        socket.send_string(msg)
        print(msg)
        time.sleep(5)
 
 
def client():
    # coding:utf-8
    context = zmq.Context()
    socket = context.socket(zmq.SUB)
    socket.setsockopt_string(zmq.SUBSCRIBE, topic)
    socket.connect("tcp://127.0.0.1:5557")
    while True:
        rev_msg = socket.recv()
        print("{} ---receiving:{}".format(time.strftime('%Y%m%d%H%M%S', time.localtime()), rev_msg))
 
 
class RunServer(threading.Thread):
    def __init__(self, function):
        threading.Thread.__init__(self)
        self.function = function
 
    def run(self):
        self.function()
 
 
server = RunServer(start_server)
server.start()
 
 
client = RunServer(client)
client.start()

3 Parallel Pipeline：不需标签，数据全接收

1）producer

import time
import zmq
 
def producer():
    context = zmq.Context()
    zmq_socket = <strong>context.socket(zmq.PUSH)</strong>
    <strong>zmq_socket.bind("tcp://127.0.0.1:5557") # server 用 bind </strong>
    # Start your result manager and workers before you start your producers
    for num in xrange(20000):
        work_message = { 'num' : num }
        zmq_socket.send_json(work_message)
 
producer()

2）consumer

import time
import zmq
import random

def consumer():
    consumer_id = random.randrange(1,10005)
    print "I am consumer #%s" % (consumer_id)
    context = zmq.Context()
    # recieve work
    consumer_receiver = context.socket(zmq.PULL) # receive pull
    consumer_receiver.connect("tcp://127.0.0.1:5557")
    # send work
    consumer_sender = context.socket(zmq.PUSH) # send push
    consumer_sender.connect("tcp://127.0.0.1:5558")
    
    while True:
        work = consumer_receiver.recv_json()
        data = work['num']
        result = { 'consumer' : consumer_id, 'num' : data}
        if data%2 == 0: 
            consumer_sender.send_json(result)

consumer()

3）collector

import time
import zmq
import pprint

def result_collector():
    context = zmq.Context()
    results_receiver = context.socket(zmq.PULL) # 获取pull
    results_receiver.bind("tcp://127.0.0.1:5558")  # 用bind绑定
    collecter_data = {}
    for x in xrange(1000):
        result = results_receiver.recv_json()
        if collecter_data.has_key(result['consumer']):
            collecter_data[result['consumer']] = collecter_data[result['consumer']] + 1
        else:
            collecter_data[result['consumer']] = 1
        if x == 999:
            pprint.pprint(collecter_data)

result_collector()