Python并发编程：多线程与多进程

大家好，我是涛哥，本文内容来自 涛哥聊Python ，转载请标原创。

更多Python学习内容：http://ipengtao.com

在现代编程中，并发编程是提升程序性能和响应速度的关键技术。Python提供了多线程和多进程两种并发编程方式，适用于不同的应用场景。本文将详细介绍Python中的多线程和多进程编程，包括基本概念、使用方法、优缺点及实际应用，帮助全面掌握并发编程的技巧。

多线程编程

什么是多线程

多线程是一种并发执行多个线程的技术，每个线程都是独立执行的序列，但共享相同的内存空间。多线程适用于I/O密集型任务，例如网络请求、文件读写等。

创建线程

Python中的threading模块提供了创建和管理线程的方法。

示例：创建简单线程

import threading

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

# 创建线程
thread = threading.Thread(target=print_numbers)
# 启动线程
thread.start()
# 等待线程结束
thread.join()

使用类创建线程

可以通过继承threading.Thread类来创建线程类。

示例：使用类创建线程

import threading

class NumberThread(threading.Thread):
    def run(self):
        for i in range(5):
            print(i)

# 创建线程
thread = NumberThread()
# 启动线程
thread.start()
# 等待线程结束
thread.join()

线程同步

多线程共享同一内存空间，因此需要同步机制来避免竞争条件。常用的同步机制包括锁（Lock）和条件变量（Condition）。

示例：使用锁同步线程

import threading

lock = threading.Lock()
counter = 0

def increment():
    global counter
    with lock:
        for _ in range(10000):
            counter += 1

threads = [threading.Thread(target=increment) for _ in range(10)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print(f"最终计数器值: {counter}")

线程间通信

线程间可以通过队列进行通信，Python的queue模块提供了线程安全的队列类。

示例：使用队列通信

import threading
import queue

q = queue.Queue()

def producer():
    for i in range(5):
        q.put(i)
        print(f"生产者: {i}")

def consumer():
    while True:
        item = q.get()
        if item is None:
            break
        print(f"消费者: {item}")

# 创建生产者线程
producer_thread = threading.Thread(target=producer)
# 创建消费者线程
consumer_thread = threading.Thread(target=consumer)

# 启动线程
producer_thread.start()
consumer_thread.start()

# 等待生产者线程结束
producer_thread.join()

# 通知消费者线程结束
q.put(None)
# 等待消费者线程结束
consumer_thread.join()

多进程编程

什么是多进程

多进程是一种并发执行多个进程的技术，每个进程都有独立的内存空间。多进程适用于CPU密集型任务，例如计算密集型操作、图像处理等。

创建进程

Python中的multiprocessing模块提供了创建和管理进程的方法。

示例：创建简单进程

import multiprocessing

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

# 创建进程
process = multiprocessing.Process(target=print_numbers)
# 启动进程
process.start()
# 等待进程结束
process.join()

使用类创建进程

可以通过继承multiprocessing.Process类来创建进程类。

示例：使用类创建进程

import multiprocessing

class NumberProcess(multiprocessing.Process):
    def run(self):
        for i in range(5):
            print(i)

# 创建进程
process = NumberProcess()
# 启动进程
process.start()
# 等待进程结束
process.join()

进程间通信

进程间可以通过队列或管道进行通信，Python的multiprocessing模块提供了进程安全的队列和管道。

示例：使用队列通信

import multiprocessing

def producer(queue):
    for i in range(5):
        queue.put(i)
        print(f"生产者: {i}")

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(f"消费者: {item}")

# 创建队列
q = multiprocessing.Queue()

# 创建生产者进程
producer_process = multiprocessing.Process(target=producer, args=(q,))
# 创建消费者进程
consumer_process = multiprocessing.Process(target=consumer, args=(q,))

# 启动进程
producer_process.start()
consumer_process.start()

# 等待生产者进程结束
producer_process.join()

# 通知消费者进程结束
q.put(None)
# 等待消费者进程结束
consumer_process.join()

进程池

multiprocessing模块提供了进程池（Pool）来管理一组进程。

示例：使用进程池

import multiprocessing

def square(n):
    return n * n

with multiprocessing.Pool(processes=4) as pool:
    results = pool.map(square, range(10))

print(results)

多线程与多进程的比较

• 多线程：

  • 适用于I/O密集型任务。
  • 线程间共享内存，易于通信，但需要同步机制防止竞争条件。
  • 由于Python的全局解释器锁（GIL），多线程在CPU密集型任务中并不能提高性能。

• 多进程：

  • 适用于CPU密集型任务。
  • 进程间独立内存空间，不共享数据，通信复杂。
  • 能够充分利用多核CPU，适合计算密集型任务。

实际应用示例

使用多线程进行网页爬取

import threading
import requests

urls = ["https://www.example.com", "https://www.python.org", "https://www.github.com"]

def fetch_url(url):
    response = requests.get(url)
    print(f"{url}: {response.status_code}")

threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

使用多进程进行图像处理

import multiprocessing
from PIL import Image, ImageFilter

def process_image(image_path):
    image = Image.open(image_path)
    image = image.filter(ImageFilter.BLUR)
    image.save(f"blurred_{image_path}")

image_files = ["image1.jpg", "image2.jpg", "image3.jpg"]

processes = [multiprocessing.Process(target=process_image, args=(image,)) for image in image_files]

for process in processes:
    process.start()

for process in processes:
    process.join()

总结

本文详细介绍了Python中的多线程和多进程编程，包括基本概念、使用方法、线程和进程的同步与通信，以及实际应用中的示例代码。通过这些知识和技巧，可以在Python编程中高效地实现并发处理，提升程序性能和响应速度。多线程适用于I/O密集型任务，而多进程则适用于CPU密集型任务，根据具体需求选择合适的并发编程方式，可以显著提高程序的执行效率。