Python的 multiprocessing 模块是一个多进程模块，它允许你创建新的进程，就像你创建新的线程一样。
Python的 multiprocessing 模块提供了一个Process类 来代表一个进程对象。multiprocessing模块的API和threading模块非常相似，所以如果你熟悉线程的编程，那么你会发现使用multiprocessing模块创建多进程是很直观的。
创建的新进程有自己的Python解释器和内存空间，因此它们可以并行运行，并且不受全局解释器锁（GIL）的限制，这使得multiprocessing模块对于CPU密集型任务特别有效。
同时，multiprocessing模块还提供了一些强大的功能，比如进程间的通信、共享状态、进程池等等，这使得我们可以更好地管理和控制多进程的行为。
（一）先来个简单的例子：
正常我们打印一个list的值是按顺序的：
def process_data(i):
print(f'Process {i} is processing data.')
if __name__ == "__main__":
data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in data_list:
process_data(i)
运行结果：
Process 1 is processing data.
Process 2 is processing data.
Process 3 is processing data.
Process 4 is processing data.
Process 5 is processing data.
Process 6 is processing data.
Process 7 is processing data.
Process 8 is processing data.
Process 9 is processing data.
Process 10 is processing data.
使用多线程实现打印：使用multiprocessing模块来创建多进程。
下面是一个示例，在此示例中，每个进程都会处理列表中的一个元素：
from multiprocessing import Process
def process_data(i):
print(f'Process {i} is processing data.')
if __name__ == "__main__":
data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
processes = []
for i in data_list:
p = Process(target=process_data, args=(i,))
processes.append(p)
p.start()
for p in processes:
p.join()
运行结果：
Process 1 is processing data.
Process 2 is processing data.
Process 3 is processing data.
Process 4 is processing data.
Process 5 is processing data.
Process 6 is processing data.
Process 7 is processing data.
Process 8 is processing data.
Process 9 is processing data.
Process 10 is processing data.
需要说明一下：join()方法是Python中multiprocessing和threading模块的一部分。在多进程和多线程编程中，join()方法的主要功能是等待进程或线程完成。
当你在一个进程或线程对象上调用join()方法时，调用它的线程（通常是主线程）会被阻塞，直到被join()的进程或线程完成。
在多进程或多线程编程中，join()方法很重要，因为它可以确保在主线程（或任何其他线程）中正确地等待其他线程或进程完成。这通常对于同步操作，以及在退出程序之前清理和完成所有的并行操作，是必要的。
在你给出的代码中，join()方法被用于确保所有的进程都完成了它们的工作，然后主进程（运行这段代码的进程）可以继续进行。
（二）
言归正传，上面的代码看不出来是否是同时进行的，那么我们加一个sleep时间进去，让每个线程运行时先睡一觉：
from multiprocessing import Process
import time
import random
def process_data(i, time_to_sleep):
time.sleep(time_to_sleep)
print(f'Process {i} is processing data, sleeping for {time_to_sleep} seconds.')
if __name__ == "__main__":
data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
processes = []
for i in data_list:
time_to_sleep = random.randint(1, 5)
p = Process(target=process_data, args=(i,time_to_sleep,))
processes.append(p)
p.start()
for process in processes:
process.join()
运行结果：
Process 2 is processing data, sleeping for 2 seconds.
Process 7 is processing data, sleeping for 2 seconds.
Process 3 is processing data, sleeping for 2 seconds.
Process 6 is processing data, sleeping for 2 seconds.
Process 1 is processing data, sleeping for 3 seconds.
Process 9 is processing data, sleeping for 4 seconds.
Process 4 is processing data, sleeping for 4 seconds.
Process 5 is processing data, sleeping for 4 seconds.
Process 10 is processing data, sleeping for 5 seconds.
Process 8 is processing data, sleeping for 5 seconds.
这样就能看到，睡的时间短的线程先完成。
（三）
接下来，我们把cpu 数加进去，让它在规定数量的cpu中运行，一次启动等于CPU核心数量的进程，然后当这些进程完成时启动新的进程。这样可以确保并行执行的进程数量不超过CPU核心数量。
这时就要引进queue（队列），queue被用来存储待处理的数据。queue的特点是先入先出（FIFO，First In First Out），这使得我们能按照数据放入queue的顺序依次处理数据。
在这个例子中，data_list中的所有元素都被放入queue中，然后在新的进程启动时从queue中取出。这个方法的好处是，一旦所有的数据都被放入queue，我们就可以不用关心数据是怎么被分配到各个进程的，只需要在每个进程中从queue中取出数据并处理就可以了。
此外，Python的queue模块提供了一种线程安全的数据结构，适用于多线程或多进程之间的数据交换，可以避免因并发访问而引起的数据不一致问题。
from multiprocessing import Process
import multiprocessing
import queue
import time
import random
def process_data(data, time_to_sleep):
time.sleep(time_to_sleep)
print(f'Processing {data} is processing data, sleeping for {time_to_sleep} seconds')
if __name__ == '__main__':
data_list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
processes = []
cpu_cores = multiprocessing.cpu_count()
# Create a Queue to hold the data_list
data_queue = queue.Queue()
for data in data_list:
data_queue.put(data)
while not data_queue.empty():
# Start new processes until we reach cpu_cores
while len(processes) < cpu_cores and not data_queue.empty():
data = data_queue.get()
# sleep random time
time_to_sleep = random.randint(1,5)
# time_to_sleep = 1
p = Process(target=process_data, args=(data,time_to_sleep,))
p.start()
processes.append(p)
# Remove and join any processes that have finished
processes = [p for p in processes if p.is_alive()]
# Wait for all processes to finish
for process in processes:
process.join()
print('Finished Processing')
但需要注意的是，上述代码中的queue是Python的内置queue，它并不支持进程间的通信。如果你需要在不同的进程之间共享数据，你应该使用multiprocessing模块中的Queue，它是设计用来在进程间安全交换信息的。因为这个例子中没有用到进程间的数据交换，就没有使用multiprocessing模块中的Queue。
在这个版本的程序中，我们首先创建一个队列来保存所有的数据，并且一直运行直到队列为空。在每次循环中，我们开始新的进程直到达到cpu_cores数量，并且从队列中移除已完成的进程。当队列为空时，我们仍然会等待所有剩余的进程完成。
这里还可以将cpu_cores手动设置为1，再看看打印效果是不是跟单线程的效果一样（本文不再测试，读者感兴趣的自己测试）
（四）
接下来加大难度，通常情况下我们的data_process函数一般是要返回一个值的，并且在主程序中需要接收这个返回值。
那么如何接收这个值呢？假设我们每个函数都要返回一个字典，在所有的进程结束后，主程序将每个子进程的字典合并成一个大字典。
使用 multiprocessing.Pool 可以更轻松地收集进程返回的结果。 Pool.map 可以自动收集每个进程的结果，并将这些结果作为一个列表返回。下面是一个示例：
from multiprocessing import Pool, cpu_count
import random
import time
def process_data(data):
time_to_sleep = random.randint(1, 5)
time.sleep(time_to_sleep)
print(f'Processing {data} is processing data, sleeping for {time_to_sleep} seconds')
return {data: time_to_sleep}
if __name__ == "__main__":
data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
cpu_cores = cpu_count() # 获取 CPU 核心数
# 使用 Pool 来创建进程池
with Pool(cpu_cores) as pool:
results = pool.map(process_data, data_list ) # 使用 Pool.map 来执行进程并收集结果
# 将结果合并为一个大字典
combined_dict = {}
for result in results:
combined_dict.update(result)
print(combined_dict) # 打印出合并后的大字典
输出结果：
Processing 1 is processing data, sleeping for 1 seconds
Processing 4 is processing data, sleeping for 1 seconds
Processing 7 is processing data, sleeping for 1 seconds
Processing 3 is processing data, sleeping for 2 seconds
Processing 9 is processing data, sleeping for 1 seconds
Processing 6 is processing data, sleeping for 2 seconds
Processing 10 is processing data, sleeping for 2 seconds
Processing 2 is processing data, sleeping for 4 seconds
Processing 8 is processing data, sleeping for 5 seconds
Processing 5 is processing data, sleeping for 5 seconds
{1: 1, 2: 4, 3: 2, 4: 1, 5: 5, 6: 2, 7: 1, 8: 5, 9: 1, 10: 2}
说明：对于multiprocessing.Pool().map()方法，它的设计是这样的：第一个参数是一个函数，第二个参数是一个可迭代对象，其中每个元素都会被作为第一个参数函数的参数。但是，Pool().map()并不能直接处理需要多个参数的函数。对于多参数函数，我们可以使用Pool().starmap()方法，该方法的参数是一个可迭代对象，每一个元素是一个元组，元组的元素会作为函数的参数。
因此，假设你需要给process_data函数传入两个参数，那么你可以这样修改代码：
from multiprocessing import Pool, cpu_count
import time
import random
def process_data(data, time_to_sleep):
time.sleep(time_to_sleep)
print(f'Processing {data} is processing data, sleeping for {time_to_sleep} seconds')
return {data: time_to_sleep}
if __name__ == "__main__":
data_list = [(i, random.randint(1, 5)) for i in range(1, 11)] # 创建一个元组列表，每个元组包含两个参数
cpu_cores = cpu_count()
with Pool(cpu_cores) as pool:
results = pool.starmap(process_data, data_list) # 使用 Pool.starmap() 来执行进程并收集结果
# 将结果合并为一个大字典
combined_dict = {}
for result in results:
combined_dict.update(result)
print(combined_dict) # 打印出合并后的大字典
在这个修改后的例子中，我们首先创建了一个包含元组的列表data_list，其中每个元组包含两个元素，分别是process_data函数需要的两个参数。然后我们使用pool.starmap()函数来处理这个列表，它将会把列表中的每一个元组的元素拆解出来，作为process_data函数的参数。
总结：这次你学会了如果使用python的多线程了吧，根据自己的应用场景，套上面的例子即可。
- cpu_cores的获取：
multiprocessing.cpu_count - 使用 Pool.map 来执行进程并收集结果
- 有参数的和无参数的函数都适用