Python并发编程：多线程与多进程实践_python并发适合多线程还是多进程

一、并发编程基础概念

1.1 什么是并发编程

并发编程是指计算机系统中同时执行多个独立的计算任务。这些任务可以同时执行也可以按照一定的调度策略交替执行。在并发编程中执行的任务需要独立管理自身的资源，且需要与其他任务共享资源。

1.2 为什么需要并发编程

在现代计算机系统中单个CPU的处理速度已经很快了。然而现代应用程序通常需要处理大量的任务和数据，单个CPU无法满足这些需求。因此需要使用多个线程或进程并发处理这些任务和数据，以提高应用程序的执行效率和响应速度。

1.3 并发编程的挑战

虽然并发编程可以提高程序执行效率，但同时也带来了一些挑战：

• 数据竞争：如果多个线程或进程同时访问共享数据，可能导致数据竞争，从而产生错误和不可预知的结果。
• 死锁：如果多个线程或进程在等待其他线程或进程释放锁时互相等待，将导致死锁。
• 上下文切换：线程或进程之间的切换需要涉及上下文切换，这会导致一定的系统开销。

二、Python并发编程介绍

2.1 Python的多线程模块

Python提供了threading模块用于创建和管理多个线程。以下是一个简单的例子：

import threading

def worker():
    """Thread worker function"""
    print('This is a thread')

# Create threads
thread1 = threading.Thread(target=worker)
thread2 = threading.Thread(target=worker)

# Start threads
thread1.start()
thread2.start()

# Wait for threads to finish
thread1.join()
thread2.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上述代码创建了两个线程分别执行worker()函数。使用start()函数启动线程，使用join()函数等待线程执行完毕。

2.2 Python的多进程模块

Python提供了multiprocessing模块可以在多个进程中并发运行Python代码。以下是一个简单的例子：

import multiprocessing

def worker():
    """Process worker function"""
    print('This is a process')

# Create processes
process1 = multiprocessing.Process(target=worker)
process2 = multiprocessing.Process(target=worker)

# Start processes
process1.start()
process2.start()

# Wait for processes to finish
process1.join()
process2.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上述代码创建了两个进程分别执行worker()函数。使用start()函数启动进程，使用join()函数等待进程执行完毕。

2.3 协程与异步IO编程

Python提供了asyncio库可以通过协程和异步IO编程实现高效的并发处理。以下是一个简单的例子：

import asyncio

async def worker():
    """Asyncio worker function"""
    print('This is a coroutine')

# Create event loop
loop = asyncio.get_event_loop()

# Create tasks
task1 = loop.create_task(worker())
task2 = loop.create_task(worker())

