当前位置：首页 > article >正文

【30天玩转python】多线程与多进程编程

article 2024/9/26 1:16:33

多线程与多进程编程

在 Python 中，多线程和多进程是实现并发编程的重要手段。多线程适用于 I/O 密集型任务，而多进程则更适合 CPU 密集型任务。通过合理使用多线程和多进程，可以有效提升程序的执行效率和性能。

1. 多线程编程

1.1 线程的概念

线程是操作系统能够进行调度的最小单位。每个线程包含了一个独立的执行路径，多个线程可以在同一个进程内共享内存和资源。Python 中的多线程编程主要使用 threading 模块。

1.2 创建多线程

在 Python 中，可以通过继承 threading.Thread 类来创建新的线程，也可以使用 threading 模块直接创建线程对象。

示例：创建并启动线程

import threading
import time

def print_numbers():
    for i in range(1, 6):
        time.sleep(1)
        print(f"Number: {i}")

# 创建线程
t = threading.Thread(target=print_numbers)

# 启动线程
t.start()

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

print("线程执行完毕")

在这个例子中，print_numbers 函数会在新线程中运行，主线程继续等待直到新线程执行完毕后，才打印“线程执行完毕”。

1.3 使用继承创建线程

class MyThread(threading.Thread):
    def run(self):
        for i in range(1, 6):
            time.sleep(1)
            print(f"MyThread Number: {i}")

# 创建并启动线程
t = MyThread()
t.start()
t.join()

1.4 线程锁（Lock）

在多线程环境下，由于多个线程共享内存和资源，可能会出现竞争条件（race condition），从而导致数据不一致或错误。为了解决这个问题，可以使用线程锁（threading.Lock）来同步线程。

示例：使用线程锁

lock = threading.Lock()
counter = 0

def increment_counter():
    global counter
    for _ in range(1000000):
        with lock:
            counter += 1

t1 = threading.Thread(target=increment_counter)
t2 = threading.Thread(target=increment_counter)

t1.start()
t2.start()

t1.join()
t2.join()

print(f"Final counter: {counter}")

在这个例子中，使用 with lock 确保每个线程在修改 counter 时，不会同时被其他线程修改，从而避免竞争条件。

2. 多进程编程

2.1 进程的概念

进程是资源分配的最小单位，每个进程都有自己独立的内存空间。多进程编程可以通过创建多个独立的进程来实现并发。Python 中的多进程编程主要使用 multiprocessing 模块。

2.2 创建多进程

multiprocessing.Process 类提供了与 threading.Thread 类类似的 API，用于创建新进程。

示例：创建并启动进程

import multiprocessing
import time

def print_numbers():
    for i in range(1, 6):
        time.sleep(1)
        print(f"Process Number: {i}")

# 创建进程
p = multiprocessing.Process(target=print_numbers)

# 启动进程
p.start()

# 等待进程执行完毕
p.join()

print("进程执行完毕")

与多线程不同的是，每个进程都有独立的内存空间，因此需要通过进程间通信（IPC）机制来共享数据。

2.3 使用继承创建进程

class MyProcess(multiprocessing.Process):
    def run(self):
        for i in range(1, 6):
            time.sleep(1)
            print(f"MyProcess Number: {i}")

# 创建并启动进程
p = MyProcess()
p.start()
p.join()

2.4 进程间通信

由于进程之间不共享内存，因此需要通过管道（Pipe）或队列（Queue）来实现进程间通信。

示例：使用队列进行进程间通信

import multiprocessing

def worker(q):
    q.put([42, None, 'hello'])

if __name__ == "__main__":
    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=worker, args=(q,))
    p.start()
    print(q.get())  # 从队列中获取数据
    p.join()

在这个例子中，主进程通过队列与子进程通信，子进程将数据放入队列，主进程从队列中读取数据。

3. 多线程 vs 多进程

特性	多线程	多进程
内存共享	线程间共享内存	进程间不共享内存
创建开销	线程创建开销较小	进程创建开销较大
适用场景	I/O 密集型任务（如文件读写、网络）	CPU 密集型任务（如复杂计算）
数据隔离	线程间数据不隔离，需同步	进程间数据完全隔离，需通信
并行性	受限于 Python 的 GIL（全局解释器锁）	进程可以真正并行执行
故障隔离	一个线程崩溃可能影响整个进程	进程崩溃不会影响其他进程

4. Global Interpreter Lock (GIL)

Python 中的全局解释器锁（GIL）限制了多个线程同时执行 Python 字节码。尽管可以使用多线程，但在 CPU 密集型任务中，GIL 会导致 Python 程序无法真正并行执行。因此，CPU 密集型任务通常使用多进程来绕过 GIL 的限制。

5. 线程池与进程池

如果需要管理大量线程或进程，使用线程池或进程池会更高效。Python 提供了 concurrent.futures.ThreadPoolExecutor 和 concurrent.futures.ProcessPoolExecutor 来简化多线程和多进程的管理。

5.1 使用线程池

from concurrent.futures import ThreadPoolExecutor

def task(n):
    return n * 2

with ThreadPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(task, i) for i in range(5)]
    for future in futures:
        print(future.result())

5.2 使用进程池

from concurrent.futures import ProcessPoolExecutor

def task(n):
    return n * 2

with ProcessPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(task, i) for i in range(5)]
    for future in futures:
        print(future.result())