Introduction to Pyzmq

【Related learning recommendations: python tutorial】

Introduction to Pyzmq

ZMQ (hereinafter ZeroMQ referred to as ZMQ) is a simple and easy-to-use transport layer, a socket library like a framework, which makes Socket programming simpler, more concise and higher-performance .

is a message processing queue library that can elastically scale between multiple threads, cores and host boxes. The stated goal of ZMQ is to "become part of the standard network protocol stack and later enter the Linux kernel."

ZMQ makes writing high-performance network applications extremely easy and fun.

ZeroMQ is not a socket encapsulation and cannot be used to implement existing network protocols.

It has its own mode, which is different from the lower-level point-to-point communication mode.

It has a higher level protocol than the tcp protocol. (Of course ZeroMQ is not necessarily based on the TCP protocol, it can also be used for inter-process and intra-process communication)

zeromq is not similar to rabbitmq message queue, it actually Only one message queue component and one library.

##Pyzmq official website: zeromq.org/languages/python/Githubgithub.com/zeromq/pyzmqDocszeromq.github.io/pyzmq/ Guidezguide.zeromq.org/py:allDownload

pip install pyzmq

Several modes of Pyzmq

1. Request-Reply mode (rep and req)

Messages are bidirectional, coming and going. For messages requested by the req end, the rep end must reply to the req end

2. Subscription publishing mode (pub and sub)

Messages are one-way, there is no return. The publishing side can publish messages on specific topics, and the subscribing side can subscribe to topics that it likes. The subscribing side will only receive topics that it has subscribed to. The publisher publishes a message that can be received by multiple subscribers.

3. Push pull mode

Messages are one-way, and there is no return. For any push message, only one pull end will receive the message.

The subsequent proxy mode and routing mode are all extensions or mutations of the three basic modes.

1. Request-Reply mode (request response model):

After the client requests, the server must respond

by the client Initiate a request and wait for the server to respond to the request. From the client side, there must be a sending and receiving pair;

On the contrary, from the server side, there must be a sending and receiving pair. Both the server and the client can be in 1:N model. Usually 1 is considered the server and N is the client.

ZMQ can support the routing function very well (the component that implements the routing function is called Device), extending 1:N to N:M (only a few routing nodes need to be added).

From this model, the lower-level endpoint address is hidden from the upper layer. The response address is implicit in every request, and the application does not care about it

Server:

sever.py

 import zmq import sys
 context = zmq.Context()
 socket = context.socket(zmq.REP)
 socket.bind("tcp://*:5555")
 while True:
  try:
  print("wait for client ...")
  message = socket.recv()
  print("message from client:", message.decode('utf-8'))
  socket.send(message)
  except Exception as e:
  print('异常:',e)
  sys.exit()

Client:

#client.py

 import zmq import sys
 context = zmq.Context()
 print("Connecting to server...")
 socket = context.socket(zmq.REQ)
 socket.connect("tcp://localhost:5555")
 while True:
 
  input1 = input("请输入内容：").strip()
  if input1 == 'b':
  sys.exit()
  socket.send(input1.encode('utf-8'))
 
  message = socket.recv()
  print("Received reply: ", message.decode('utf-8'))

2.Publish-Subscribe mode (publish-subscribe model):

Broadcast All clients, without queue cache, disconnect data will be lost forever. The client can perform data filtering.

Server

server.py

 import zmq import time import sys
 context = zmq.Context()
 socket = context.socket(zmq.PUB)
 socket.bind("tcp://*:5555")
 
 while True:
  msg = input("请输入要发布的信息：").strip()
  if msg == 'b':
  sys.exit()
  socket.send(msg.encode('utf-8'))
  time.sleep(1)

Client 1

client1.py

 import zmq
 
 
 context = zmq.Context()
 socket = context.socket(zmq.SUB)
 socket.connect("tcp://localhost:5555")
 socket.setsockopt(zmq.SUBSCRIBE,''.encode('utf-8'))  # 接收所有消息 while True:
  response = socket.recv().decode('utf-8');
  print("response: %s" % response)

Client Terminal 2

client2.py

 import zmq
 context = zmq.Context()
 socket = context.socket(zmq.SUB)
 socket.connect("tcp://localhost:5555")
 socket.setsockopt(zmq.SUBSCRIBE,'123'.encode('utf-8'))  # 消息过滤  只接受123开头的信息 while True:
  response = socket.recv().decode('utf-8');
  print("response: %s" % response)

3.Parallel Pipeline mode (pipeline model):

consists of three parts, push for data push, Work performs data caching, and pull performs data competition acquisition processing. Different from Publish-Subscribe, there is a data cache and processing load.

When the connection is disconnected, the data will not be lost, and the data will continue to be sent to the peer after reconnection.

server.py

 import zmq import time
 
 context = zmq.Context()
 socket = context.socket(zmq.PUSH)
 socket.bind("tcp://*:5557")
 
 while True:
  msg = input("请输入要发布的信息：").strip()
  socket.send(msg.encode('utf-8'))
  print("已发送")
  time.sleep(1)

worker.py

 import zmq
 context = zmq.Context()
 receive = context.socket(zmq.PULL)
 receive.connect('tcp://127.0.0.1:5557')
 sender = context.socket(zmq.PUSH)
 sender.connect('tcp://127.0.0.1:5558')
 
 while True:
  data = receive.recv()
  print("正在转发...")
  sender.send(data)

client.py

 import zmq
 context = zmq.Context()
 socket = context.socket(zmq.PULL)
 socket.bind("tcp://*:5558")
 
 while True:
  response = socket.recv().decode('utf-8')
  print("response: %s" % response)

The above is the detailed content of Introduction to Pyzmq. For more information, please follow other related articles on the PHP Chinese website!