# Wait for tasks to finish
loop.run_until_complete(asyncio.gather(task1, task2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上述代码创建了两个协程使用create_task()函数将其转换为任务。使用run_until_complete()函数等待任务执行完毕。

三、Python多线程编程实践

在现代计算机系统中单个CPU的处理速度已经很快了。然而现代应用程序通常需要处理大量的任务和数据，单个CPU无法满足这些需求。因此使用多个线程并发处理这些任务和数据，以提高应用程序的执行效率和响应速度。接下来将介绍Python中的多线程编程实践。

3.1 线程的创建

Python中创建线程非常简单只需使用threading模块即可。以下是一个简单的例子：

import threading

# 定义线程执行的函数
def worker():
    print('This is a thread')

# 创建线程
thread = threading.Thread(target=worker)

# 启动线程
thread.start()

# 等待线程执行完毕
thread.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上述代码创建了一个线程使用start()函数启动它，使用join()函数等待线程执行完毕。

3.2 线程的生命周期

线程的生命周期包括以下几个阶段：

• 创建阶段：线程被创建，但尚未执行。
• 就绪阶段：线程已经准备好执行，等待CPU资源。
• 执行阶段：线程正在执行其任务。
• 阻塞阶段：线程暂时被挂起，等待某个事件的发生。
• 终止阶段：线程执行完毕，或由于异常终止。

3.3 线程同步与互斥

在多线程编程中可能会涉及共享资源的访问问题，如果多个线程同时访问同一个共享资源，会导致数据竞争和错误的结果。因此需要使用线程同步和互斥机制。

3.3.1 Lock

Lock是一种简单的互斥机制用于保护共享资源的访问。以下是一个简单的例子：

import threading

# 定义共享变量
count = 0

# 定义锁
lock = threading.Lock()

# 定义计数函数
def counter():
    global count
    for i in range(1000000):
        lock.acquire()
        count += 1
        lock.release()

# 创建线程
thread1 = threading.Thread(target=counter)
thread2 = threading.Thread(target=counter)

# 启动线程
thread1.start()
thread2.start()

# 等待线程执行完毕
thread1.join()
thread2.join()

# 输出计数结果
print(count)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

上述代码使用Lock保护共享变量的访问，确保每个线程都可以正确地访问和修改共享变量。

3.3.2 RLock

RLock是一种可重入的互斥机制，允许同一个线程对同一个锁进行多次加锁和解锁。以下是一个简单的例子：

import threading

# 定义共享变量
count = 0

# 定义锁
lock = threading.RLock()

# 定义计数函数
def counter():
    global count
    for i in range(1000000):
        lock.acquire()
        lock.acquire()  # 多次加锁
        count += 1
        lock.release()
        lock.release()  # 多次解锁

# 创建线程
thread1 = threading.Thread(target=counter)
thread2 = threading.Thread(target=counter)

# 启动线程
thread1.start()
thread2.start()

# 等待线程执行完毕
thread1.join()
thread2.join()

# 输出计数结果
print(count)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

上述代码使用RLock保护共享变量的访问，允许同一个线程对同一个锁进行多次加锁和解锁。

3.4 线程通信

在多线程编程中可能需要线程之间进行通信，以共享数据或进行协作。Python提供了多种方式来实现线程之间的通信。

3.4.1 队列

队列是一种线程安全的数据结构可以用来进行线程之间的通信。以下是一个简单的例子：

import threading
import queue

# 定义队列
q = queue.Queue()

# 定义生产者函数
def producer():
    for i in range(10):
        q.put(i)
        print('生产者生产了', i)
        
# 定义消费者函数
def consumer():
    while True:
        item = q.get()
        if item is None:
            break
        print('消费者消费了', item)

# 创建线程
thread1 = threading.Thread(target=producer)
thread2 = threading.Thread(target=consumer)

# 启动线程
thread1.start()
thread2.start()

# 等待生产者线程执行完毕
thread1.join()

# 将None添加到队列中，通知消费者线程结束
q.put(None)

# 等待消费者线程执行完毕
thread2.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

上述代码使用队列实现了生产者-消费者模式，实现了线程之间的通信。

3.5 线程池与队列

线程池是一种常见的优化多线程程序的方式，可以有效地复用线程，避免频繁地创建和销毁线程。Python提供了concurrent.futures模块，可以很容易地创建和管理线程池。以下是一个简单的例子：

import concurrent.futures
import time

# 定义任务函数
def worker(i):
    print('Thread', i, 'start')
    time.sleep(1)
    print('Thread', i, 'end')

# 创建线程池
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    # 提交任务
    futures = [executor.submit(worker, i) for i in range(10)]
    
    # 等待任务完成
    for future in concurrent.futures.as_completed(futures):
        result = future.result()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上述代码创建了一个包含3个线程的线程池，提交了10个任务。使用as_completed()函数等待任务执行完毕。

除了常规的线程池外，Python还提供了使用队列实现的线程池，可以更好地控制任务的执行方式。以下是一个简单的例子：

import concurrent.futures
import time
import queue

# 定义任务函数
def worker(i, q):
    print('Thread', i, 'start')
    item = q.get()
    time.sleep(1)
    print('Thread', i, 'finish', item)
    q.task_done()
    
# 定义任务队列
q = queue.Queue()

# 向队列中添加任务
for i in range(10):
    q.put(i)

# 创建线程池
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    # 提交任务
    futures = [executor.submit(worker, i, q) for i in range(3)]
    
    # 等待任务完成
    q.join()
    
    # 取消未执行的任务
    for future in futures:
        future.cancel()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

上述代码使用队列实现了线程池，对于每个任务，只有一个线程可以执行，避免了竞争的情况。使用队列的join()函数等待所有任务完成。未执行的任务可以使用cancel()函数取消。

四、Python协程与异步IO编程实践接

下面将介绍Python中的协程与异步IO编程实践

1 协程的概念与实现

1.1 协程的概念

协程是一种轻量级的线程可以在单个线程内部实现并发执行。协程能够在不同的执行点之间暂停和继续执行，类似于线程的上下文切换。协程的优点在于避免了线程的创建和上下文切换开销，同时也避免了多线程程序中可能存在的数据竞争和锁问题。

1.2 协程的实现

Python的协程通过生成器实现使用yield语句来暂停和恢复协程的执行。以下是一个简单的例子：

# 定义协程函数
def coroutine():
    print('Coroutine start')
    while True:
        value = yield
        print('Coroutine received:', value)
        
# 创建协程对象
coro = coroutine()

# 启动协程
next(coro)

# 向协程发送数据
coro.send('data1')
coro.send('data2')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上述代码创建了一个协程对象，使用yield语句来暂停和恢复协程的执行。使用next()函数启动协程，使用send()函数向协程发送数据。

2 使用asyncio进行异步编程

Python提供了asyncio模块可以很容易地进行协程和异步IO编程。asyncio提供了一个事件循环(Event Loop)，可以在单线程中实现异步的协程调度和IO操作。

2.1 基本概念与用法

以下是一个简单的例子展示了如何创建和启动一个协程，以及如何使用事件循环：

import asyncio

# 定义协程函数
async def coroutine():
    print('Coroutine start')
    await asyncio.sleep(1)
    print('Coroutine end')

# 创建事件循环
loop = asyncio.get_event_loop()

# 启动协程
loop.run_until_complete(coroutine())

# 关闭事件循环
loop.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上述代码中使用async关键字定义了一个协程函数，使用await关键字来暂停和恢复协程的执行。使用asyncio.get_event_loop()函数创建事件循环，使用loop.run_until_complete()函数启动协程，并等待协程执行结束。最后使用loop.close()函数关闭事件循环。

2.2 协程的并发执行

asyncio可以很容易地实现多个协程的并发执行。以下是一个简单的例子：

import asyncio

# 定义协程函数
async def coroutine(i):
    print('Coroutine', i, 'start')
    await asyncio.sleep(1)
    print('Coroutine', i, 'end')

# 创建事件循环
loop = asyncio.get_event_loop()

# 启动多个协程
coros = [coroutine(i) for i in range(5)]
loop.run_until_complete(asyncio.gather(*coros))

# 关闭事件循环
loop.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上述代码创建了多个协程对象使用asyncio.gather()函数启动这些协程，并等待它们执行完毕。使用*coros语法将协程列表解包为单独的参数。

3 实现异步IO操作

除了协程的并发执行外，asyncio还提供了异步IO操作的实现，以提高应用程序的执行效率和响应速度。以下是一个简单的例子，展示了如何使用异步IO进行文件的读取和写入：

import asyncio

# 定义异步IO操作函数
async def file_io():
    # 打开文件
    with open('test.txt', 'r') as f1, open('output.txt', 'w') as f2:
        # 读取文件
        data = await f1.read()
        
        # 写入文件
        await f2.write(data)
        
# 创建事件循环
loop = asyncio.get_event_loop()

# 启动异步IO操作
loop.run_until_complete(file_io())

# 关闭事件循环
loop.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上述代码使用async with语法打开文件，并使用await关键字进行异步IO操作。在文件读取和写入操作之间使用await asyncio.sleep()函数来模拟IO操作的延迟。

除此之外asyncio还提供了许多其他的异步IO操作，如TCP连接、UDP连接、HTTP请求等可以根据需要进行选择和使用。