Python-实现高并发的常见方式

高并发能帮支持快速处理大量执行任务，提高代码的执行效率，以下是在日常开发中常见的高并发方式

1. 多线程（Threading）
   Python 的 threading 模块可以非常容易地创建和管理线程。线程共享内存空间，这意味着它们可以更高效的进行I/O操作。但是，由于Python的全局解释器锁（GIL），同一时刻只允许一个线程执行Python字节码。因此，多线程在CPU密集型任务上效果不佳，但适用于I/O密集型任务。

2. 多进程（Multiprocessing）
   Python 的 multiprocessing 模块提供了一个开销较大但可以利用多核CPU优势的并发执行功能。每个进程有自己的内存空间和解释器，因此可以避开GIL的限制。适合CPU密集型任务。

3. 异步（Asyncio）
   Python 3.4 引入的 asyncio 模块允许进行异步编程，你可以使用 async 和 await 关键字编写看起来像同步代码的异步代码。它是基于事件循环的，适合I/O密集型任务，能够在单个线程内实现高并发。

4. 协程（Coroutines）
   协程是一种比线程更加轻量级的单元，它利用了异步执行的优势。与线程不同的是，协程的调度完全由程序控制，协程之间的切换不需要上下文切换的开销。asyncio 是建立在协程之上的。

5. 网络库/框架
   有些Python网络库如Tornado、Twisted和Gevent利用非阻塞网络I/O进行操作，可以轻松实现高并发。这些库通常自带一个事件循环，并且可以处理成千上万的并发连接。

6. 进程池/线程池（Pool）
   multiprocessing 和 concurrent.futures 模块提供了进程池和线程池，允许开发者方便地映射出一组函数调用到一个进程或线程池中。池可以根据系统资源自动创建和销毁工作进程/线程，并管理它们的任务队列。

每种方式都有其适用的场景和局限性，选择哪种方式取决于具体的应用场景和性能要求。例如，对于I/O密集型应用，使用异步I/O（如asyncio）或者Tornado这样的非阻塞网络框架会是个不错的选择；而对于CPU密集型应用，则可能需要使用多进程来充分利用多核CPU的优势。

代码示例

# 1.使用 threading 模块

import threading

def worker():
    """线程要执行的任务"""
    print("Task in progress")

# 创建多个线程
threads = []
for _ in range(5):
    t = threading.Thread(target=worker)
    threads.append(t)
    t.start()

# 等待所有线程执行完成
for t in threads:
    t.join()
# 使用 concurrent.futures 模块中的 ThreadPoolExecutor 或 ProcessPoolExecutor

from concurrent.futures import ThreadPoolExecutor

def worker():
    """任务"""
    print("Task in progress")

# 2. 使用 ThreadPoolExecutor 创建线程池，并提交任务
with ThreadPoolExecutor() as executor:
    futures = [executor.submit(worker) for _ in range(5)]

# 获取任务的执行结果
for future in futures:
    result = future.result()
# 3.使用 asyncio 模块（适用于异步 I/O 操作）
# 示例1
import asyncio

async def worker():
    """异步任务"""
    print("Task in progress")

# 创建事件循环并运行异步任务
loop = asyncio.get_event_loop()
tasks = [worker() for _ in range(5)]
loop.run_until_complete(asyncio.gather(*tasks))
# 示例2
import asyncio

async def hello_concurrency(index):
    print(f"Hello, concurrency! ({index})")
    await asyncio.sleep(1)
    print(f"Goodbye, concurrency! ({index})")

async def run_concurrent_tasks():
    tasks = []
    for i in range(10):  # 创建10个并发任务
        task = asyncio.create_task(hello_concurrency(i))
        tasks.append(task)
    await asyncio.gather(*tasks)  # 并发运行所有任务

# 运行事件循环
asyncio.run(run_concurrent_tasks())

# 4. 使用 multiprocessing 模块（适用于 CPU 密集型任务）
import multiprocessing

def worker():
    """进程要执行的任务"""
    print("Task in progress")

# 创建多个进程
processes = []
for _ in range(5):
    p = multiprocessing.Process(target=worker)
    processes.append(p)
    p.start()

# 等待所有进程执行完成
for p in processes:
    p.join()