如何在Python程序中响应开关请求启停指定Python脚本？

Got it, let's break down how you can control another Python script's start/stop from your custom application—beyond the subprocess method you already know about. Since you've got the request handling sorted, let's jump into practical alternatives:

1. Use the multiprocessing Module (Direct Python Process Control) #

This is great if your target script is written in Python, because you can directly spawn and manage a child process within your code. You'll need to keep track of the process instance so you can terminate it later.

Example Code: #

from multiprocessing import Process
import time

# If your target script is a separate file, import its main logic
# from target_script import run_main_logic

def target_script_logic():
    """Mock logic for your target script"""
    while True:
        print("Target script is running...", flush=True)
        time.sleep(1)

# Store the active process (use a class attribute instead of global in production)
active_process = None

def handle_on_request():
    global active_process
    if not active_process or not active_process.is_alive():
        active_process = Process(target=target_script_logic)
        active_process.start()
        print("✅ Started target script")

def handle_off_request():
    global active_process
    if active_process and active_process.is_alive():
        # For graceful shutdown, use a shared Event instead of terminate()
        active_process.terminate()
        active_process.join()  # Wait for the process to fully exit
        active_process = None
        print("❌ Stopped target script")

Pro Tip: For graceful exits (instead of force-terminating), use multiprocessing.Event—have your target script check the event periodically and exit cleanly when it's set.

2. Low-Level os Module (Unix/Linux Only) #

If you're working on a Unix-like system (Linux/macOS), you can use os.fork() to create a child process, then replace its execution context with your target script. This is more hands-on but gives you system-level control.

Example Code: #

import os
import signal
import time

child_pid = None

def handle_on_request():
    global child_pid
    if not child_pid:
        pid = os.fork()
        if pid == 0:
            # Child process: replace with target script
            os.execvp("python3", ["python3", "target_script.py"])
        else:
            child_pid = pid
            print(f"✅ Started target script with PID {child_pid}")

def handle_off_request():
    global child_pid
    if child_pid:
        try:
            os.kill(child_pid, signal.SIGTERM)
            os.waitpid(child_pid, 0)  # Wait for exit
            child_pid = None
            print("❌ Stopped target script")
        except OSError:
            print("⚠️ Target script wasn't running")

Note: This won't work on Windows since os.fork() isn't supported there.

3. IPC-Based Server-Client Model (Graceful Control) #

If you need your target script to shut down gracefully (clean up resources, save state), set up an inter-process communication (IPC) channel. The target script acts as a server listening for commands, and your main app sends "start" (though you'll still spawn it first) or "stop" signals.

Target Script (target_script.py): #

import socket
import time

def main():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(("localhost", 9999))
    server.listen(1)
    running = True
    print("Target script ready for commands")

    while running:
        conn, addr = server.accept()
        cmd = conn.recv(1024).decode().strip()
        if cmd == "STOP":
            running = False
            conn.sendall(b"ACK_STOP")
        elif cmd == "STATUS":
            conn.sendall(b"RUNNING")
        conn.close()
        time.sleep(0.1)

    print("Cleaning up and exiting...")
    server.close()

if __name__ == "__main__":
    main()

Main App Control Functions: #

import socket
import subprocess

target_proc = None

def handle_on_request():
    global target_proc
    if not target_proc or target_proc.poll() is not None:
        target_proc = subprocess.Popen(["python3", "target_script.py"])
        print("✅ Started target script service")

def handle_off_request():
    global target_proc
    if target_proc and target_proc.poll() is None:
        try:
            # Send stop command over socket
            client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            client.connect(("localhost", 9999))
            client.sendall(b"STOP")
            resp = client.recv(1024).decode()
            print(f"Received response: {resp}")
            client.close()
            target_proc.wait()
            target_proc = None
        except ConnectionRefusedError:
            # Fallback to force terminate if IPC fails
            print("⚠️ Couldn't reach target script, force stopping")
            target_proc.terminate()
            target_proc.wait()
            target_proc = None

4. External Process Managers (Production-Grade) #

For production environments, consider using a dedicated process manager like supervisord. Your main app can call its CLI or API to start/stop the target script, and supervisord handles monitoring, restarting on crashes, and logging.

Example Control Code: #

import subprocess

def handle_on_request():
    try:
        subprocess.run(["supervisorctl", "start", "target_script"], check=True)
        print("✅ Started target script via supervisord")
    except subprocess.CalledProcessError:
        print("⚠️ Failed to start target script")

def handle_off_request():
    try:
        subprocess.run(["supervisorctl", "stop", "target_script"], check=True)
        print("❌ Stopped target script via supervisord")
    except subprocess.CalledProcessError:
        print("⚠️ Failed to stop target script")

Setup: You'll need to configure supervisord with a config file defining your target script as a managed process.

Quick Recap of Use Cases: #

• multiprocessing: Best for cross-platform, Python-to-Python control.
• os.fork(): Unix-only, low-level system control.
• IPC Model: Ideal for graceful shutdowns and complex command flows.
• supervisord: Production-ready, with built-in monitoring and reliability.

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