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

虎哥2024年10月02日约 6 分钟

嗨，大家好，我是虎哥。

今天我们来聊聊Python中的并发编程，尤其是多线程和多进程这两种技术。这可不是简单的“线程、进程”的概念，而是能够显著提升程序性能和响应速度的关键手段。无论你是刚入门的小白，还是资深的技术专家，这篇文章都将带你深入了解这些技术。

并发编程的必要性

在现代编程中，许多任务是I/O密集型或CPU密集型的。例如，当你进行网络请求、文件读写时，就属于I/O密集型任务；而处理复杂计算、图像处理等则属于CPU密集型任务。为了更高效地利用计算资源，Python提供了多线程和多进程两种并发编程方式，各有其独特的优缺点。

多线程编程

1. 什么是多线程？

多线程是指在一个进程内创建多个线程，每个线程都是独立执行的，但它们共享同一内存空间。这使得多线程非常适合处理I/O密集型任务，比如网络请求和文件操作。

2. 如何创建线程？

在Python中，可以使用threading模块来创建和管理线程。下面是一个简单的例子：

import threading
def print_numbers():  for i in range(5):      print(i)
# 创建线程thread = threading.Thread(target=print_numbers)# 启动线程thread.start()# 等待线程结束thread.join()

这个示例展示了如何创建一个简单的线程并等待它执行完毕。

3. 使用类创建线程

如果你想要更灵活的线程管理，可以通过继承threading.Thread类来创建线程类：

import threading
class NumberThread(threading.Thread):  def run(self):      for i in range(5):          print(i)
# 创建线程thread = NumberThread()# 启动线程thread.start()# 等待线程结束thread.join()

这种方式让我们可以封装线程的行为，便于管理和扩展。

4. 线程同步

由于多线程共享内存空间，因此需要使用同步机制来避免竞争条件。常用的同步机制包括锁（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}")

在这个示例中，锁保证了同一时间只有一个线程可以修改计数器，避免了数据不一致的情况。

5. 线程间通信

线程间可以通过队列进行通信，Python的queue模块提供了线程安全的队列类。下面是一个生产者-消费者模型的实现：

import threadingimport 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()

通过这个例子，你可以看到如何在多线程环境中实现安全的通信机制。

多进程编程

1. 什么是多进程？

多进程是指在操作系统中创建多个独立的进程，每个进程都有自己的内存空间。多进程适用于CPU密集型任务，例如数据处理和计算任务。

2. 如何创建进程？

在Python中，使用multiprocessing模块可以轻松创建和管理进程。以下是创建简单进程的示例：

import multiprocessing
def print_numbers():  for i in range(5):      print(i)
# 创建进程process = multiprocessing.Process(target=print_numbers)# 启动进程process.start()# 等待进程结束process.join()

3. 使用类创建进程

和多线程一样，你也可以通过继承multiprocessing.Process类来创建进程类：

import multiprocessing
class NumberProcess(multiprocessing.Process):  def run(self):      for i in range(5):          print(i)
# 创建进程process = NumberProcess()# 启动进程process.start()# 等待进程结束process.join()

4. 进程间通信

进程间可以通过队列或管道进行通信，下面是一个使用队列的示例：

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()

5. 进程池

multiprocessing模块还提供了进程池（Pool）来管理一组进程，非常适合并发任务处理。下面是一个使用进程池的例子：

def square(n):  return n * n
with multiprocessing.Pool(processes=4) as pool:  results = pool.map(square, range(10))
print(results)

通过进程池，可以更方便地管理和分配任务，充分利用CPU资源。

多线程与多进程的比较

多线程：适用于I/O密集型任务。线程间共享内存，通信容易，但需要同步机制来防止竞争条件。由于Python的全局解释器锁（GIL），在CPU密集型任务中，多线程无法有效提高性能。
多进程：适用于CPU密集型任务。每个进程有独立的内存空间，通信复杂，但可以充分利用多核CPU，适合进行计算密集型操作。

实际应用示例

使用多线程进行网页爬取

多线程在处理I/O密集型任务时表现尤为出色。下面是一个简单的网页爬取示例：

import threadingimport 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 multiprocessingfrom 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中的多线程和多进程编程有了更全面的理解。无论是I/O密集型任务的多线程，还是CPU密集型任务的多进程，掌握它们的使用方法和适用场景，将极大提升你的编程效率。如果你觉得本文有帮助，记得点赞、分享和留言哦，这将是我继续输出优质内容的动力！

目前，对编程、职场感兴趣的同学，大家可以联系我微信：golang404，拉你进入“程序员交流群”。

资料包含了《IDEA视频教程》、《最全python面试题库》、《最全项目实战源码及视频》及《毕业设计系统源码》，总量高达 650GB。全部 免费领取！全面满足各个阶段程序员的学习需求。