如何提取Python multiprocessing.Process的状态标识（initial/started/stopped）

Great question! I totally get why having those explicit state labels would be more intuitive for your business logic checks compared to just relying on is_alive(). Let's walk through two reliable ways to get those exact state identifiers you're seeing when printing the Process object.

Method 1: Parse the Process object's string representation #

The state labels (initial, started, stopped) you see in the print output are directly baked into how the Process class formats its string representation. We can extract them by converting the process object to a string and parsing the relevant section:

from multiprocessing import Process
import time

def get_process_state(proc):
    proc_str = str(proc)
    # Isolate the state part from the string
    if ", " in proc_str:
        state = proc_str.split(", ")[-1].rstrip(">)")
        return state.strip()
    return "unknown"

# Test the function
def sample_func():
    time.sleep(1)

subproc = Process(target=sample_func, name='MySubprocess')
print(get_process_state(subproc))  # Output: initial
subproc.start()
print(get_process_state(subproc))  # Output: started
subproc.join()
print(get_process_state(subproc))  # Output: stopped

Pros & Cons #

• Pros: Directly maps to the exact labels you see in print statements, no need to infer state from other properties.
• Cons: Relies on the fixed string formatting of the Process class, which could theoretically change between Python versions (though it's remained consistent for most recent releases).

Method 2: Infer state from Process instance properties (more stable) #

If you want a version that's less dependent on string formatting, you can use the Process object's built-in properties to deduce the state. This approach is more robust across Python updates:

def get_process_state(proc):
    # Initial state: process hasn't been started yet
    if proc._popen is None:
        return "initial"
    # Started state: process is actively running
    elif proc.is_alive():
        return "started"
    # Stopped state: process has finished execution
    else:
        return "stopped"

If you're cautious about accessing the "private" _popen attribute (even though it's a standard part of the multiprocessing implementation), you can also use exitcode and is_alive() together for a purely public-API approach:

def get_process_state(proc):
    # Initial: not alive and no exit code assigned yet
    if not proc.is_alive() and proc.exitcode is None:
        return "initial"
    # Started: currently running
    elif proc.is_alive():
        return "started"
    # Stopped: finished, exit code exists
    else:
        return "stopped"

Pros & Cons #

• Pros: Doesn't depend on string formatting, so it's more stable across Python versions. Uses official API methods (is_alive()) plus well-documented internal properties.
• Cons: Doesn't directly pull the label from the print output, but it accurately maps to the same state transitions.

Either method will give you the clear state labels you need for your business logic checks. Pick the one that aligns best with your priorities for stability vs. exact label matching.

内容的提问来源于stack exchange，提问作者missmango