Python3，如何实现CPU的并行计算，那还不简单，5种方式，这篇就搞定。

# -*- coding:utf-8 -*-
# @Time   : 2023-07-01
# @Author : Carl_DJ
import multiprocessing
def worker(num):
    """子进程的任务函数"""
    print(f'Worker {num} started')
    # 执行一些任务
    print(f'Worker {num} finished')
if __name__ == '__main__':
    # 创建多个子进程
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()
    # 等待所有子进程结束
    for p in processes:
        p.join()
    print('All workers finished')

# -*- coding:utf-8 -*-
# @Time   : 2023-07-01
# @Author : Carl_DJ
import multiprocessing
def task(name):
    print(f"Running task {name}")
if __name__ == "__main__":
    # 创建进程池，最大进程数为4
    pool = multiprocessing.Pool(processes=4)
    # 提交任务到进程池
    for i in range(10):
        pool.apply_async(task, args=(i,))
    # 关闭进程池，不再接受新的任务
    pool.close()
    # 等待所有任务完成
    pool.join()
    print("All tasks completed")

# -*- coding:utf-8 -*-
# @Time   : 2023-07-01
# @Author : Carl_DJ
import multiprocessing
def worker(num):
    print('Worker', num)
if __name__ == '__main__':
    # 创建一个进程池，最大进程数为3
    pool = multiprocessing.Pool(processes=3)
    # 使用进程池执行任务
    for i in range(5):
        pool.apply_async(worker, (i,))
    # 关闭进程池，不再接受新的任务
    pool.close()
    # 等待所有任务完成
    pool.join()

# -*- coding:utf-8 -*-
# @Time   : 2023-07-01
# @Author : Carl_DJ
from queue import Queue
import time
# 创建一个消息队列
message_queue = Queue()
# 生产者函数，向消息队列中添加消息
def producer():
    for i in range(5):
        message = f"Message {i+1}"
        message_queue.put(message)
        print(f"Produced: {message}")
        time.sleep(1)
# 消费者函数，从消息队列中获取消息并处理
def consumer():
    while True:
        message = message_queue.get()
        print(f"Consumed: {message}")
        time.sleep(2)
        message_queue.task_done()
# 创建并启动生产者和消费者线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
producer_thread.start()
consumer_thread.start()
# 等待生产者和消费者线程结束
producer_thread.join()
consumer_thread.join()

# -*- coding:utf-8 -*-
# @Time   : 2023-07-01
# @Author : Carl_DJ
from multiprocessing import Process, Value, Array
# 定义一个共享变量
shared_value = Value('i', 0)
# 定义一个共享数组
shared_array = Array('d', [0.0, 1.0, 2.0, 3.0, 4.0])
# 定义一个函数，用于修改共享变量和数组的值
def modify_shared_data(value, array):
    value.value = 10
    for i in range(len(array)):
        array[i] = i * 2
# 创建一个子进程，传入共享变量和数组
p = Process(target=modify_shared_data, args=(shared_value, shared_array))
p.start()
p.join()
# 打印共享变量和数组的值
print("Shared value:", shared_value.value)
print("Shared array:", shared_array[:])

# -*- coding:utf-8 -*-
# @Time   : 2023-07-01
# @Author : Carl_DJ
import asyncio
async def fetch_data(url):
    print(f"正在请求URL：{url}")
    await asyncio.sleep(2)  # 模拟网络请求延迟
    print(f"请求URL：{url}完成")
    return f"从{url}获取的数据"
async def main():
    urls = [
        "https://www.example.com",
        "https://www.google.com",
        "https://www.baidu.com"
    ]
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(results)
if __name__ == "__main__":
    asyncio.run(main())