Python子进程被子进程卡住

Question

I am trying to call a subprocess inside a subprocess in order to send information using ZMQ to an Unity Application. When I call socket.recv() or time.sleep , it stucks the parent process(which is a child process of a main process)

import json
import zmq
from multiprocessing import Process
import multiprocessing as mp
from absl import app, flags, logging
from absl.flags import FLAGS

def send_unity_data(arg):
    context = zmq.Context()
    socket = context.socket(zmq.ROUTER)
    socket.bind("tcp://*:8080")
    while True:
        if(arg.poll()):
            message=arg.recv()
            x =  { "x":str(message[0]), "y":str(message[1])}
            app_json = json.dumps(x)
            socket.send_string(app_json)
            message = socket.recv()
            print("Received request: %s" % message)

def streaming(detection,args):
    try:
        vid = cv2.VideoCapture(int(FLAGS.video))
    except:
        vid = cv2.VideoCapture(FLAGS.video)
    receiver1 , sender1 = mp.Pipe()
    b_proc3 = Process(target=send_unity_data, args=[receiver1])
    b_proc3.start()
    while(True):
    ...

def Main(_argv):
    receiver , sender = mp.Pipe()
    b_proc = Process(target=streaming, args=[receiver,FLAGS])
    b_proc.start()
    while(True):
    ...

I want to send positional coordinates to an Unity application, which is calculated by the streaming process, if someone has a better way to do it, I can change my code as well.

Answer 1

Avoid any undeterministically long blocking state in Video streaming

Without deeper analysis, your code uses blocking-mode operations, which will block, whenever there are no messages yet in the Context() -s instance receiving queue and the code submits a call to a socket.recv() -method, like in the message = socket.recv() SLOC above.

Designing multi-layer / multi-process coordination is to avoid each and every potential blocking - ZeroMQ has .poll() -methods for non-blocking or deterministic ( max-latency-budget consolidated MUX-ed ) priority polling (mainloop-alike)-"Controller"-policies.

Feel free to read more details about how to best use ZeroMQ Hierarchy for your projects.

---

Where the code blocks? Let's review the as-is state:

multiprocessing module has other defaults and exhibits other behaviour than the tools based on the ZeroMQ messaging/signaling infrastructure. Best use the ZeroMQ on both sides - no need to rely on 2nd layer of multiprocessing.Pipe tools for delivering content into ZeroMQ operating realms. ZeroMQ stack-less transport classes, as inproc:// and ipc:// and even cluster-wide tipc:// deliver way better performance as they may ejnoy a Zero-Copy for ultimate shaving off the processing latency.

Anyway, avoid all blocking forms of methods being called and design a code so that it does not depend on (not yet, the more on not ever) delivered messages:

def send_unity_data( arg ):                     ### an ad-hoc called
    context = zmq.Context()                     ###           1st: spends time to instantiate a .Context()
    socket = context.socket( zmq.ROUTER )       ###           2nd: spends time to instantiate a .socket()
    socket.bind("tcp://*:8080")                 ###           3rd: spends time to ask/acquire O/S port(s)
    while True:                                 ### INFINITE-LOOP----------------------------------------
        if( arg.poll()                          ### ?-?-?-?-?-?-? MAY BLOCK depending on arg's .poll()-method
            ):                                  ###           IF .poll()-ed:
            message = arg.recv()                ### ?-?-?-?-?-?-? MAY BLOCK till a call to arg.recv()-finished
            x =  { "x": str( message[0] ),      ###               try to assemble a dict{}
                   "y": str( message[1] )       ###                      based on both message structure
                   }                            ###                                        and content
            app_json = json.dumps( x )          ###               try to JSON-ify the dict{}
            socket.send_string( app_json )      ### x-x-x-x-x-x-x WILL BLOCK till a socket.send_string() finished
            message = socket.recv()             ### x-x-x-x-x-x-x WILL BLOCK till a socket.recv()is ever finished
            print( "Received request: %s"       ###               try to print
                 %  message                     ###                    a representation of a <message>
                    )                           ###                   on CLI
        ########################################### This is
        # SPIN/LOOP OTHEWRISE                   ### hasty to O/S resources, wasting GIL-lock latency masking
    ########################################################################################################