如何在 python 的另一个函数中启动进程？

Question

Suppose i have two functions

def funct1():
    ##does something
def funct2():
    ##does something

I want to use them in another function with multiprocessing like so:

def my_funct
    ##does something
    if __name__ == '__main__':
         p1 = Process(target = funct1)
         p2 = Process(target = funct2)
         p1.start()
         p2.start()
         ##more code
         p1.terminate()
         p2.terminate()
     return something

Basically i want to start and end processes inside my function but its not working properly. What would be the correct way to do this?

Answer 1

On platforms that use the spawn method to create new processes it becomes necessary to place the process-creation code that exists at the global scope within an if __name__ == '__main__': block to prevent the newly created child process from trying to re-execute recursively the process-creation code since all code at the global level is re-executed in order to initialize memory (eg function definitions and global variables) for the process. Putting such a test within a function or method, which by definition would not be at global scope, would not normally make too much sense.

In your case there must be some code in the main script being executed (where __name__ would be '__main__' unless that script is launched as a module with the -m Python flag) that invokes directly or indirectly your my_funct function. It is that code that should be placed in a if __name__ == '__main__': block. For example:

def my_funct
    ##does something
    p1 = Process(target = funct1)
    p2 = Process(target = funct2)
    p1.start()
    p2.start()
    ##more code
    p1.terminate()
    p2.terminate()
    return something

def function main():
    # Do some work
    ...
    # Call my_funct, which creates new child processes:
    print(my_funct())
    # Do some more work
    ...

if __name__ == '__main__':
    # The following function invocation is at global scope in the main script 
    # and invokes code that will ultimately be creating new child processes:
    main()

If the if __name__ == '__main__': test were instead moved to where you had it originally, then function main would be invoked as part of the initialization of memory for the new processes that were created in function my_funct . But I am sure you would not want main or any part of my_funct to be re-executed, which would happen with this move.

Note

I should add that any code at global scope that you do not want or do not need to be re-executed as part of memory initialization for the new child process should be placed within a if __name__ == '__main__': block , not just process-creation code. Also note that if your my_funct is imported from some module, then __name__ would not be '__main__' to begin with.