1. 导入相关包

import math
import datetime
import multiprocessing as mp

# 调用 Python 自带的多进程库 Multiprocessing, 就可以进行多核并行计算

2. 定义函数

# 可以定义任何函数
def f(name, param):
    result = 0
    for num in param:
        result += math.sqrt(num * math.tanh(num) / math.log2(num) / math.log10(num))
    return {
    
    name: result}

3. 设置任务进行测试

if __name__ == '__main__':
    # 核心数量: cpu_count() 函数可以获得计算机的核心数量。
    num_cores = int(mp.cpu_count())
    print("本计算机总共有: " + str(num_cores) + " 核心")

    # 进程池: Pool() 函数创建了一个进程池类，用来管理多进程的生命周期和资源分配。
    #        这里进程池传入的参数是核心数量，意思是最多有多少个进程可以进行并行运算。

    param_dict = {
    
    'task1': list(range(10, 3000000)),
                  'task2': list(range(3000000, 6000000)),
                  'task3': list(range(6000000, 9000000)),
                  'task4': list(range(9000000, 12000000)),
                  'task5': list(range(12000000, 15000000)),
                  'task6': list(range(15000000, 18000000)),
                  'task7': list(range(18000000, 21000000)),
                  'task8': list(range(21000000, 24000000)),
                  'task9': list(range(24000000, 27000000)),
                  'task10': list(range(27000000, 30000000)),
                  'task11': list(range(30000000, 33000000)),
                  'task12': list(range(33000000, 36000000)),
                  'task13': list(range(36000000, 39000000)),
                  'task14': list(range(39000000, 42000000)),
                  'task15': list(range(42000000, 45000000)),
                  'task16': list(range(45000000, 48000000))
                  }
    # 异步调度: apply_async() 是进程池的一个调度函数。第一个参数是计算函数.第二个参数是需要传入计算函数的参数，这里传入了计算函数名字和计算调参。
    #          异步的意义是在调度之后，虽然计算函数开始运行并且可能没有结束，异步调度都会返回一个临时结果，并且通过列表生成器临时保存在一个列表-results里。

    cores = [1,2,4,8,12,16]
    for i in cores:
        if i < num_cores:
            pool = mp.Pool(i)
        else:
            pool = mp.Pool(num_cores)

        start_t = datetime.datetime.now()
        results = [pool.apply_async(f, args=(name, param)) for name, param in param_dict.items()]
        # 调度结果: 如果检查列表 results 里的类，会发现 apply_async() 返回的是 ApplyResult，也就是 调度结果类。
        #          简单来说，就是一个用来等待异步结果生成完毕的容器。
        # 获取结果: 调度结果 ApplyResult 类可以调用函数 get(), 这是一个非异步函数，
        #          也就是说 get() 会等待计算函数处理完毕，并且返回结果。
        #          这里的结果就是计算函数的 return。
        results = [p.get() for p in results]

        end_t = datetime.datetime.now()
        elapsed_sec = (end_t - start_t).total_seconds()
        print("进程数为%d"%i + "计算共消耗: " + "{:.2f}".format(elapsed_sec) + " 秒")

4. 测试结果

  实验测试环境是具有16核笔记本电脑。从以上测试结果可以看出，进程数增加，时间总体下降；但是当进程数过多的时候，互相之间的通信可能也会占用一些时间，导致时间增加。

参考

[1] python 多核并行计算