title: ZeroMQ synchronized PUB-SUB: Subscriber hangs with synchronization but works normally otherwise
body: <p>I'm using ZeroMQ to establish a publisher/subscriber communication model.<br>
  The publisher creates a zmq context and then opens a socket with the PUB<br>
  communication pattern. It then binds to a port, as the TCP transport protocol is used. For the synchronization a separate socket is opened with the REP communication pattern that binds in a different path. Unless a synchronization request in <code>msg = syncservice.recv()</code> is received, the program cannot continue. It then does some rudimentary work and starts over again. Here's the code for the publisher:</p>
  
  <pre><code>import pickle, zmq, random, string
  
  # Wait for 1 subscriber
  SUBSCRIBERS_EXPECTED = 1
  
  def randomword(length):
      letters = string.ascii_lowercase
      return ''.join(random.choice(letters) for i in range(length))
  
  while True:
      try:
          arguments = {}
          data = {}
          context = zmq.Context()
  
          # Socket to talk to clients
          publisher = context.socket(zmq.PUB)
          # set SNDHWM, in case of slow subscribers
          publisher.sndhwm = 1100000
          publisher.bind('tcp://*:5561')
  
          # Socket to receive signals
          syncservice = context.socket(zmq.REP)
          syncservice.bind('tcp://*:5562')
  
          # Get synchronization from subscribers
          subscribers = 0
          while subscribers &lt; SUBSCRIBERS_EXPECTED:
              # wait for synchronization request
              msg = syncservice.recv()
              # send synchronization reply
              syncservice.send(b'')
              subscribers += 1
  
          for n in range(1000):
              for i in range(random.randrange(1, 6)):
                  arguments[i] = randomword(random.randrange(2, 10))
  
              data['func_name_' + str(n)] = randomword(8)
              data['arguments_' + str(n)] = arguments
  
          data_string = pickle.dumps(data)
          publisher.send(data_string)
  
      except KeyboardInterrupt:
          print("Interrupt received, stopping...")
          break
  </code></pre>
  
  <p>The subscriber functions pretty much the same way the publisher does, albeit
  from a subscriber perspective. Here's the code for the subscriber:</p>
  
  <pre><code>import pickle, zmq, pprint, time
  
  context = zmq.Context()
  
  # Connect the subscriber socket
  subscriber = context.socket(zmq.SUB)
  subscriber.connect('tcp://localhost:5561')
  subscriber.setsockopt(zmq.SUBSCRIBE, b'')
  
  time.sleep(1)
  
  # Synchronize with publisher
  syncclient = context.socket(zmq.REQ)
  syncclient.connect('tcp://localhost:5562')
  
  # Initialize poll set
  poller = zmq.Poller()
  poller.register(syncclient, zmq.POLLIN)
  poller.register(subscriber, zmq.POLLIN)
  
  # send a synchronization request
  syncclient.send(b'')
  
  while True:
      try:
          socks = dict(poller.poll())
  
      except KeyboardInterrupt:
          print("Interrupt received, stopping...")
          break
  
      # wait for synchronization reply
      if syncclient in socks:
          syncclient.recv()
          print('Sync')
  
      if subscriber in socks:
          msg = subscriber.recv()
          data = pickle.loads(msg)
          pprint.pprint(data)
          syncclient.send(b'')
  </code></pre>
  
  <p>The desired result would be for the publisher to publish endlessly, while the
  subscriber continually receives and prints everything. If I remove the
  synchronization part, everything runs as expected. If I keep the synchronization
  part the subscriber hangs after a number of transmissions. The interesting thing
  is that if I send a keyboard interrupt (Ctrl-C) and then restart the subscriber,
  it will receive a couple of transmissions again and hang again and so on and so
  forth.</p>
  
  <p>I have tried different high-watermark settings, but it didn't make any difference. I have tried closing the sockets and terminating the context after every loop. I've tested if the overhead from printing or pickling (serializing) was too much, but it wasn't it either. I have also modified the <a href="http://zguide.zeromq.org/py:suisnail" rel="nofollow noreferrer">suicidal snail example</a> to work in this case, but the subscriber didn't die. What am I missing? (Python 3 is used for every example)</p>