Python并发编程基础

最新推荐文章于 2024-11-13 17:26:18 发布

大数据左右手

最新推荐文章于 2024-11-13 17:26:18 发布

阅读量955

点赞数 9

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/Hello_Java2018/article/details/136162355

版权

Python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

多线程并发

Python的多线程并发是基于threading模块实现的，其核心原理是利用线程切换技术来实现CPU级别的并发执行。这种并发执行并不等同于多CPU的并行操作，而是在单个CPU上通过快速切换线程来模拟同时处理多个任务的效果。

示范

import threading

def print_numbers():
    for i in range(10):
        print(i)

def print_letters():
    for letter in 'asdfghjkl':
        print(letter)

# 创建两个线程
t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_letters)

# 启动线程
t1.start()
t2.start()

# 等待线程执行完毕
t1.join()
t2.join()

join() 解释

join() 在多线程编程中，是一个用来等待线程终止的方法。

join()方法是用来阻塞主线程，直到目标线程执行完毕。当调用一个线程对象的join()方法时，主线程会被挂起，直到该线程对象完成其执行。这是为了确保主线程能在所有子线程完成后再继续执行，特别是在需要汇总或处理由多个线程产生的结果时尤为重要。

import threading
import time

def worker():
    print("Worker started")
    time.sleep(2)  # 模拟耗时操作
    print("Worker finished")

t = threading.Thread(target=worker)
t.start()

print("Main thread is waiting for worker thread to finish")
t.join()  # 主线程等待子线程执行完毕
print("Main thread continues after worker thread has finished")

创建了一个名为worker的线程，它会在2秒后打印"Worker finished"。然后我们在主线程中调用了t.join()，这会导致主线程阻塞，直到worker线程执行完毕。输出结果如下：

Worker started
Main thread is waiting for worker thread to finish
Worker finished
Main thread continues after worker thread has finished

多CPU并行

在计算机系统中，多个CPU同时执行不同的任务，以提高系统的处理能力和效率。在Python中，可以使用multiprocessing模块来实现多CPU并行，其实也叫多进程。

示范

import multiprocessing

def worker(num):
    """线程函数"""
    print('Worker:', num)

if __name__ == '__main__':
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        p.start()

多协程

多协程是指在一个线程中运行多个协程，它们通过任务的暂停和恢复来避免线程切换的开销，并且减少了锁的使用。

示范

import asyncio

async def worker(num):
    """协程函数"""
    print('Worker:', num)
    await asyncio.sleep(1)  # 模拟耗时操作

async def main():
    tasks = []
    for i in range(5):
        task = asyncio.create_task(worker(i))  # 创建协程任务
        tasks.append(task)
    await asyncio.gather(*tasks)  # 并发执行协程任务

if __name__ == '__main__':
    asyncio.run(main())

async def

async def 用于声明一个异步函数，即协程函数。这种函数的定义与普通函数类似，但包含 async 关键字，表示该函数是一个协程函数。

await

它用于挂起当前协程的执行，直到等待的操作完成。

await作用如下：

暂停执行：当协程遇到 await 表达式时，它会暂停当前的执行，让出控制权给事件循环。这样，其他协程或任务可以继续执行，从而实现并发。
恢复执行：当 await 后面的表达式（通常是另一个协程或异步操作）完成后，原协程会恢复执行。

import asyncio

async def fetch_data():
    print('Start fetching data...')
    await asyncio.sleep(2)
    print('Data fetched')

async def main():
    task = asyncio.create_task(fetch_data())
    print('Do something else...')
    await asyncio.sleep(1)
    print('Waiting for data...')
    await task
    print('Data received')

asyncio.run(main())

定义了两个协程函数：fetch_data 和 main。fetch_data 模拟了一个耗时的异步操作，它使用 await 来暂停当前协程的执行，等待2秒钟。而 main 则创建了一个任务（Task），并在等待1秒后使用 await 等待该任务完成。当任务完成后，main 会继续执行并打印出 "Data received"。

Do something else...
Start fetching data...
Waiting for data...
Data fetched
Data received

三者对比

多线程

优点

线程的创建和切换成本相对较低，对于I/O密集型任务，多线程可以在等待I/O操作时释放GIL，使得其他线程得以执行，从而提高程序的整体效率。

缺点

由于Python的GIL（全局解释器锁），多线程在CPU密集型任务中可能无法充分利用多核CPU的优势，因为同一时刻只有一个线程能够执行Python字节码。

场景

适合I/O密集型任务，如文件读写、网络请求等。

多进程

优点

每个进程拥有自己的内存空间和解释器，不受GIL的限制，可以充分利用多核CPU的优势，适合执行CPU密集型任务。

缺点

进程间的通信和数据共享相对复杂，且进程的创建和管理成本高于线程。

场景

适合CPU密集型任务，如大规模数值计算、图像处理等。

多协程

优点

协程是一种用户态的轻量级线程，它们通过事件循环来调度，可以在单线程内实现高并发。协程的创建和切换成本非常低，对于IO密集型任务尤其高效。

缺点

协程虽然轻量级，但仍然受限于GIL，对于CPU密集型任务，单独使用协程可能无法发挥最大效能。

场景

适合IO密集型任务，如Web服务器、异步数据处理等。

所以，对于IO密集型任务，可以考虑使用多线程或协程，而对于CPU密集型任务，则推荐使用多进程。在某些情况下，还可以将多进程与协程结合使用，以充分利用CPU资源并获得极高的性能。

理解GIL

Python的全局解释器锁（Global Interpreter Lock，GIL）是CPython解释器（Python的默认实现）中的一个技术细节。GIL是一个互斥锁，它确保了同一时刻只有一个线程能够执行Python字节码。这意味着在多线程环境下，即使有多个CPU核心，也只能有一个线程在执行Python代码。