python的multiprocessing用法

1.详解

multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

参数介绍：
    
    1. group默认为None（目前未使用）
    2. target代表调用对象，即子进程执行的任务
    3. name为进程名称
    4. args调用对象的位置参数元组，args=(value1, value2, ...)
    5. kwargs调用对象的字典，kwargs={key1:value1, key2:value2, ...}
    6. daemon表示进程是否为守护进程，布尔值
　　 　

方法介绍：
　　Process.start() 启动进程，并调用子进程中的run()方法
　　Process.run() 进程启动时运行的方法，在自定义时必须要实现该方法
　　Process.terminate() 强制终止进程，不进行清理操作，如果Process创建了子进程，会导致该进程变成僵尸进程
　　Process.join() 阻塞进程使主进程等待该进程终止
　　Process.kill() 与terminate()相同
　　Process.is_alive() 判断进程是否还存活，如果存活，返回True
　　Process.close() 关闭进程对象，并清理资源，如果进程仍在运行则返回错误

在windows系统中需要注意的：

在Windows中，由于没有fork(Linux中创建进程的机制)，在创建进程的时候会import启动该文件，而在import文件的时候又会再次运行整个文件，如果把Process()放在 if __name__ == '__main__' 判断之外，则Process()在被import的时候也会被运行，导致无限递归创建子进程导致报错，所以在Windows系统下，必须把Process()放在 if __name__ == '__main__' 的判断保护之下。
在子进程中不能使用input，因为输入台只显示在主进程中，故如果在子进程中使用input，会导致报错。

#例子：
from multiprocessing import Process


class NewProcess(Process):
    def __init__(self, name):
        
        # 执行父类的init()
        super().__init__()  
        
        # 创建新参数
        self.name = name
    
    # 在自定义Process类时，必须实现run()方法
    def run(self):
        print(f'{self.name}: Hello World')


if __name__ == '__main__':
    
    # 创建一个新的子进程，并传入参数
    np = NewProcess('LovefishO')
    
    # 开始子进程
    np.start()
    
    # 加入阻塞，保证主进程在子进程之后结束
    np.join()
    
    print('主进程结束')      


# LovefishO: Hello World
# 主进程结束

2.例子

参考：python 实现多核 CPU 并行计算

import multiprocessing
import time

def single_run(digits, fold="1by1"):
    sum = 0
    for i in range(0,500000000):
        sum = sum+i
    print("sum:",sum)


def one_by_one():
    start_time = time.time()
    for i in range(0,12):
        single_run(digits=[], fold="1by1")
    end_time = time.time()
    print("one by one time:",end_time-start_time)

def parallel():
    begin_time = time.time()
    n = 24  # 10
    procs = []
    n_cpu = multiprocessing.cpu_count()
    chunk_size = int(n / n_cpu)

    for i in range(0, n_cpu):
        min_i = chunk_size * i

        if i < n_cpu - 1:
            max_i = chunk_size * (i + 1)
        else:
            max_i = n
        digits = []
        for digit in range(min_i, max_i):
            digits.append(digit)
        print("digits:",digits)
        print("CPU:",i)
        procs.append(multiprocessing.Process(target=single_run, args=(digits, "parallel")))

    for proc in procs:
        proc.start()
    for proc in procs:
        proc.join()

    end_time = time.time()
    print("parallel time: ", end_time - begin_time)


if __name__ == '__main__':
    parallel()

    one_by_one()