Python高级篇—多线程、多进程、协程、异步编程的概念与实现-51CTO.COM

Python 的并发编程是指在程序中同时执行多个任务的能力，以提高程序的效率和性能。常用的并发编程方式包括多线程、多进程、协程和异步编程。

多线程

多线程是指在一个进程内，同时执行多个线程，每个线程负责执行一个子任务。多线程可以提高程序的并发性，加速程序执行速度。Python 提供了 threading 模块来实现多线程编程。

下面是一个简单的多线程示例：

import threading

def worker(num):
    print(f"Thread {num} is running")

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

输出结果：

Thread 0 is running
Thread 1 is running
Thread 2 is running
Thread 3 is running
Thread 4 is running1.
2.
3.
4.
5.

多进程

多进程是指在一个程序中同时执行多个进程，每个进程负责执行一个子任务。多进程可以利用多核 CPU 提高程序的并发性，加速程序执行速度。Python 提供了 multiprocessing 模块来实现多进程编程。

下面是一个简单的多进程示例：

import multiprocessing

def worker(num):
    print(f"Process {num} is running")

processes = []
for i in range(5):
    p = multiprocessing.Process(target=worker, args=(i,))
    processes.append(p)
    p.start()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

输出结果：

Process 0 is running
Process 1 is running
Process 2 is running
Process 3 is running
Process 4 is running1.
2.
3.
4.
5.

线程同步和互斥

在多线程编程中，由于多个线程同时访问共享资源可能导致数据不一致或其他问题。因此，需要进行线程同步和互斥操作，以保证程序的正确性和可靠性。

Python 提供了多种线程同步和互斥机制，如锁（Lock）、信号量（Semaphore）、事件（Event）等。下面是一个使用锁实现线程同步的示例：

import threading

num = 0
lock = threading.Lock()

def worker():
    global num
    for i in range(100000):
        with lock:
            num += 1

threads = []
for i in range(5):
    t = threading.Thread(target=worker)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"num = {num}")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

输出结果：

num = 5000001.

协程和异步编程

协程是一种轻量级的线程，可以在单线程中实现多任务的并发执行。协程不需要线程切换的开销，可以更高效地利用 CPU 资源。Python 提供了 asyncio 模块来实现协程和异步编程。

下面是一个简单的协程示例：

import asyncio

async def worker(num):
    print(f"Coroutine {num} is running")
    await asyncio.sleep(1)
    print(f"Coroutine {num} is done")

async def main():
    coroutines = [worker(i) for i in range(5)]
    await asyncio.gather(*coroutines)

asyncio.run(main())1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

输出结果：

Coroutine 0 is running
Coroutine 1 is running
Coroutine 2 is running
Coroutine 3 is running
Coroutine 4 is running
Coroutine 0 is done
Coroutine 1 is done
Coroutine 2 is done
Coroutine 3 is done
Coroutine 4 is done1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

在异步编程中，常常需要使用回调函数来处理异步操作的结果。Python 3.5 引入了 async 和 await 关键字，使得异步编程更加易读易写。下面是一个使用 async 和 await 实现异步编程的示例：

import asyncio

async def worker(num):
    print(f"Task {num} is running")
    await asyncio.sleep(1)
    return f"Task {num} is done"

async def main():
    tasks = [asyncio.create_task(worker(i)) for i in range(5)]
    results = await asyncio.gather(*tasks)
    for result in results:
        print(result)

asyncio.run(main())1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

输出结果：

Task 0 is running
Task 1 is running
Task 2 is running
Task 3 is running
Task 4 is running
Task 0 is done
Task 1 is done
Task 2 is done
Task 3 is done
Task 4 is done1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

总之，Python 并发编程提供了多种实现方式，开发者可以根据实际情况选择最适合的方式来提高程序的执行效率和并发性能。同时，在编写并发程序时需要注意线程安全、进程间通信等问题，以保证程序的正确性和稳定性。