# -*- coding: UTF-8 -*-
from multiprocessing import Process
# multiprocessing  基于进程的并行

def work(name,job):
  print(f'{name}喜欢{job}')

# 在 multiprocessing 中，通过创建一个 Process 对象然后调用它的 start() 方法来生成进程

if __name__ == '__main__':  # __name__ 当前主进程
    p = Process(target = work,args=('光头强','砍树'))
    p1 = Process(target = work,args=('光头强1','玩游戏'))
    p2 = Process(target = work,args=('光头强2','赚钱'))
    p.start()            #start() 方法来生成进程
    p1.start()           #start() 方法来生成进程
    p2.start()           #start() 方法来生成进程
    p.join()             #join() 方法结束进程
    p1.join()            #join() 方法结束进程
    p2.join()            #join() 方法结束进程

     新建一个子进程是会把需要的执行环境都拷贝一份,每个进程的执行环境是独立的，互不影响的。

# -*-  coding: utf-8  -*-
from multiprocessing import Process
import os
num = 0
def add(name):
    global num
    print(f'函数{name} 当前进程ID = {os.getpid()} 主进程ID =  {os.getppid()}'  )    # 获得主进程ID
    for _ in range(10):
        num += 1
    print(f'函数{name} 执行完后num = {num}')


if __name__ == '__main__':
    print(f"start num = {num}")
    print(f'当前主进程ID = {os.getpid()}')
    p1 = Process(target=add, args=('张三',))   #新建一个子进程是会把需要的执行环境都拷贝一份，并单独执行
    p2 = Process(target=add, args=('李四',))   #每个子进程都是相互独立的并不相互影响,同时也不影响主程序

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print(f"end num = {num}")

 

from multiprocessing import Process
import time
def work(a):
    print(a)
    time.sleep(0.5)

if __name__ == '__main__' :
    start_time = time.time()
    l = []
    for x in range(50):
        p = Process(target=work, args=(x,))
        l.append(p)
        p.start()
    end_time = time.time()
    for x in l:
        x.join()
    print(f"耗时：{end_time - start_time :.2f}s")

在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。
Pool可以提供指定数量的进程供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。

#-*- coding: UTF-8 -*-

from multiprocessing import Pool
import time
def func(ss):
    print("msg:", ss)
    time.sleep(3)
    print("end")

if __name__ == "__main__":
    pool = Pool(3)   # 3 就是池子的容量，同时可容纳3个子进程
    for i in range(50):
        msg = f"hello {i}"
        pool.apply_async(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
    print("Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~")
    pool.close()
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    print("Sub-process(es) done.")