进程

from multiprocessing import Process
import time
def son_process():
    print("son start")
    time.sleep(0.1)
    print("son end")
if __name__ == "__main__":
    p = Process(target = son_process)
    p.start()                  #开启子进程，只是通知操作系统，并不意味着子进程开始了
    for i in range(5):
        print("主进程")
        time.sleep(0.1)
#并发：上面的主进程和子进程同时进行

  p1 = Process(target = son_process)
    p1.start()
    p2 = Process(target = son_process)
    p2.start()
    p3 = Process(target = son_process)    
    p3.start()                     #方法1.开启多个子进程
    for i in range(3):                 #方法2：开启多个子进程
        p = Process(target=son_process)
        p.start()

from multiprocessing import Process
import time
def son_process(i):               #传参  
    print("son start",i)
    time.sleep(1)
    print("son end",i)
if __name__ == "__main__":
    for i in range(10):                    #给 参数赋值
        p = Process(target = son_process,args = (i,))
        time.sleep(1)
        p.start()

from multiprocessing import Process
import time
def son_process(i):               #传参
    print("son start",i)
    time.sleep(1)
    print("son end",i)
if __name__ == "__main__":
    for i in range(10):
        p = Process(target=son_process,args=(i,))
        p.start()
    print("主进程的代码执行完毕")       
#主进程与子进程关系：主进程等待子进程结束之后才结束
#原因： 父进程负责创建子进程，也负责回收子进程的资源
             
主进程的代码执行完毕
son start 3
son start 0
son start 5
son start 7
son start 2
son start 1
son start 4
son start 6
son start 8
son start 9
son end 3
son end 0
son end 5
son end 7
son end 2
son end 1
son end 4
son end 6
son end 8
son end 9     #子进程结束 程序结束

Process finished with exit code 0

from multiprocessing import Process
import time
def son_process(i):
    while True:                  #子进程无限循环
        print('son start',i)   
        time.sleep(0.5)
        print('son end',i)

if __name__ == '__main__':
    p = Process(target=son_process, args=(1,))
    p.start()           # 开启一个子进程,异步的
    print('主进程的代码执行完毕')
    print(p.is_alive())  # 子进程还活着
    p.terminate()        # 结束一个子进程,异步的
    print(p.is_alive())  # 子进程还在活着
    time.sleep(0.01)
    print(p.is_alive())     #关闭子进程需要时间，尽管这个时间非常短

主进程的代码执行完毕
True
True
False

Process finished with exit code 0

# 数据隔离
from multiprocessing import Process
n = 100
def sub_n():
    global n              # 子进程对于主进程中的全局变量的修改是不生效的
    n -= 1
    print("子进程：", n)
if __name__ == "__main__":
    p = Process(target = sub_n)
    p.start()
    p.join()                 # 阻塞 直到子进程p结束，主程序才开始进行  两者数据互不干扰
    print("主进程: ",n)



子进程： 99
主进程:  100

Process finished with exit code 0

#开启十个子进程，他们执行完之后结束主进程？？？
#思路   for循环
# if __name__ == '__main__':
#     p_lst = []
#     for i in range(10):
#         p = Process(target = sub_n)
#         p.start()
#p.join()        #此代码为错误阻塞，因为p为最后一个子进程，只阻塞了最后一个子进程。  错误原因：对for循环理解不够深
#         p_lst.append(p)        #把每一个循环的子进程放在列表里
#     for p in p_lst:p.join()  # 循环这10个子进程   通过阻塞 只有一个条件是能够让我继续执行 这个条件就是子进程结束
#     print('主进程n : ',n)

join 扩展 
      #p.join(timeout = 5)     # 如果不设置超时时间 join会阻塞直到子进程p结束
#     # timeout超时
#     # 如果设置的超时时间,那么意味着如果不足5s子进程结束了,程序结束阻塞
#     # 如果超过5s还没有结束,那么也结束阻塞
#     print('主进程n : ',n)
#     p.terminate()  # 也可以强制结束一个子进程