1. Runtime when using multiple processes without blocking with the join function

import os
from multiprocessing import Process


"""
 The following is the result of the run. We can see that the main process does not
 After the child process finishes running, it ends, and each program runs.
 Mutual interference
Parent process 10996
Finished
Child process 0 (984)
Child process 2 (13632)
Child process 1 (8308)
Child process 3 (8640)
Child process 4 (8412)
"""
def run_proc(name):
    print("Child process %s (%s)" % (name, os.getpid()))


if __name__ == "__main__":
    print("Parent process %s" % (os.getpid()))
    for i in range(5):
        p = Process(target=run_proc, args=(str(i),))
        p.start()
         The role of the # join function is to achieve process synchronization,
         # and it specifically blocks the current process, that is, the main process until the process of calling the join function is executed.
         # Continue to execute the current process.
    print("Finished")

2, when only one join is called, the main process that is called will wait for the child process to continue to execute downward after the end of the run.

import os
import time
from multiprocessing import Process

"""
The following is the result of the run. We can see that the main process does not end directly.
 Instead, it blocks and waits for the process started by p01 to finish executing.
Parent process 14208
Child process 1 (19392)
 A total of 0 seconds of sleep
 I have slept for 1 second.
 A total of 2 seconds of sleep
 A total of 3 seconds of sleep
 A total of 4 seconds of sleep
Child process 2 (17348)
Finished

"""
def run_proc(name):
    print("Child process %s (%s)" % (name, os.getpid()))

def run_proc01(name):
    for i in range(5):
        time.sleep(1)
                 Print("A total sleep of %s seconds" %i)
    print("Child process %s (%s)" % (name, os.getpid()))


if __name__ == "__main__":
    print("Parent process %s" % (os.getpid()))
    p = Process(target=run_proc, args=(str(1),))
    p01 = Process(target=run_proc01, args=(str(2),))
    p.start()
    p01.start()
    p01.join()
    print("Finished")

3, when only calling a join function in front of a process's start function, then because the main process is blocked to the join position will not start executing the next line of code until the process of calling join is executed, so the start time is blocked. After time.

import os
from multiprocessing import Process


"""
 The following is the result of the run. We can see that the for loop is first entered in the main process.
 Start the first child process and then block the main process by calling the join function until
 After the first child process finishes executing, it starts to cancel the blocking and continues to execute the main process.
 Open the second child process and then call the join and block the main process because the second child process also
 Until the end of the cycle. 
Parent process 8028
Child process 0 (13792)
Child process 1 (11456)
Child process 2 (16948)
Child process 3 (16240)
Child process 4 (10544)
Finished
"""
def run_proc(name):
    print("Child process %s (%s)" % (name, os.getpid()))


if __name__ == "__main__":
    print("Parent process %s" % (os.getpid()))
    for i in range(5):
        p = Process(target=run_proc, args=(str(i),))
        p.start()
        p.join()
         The role of the # join function is to achieve process synchronization,
         # and it specifically blocks the current process, that is, the main process until the process of calling the join function is executed.
         # Continue to execute the current process.
    print("Finished")

4, therefore, we can see from the above that if multiple processes are not well written, it is not as good as a single process because it takes time to restart the process and block the process. Therefore the join function should be after all start functions (generally).

import os
from multiprocessing import Process


"""
 In this case, no matter how the main process runs, it waits for all the child processes to complete and continues to execute downwards.
Parent process 7764
Child process 0 (12884)
Child process 2 (15644)
Child process 1 (3936)
Child process 4 (6876)
Child process 3 (16904)
Finished

"""
def run_proc(name):
    print("Child process %s (%s)" % (name, os.getpid()))


if __name__ == "__main__":
    print("Parent process %s" % (os.getpid()))
    list1 =[]
    for i in range(5):
        p = Process(target=run_proc, args=(str(i),))
        list1.append(p)
        p.start()
    for i in list1:
        i.join()
         The role of the # join function is to achieve process synchronization,
         # and it specifically blocks the current process, that is, the main process until the process of calling the join function is executed.
         # Continue to execute the current process.
    print("Finished")

5, below to share with you a bit of a problem code can be seen, you can leave a message or private chat about its problems.

import os
import time
import random
from multiprocessing import Process

"""
 The following is the result of the operation
Parent process 2432
Child process 0 (2416)
Child process 2 (8972)
Child process 1 (16916)
Child process 3 (13144)
Child process 4 (15608)
Finished
"""


def run_proc(name):
    print("Child process %s (%s)" % (name, os.getpid()))


def run_proc01(name):
    i = random.random()
    time.sleep(i)
    print("Child process %s (%s)" % (name, os.getpid()))


if __name__ == "__main__":
    print("Parent process %s" % (os.getpid()))
    for i in range(5):
        p = Process(target=run_proc, args=(str(i),))
        p.start()
         The role of the # join function is to achieve process synchronization,
         # and it specifically blocks the current process, that is, the main process until the process of calling the join function is executed.
         # Continue to execute the current process.
    p.join()
    print("Finished")