Python多进程spawn模式打包触发fork炸弹问题及适配问询

Great question! Let’s break down exactly why this happens and how to fix it so you can use spawn mode with your packaged app.

Why spawn mode causes a process explosion after packaging #

The root issue comes down to how fork and spawn handle child processes differently:

• fork mode: This makes a full copy of the parent process’s memory and state. Child processes don’t re-run your entire program from the start—they just pick up where the parent left off to execute the target function. That’s why your code works here: only the parent runs main() and creates the child, while the child just runs foo() without triggering another process creation.
• spawn mode: This launches a brand new Python interpreter that loads your program from scratch. When running a regular .py script, the child process imports your module, so __name__ isn’t set to __main__, and main() doesn’t run again. But when you package into an executable (PyInstaller/cx_Freeze), the child runs the same executable file. In this case, the executable treats itself as the main module (__name__ == '__main__'), so the child runs main() again, creates another child, and this loops infinitely—causing the "fork bomb" effect that slows down your machine.

How to fix spawn mode support for packaged apps #

You can resolve this with two straightforward steps:

1. Add multiprocessing.freeze_support() to your code
   This function is built explicitly for handling multiprocessing in frozen (packaged) environments. It checks if the current process is a spawned child and exits early before your main() function runs, breaking the infinite loop. Update your code like this:

   import multiprocessing
   
   def foo():
       print('running foo')
   
   def main():
       print('start')
       ctx = multiprocessing.get_context('spawn')
       p = ctx.Process(target=foo)
       p.start()
       p.join()
   
   if __name__ == '__main__':
       # Critical line for frozen apps using spawn mode
       multiprocessing.freeze_support()
       main()
   

2. Double-check your packaging tool settings

   • For PyInstaller: You usually don’t need extra flags, but if you still hit issues, explicitly include multiprocessing in your build command to ensure all necessary modules are packaged:

     pyinstaller --hidden-import multiprocessing test.py
     

   • For cx_Freeze: Ensure your setup.py includes multiprocessing. Most recent versions handle this automatically, but you can add includes=['multiprocessing'] to your Executable definition if needed.

Why this works #

freeze_support() acts as a gatekeeper: when a spawned child process runs the executable, it detects this and exits before executing main(). This stops the infinite process creation loop while still letting the child process run the target foo() function exactly as intended.

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