Python如何实现多线程_Python多线程编程指南分享

Python多线程依赖threading模块，适用于I/O密集型任务，但受GIL限制无法在CPU密集型任务中实现真正并行；通过Lock、Queue等机制可解决共享数据的竞态条件；对于并行计算需求，应选用multiprocessing或多线程结合异步IO的混合模型。

Python实现多线程主要依赖于内置的

threading

解决方案

要实现Python多线程，核心是使用

threading.Thread

import threading
import time

def task_function(name, delay):
    """一个模拟耗时操作的函数"""
    print(f"线程 {name}: 启动...")
    time.sleep(delay)
    print(f"线程 {name}: 完成。")

# 创建线程列表
threads = []

# 创建并启动第一个线程
thread1 = threading.Thread(target=task_function, args=("Worker 1", 2))
threads.append(thread1)
thread1.start() # 启动线程

# 创建并启动第二个线程
thread2 = threading.Thread(target=task_function, args=("Worker 2", 3))
threads.append(thread2)
thread2.start() # 启动线程

# 等待所有线程完成
for t in threads:
    t.join() # 阻塞主线程，直到该线程执行完毕

print("所有线程都已完成。")

# 如果涉及到共享资源，需要使用锁来避免竞态条件
balance = 0
lock = threading.Lock()

def deposit(amount):
    global balance
    with lock: # 使用with语句确保锁的自动释放
        current_balance = balance
        time.sleep(0.01) # 模拟一些操作延迟
        current_balance += amount
        balance = current_balance
    print(f"存款 {amount}，当前余额：{balance}")

def withdraw(amount):
    global balance
    with lock:
        current_balance = balance
        time.sleep(0.01)
        current_balance -= amount
        balance = current_balance
    print(f"取款 {amount}，当前余额：{balance}")

# 启动多个线程进行存取款操作
deposit_threads = [threading.Thread(target=deposit, args=(100,)) for _ in range(5)]
withdraw_threads = [threading.Thread(target=withdraw, args=(50,)) for _ in range(3)]

all_bank_threads = deposit_threads + withdraw_threads
for t in all_bank_threads:
    t.start()

for t in all_bank_threads:
    t.join()

print(f"最终余额：{balance}")

在这个例子里，

threading.Thread

target

args

start()

join()

deposit

withdraw

balance

threading.Lock

RLock

Semaphore

Python多线程真的能并行计算吗？深入理解GIL的限制与应对

这大概是每个Python开发者在接触多线程时都会遇到的第一个疑问，也是最让人困惑的地方。我的经验告诉我，答案是“在某些情况下可以，但在CPU密集型任务上不行”。核心原因就是Python的“全局解释器锁”（Global Interpreter Lock，简称GIL）。

立即学习“Python免费学习笔记（深入）”；

GIL是一个互斥锁，它的作用是确保在任何时候，只有一个线程能执行Python字节码。这意味着，即使你的程序在多核处理器上运行，并且你创建了多个线程，这些线程也无法真正地并行执行Python代码。它们会轮流获得GIL，执行一小段代码，然后释放GIL，让下一个线程有机会执行。这个过程切换得非常快，以至于我们感觉它们是同时在运行，但这只是并发，而非并行。

那么，GIL的存在意味着Python多线程一无是处吗？当然不是。GIL只影响CPU密集型任务，也就是那些大部分时间都在进行计算的程序。对于I/O密集型任务，比如网络请求、文件读写、数据库操作等，当一个线程在等待I/O操作完成时，它会主动释放GIL，允许其他线程运行。这样一来，虽然Python代码本身没有并行执行，但程序整体的吞吐量却能显著提升，因为CPU不会在等待I/O时空闲下来。

应对GIL的策略：

1. 识别任务类型：如果你的任务是I/O密集型，多线程依然是提高效率的有效手段。
2. 外部库：许多Python的科学计算库（如NumPy、SciPy）或底层C/C++扩展（如OpenCV）在执行内部计算时会释放GIL。这意味着当你调用这些库的函数时，它们可以并行执行，而Python主线程可以去做其他事情。
3. 多进程（Multiprocessing）：对于CPU密集型任务，使用

   multiprocessing

   登录后复制
   模块创建多个进程是更直接的解决方案。每个进程都有自己的Python解释器和GIL，因此它们可以真正地并行运行在不同的CPU核心上。当然，进程间通信（IPC）会带来额外的开销和复杂性。
4. 异步IO（Asyncio）：对于高并发的I/O密集型任务，

   asyncio

   登录后复制
   框架提供了一种基于协程的非阻塞I/O模型，它在单线程内通过事件循环来管理并发，避免了线程切换的开销和GIL的限制。这是一种完全不同的并发范式，但在特定场景下非常高效。

在我看来，理解GIL是Python并发编程的起点。它不是一个bug，而是为了简化解释器设计和内存管理而做出的权衡。一旦你接受了它的存在，就能更清晰地选择合适的并发工具。

Python多线程中的数据同步与通信：避免竞态条件的实用技巧

在多线程编程中，最大的挑战之一就是如何安全地共享数据。当多个线程同时访问和修改同一个共享资源时，如果没有适当的同步机制，就可能导致数据不一致、程序崩溃等难以预料的问题，这就是所谓的“竞态条件”（Race Condition）。我的经验告诉我，处理好这一块，多线程编程就成功了一大半。

最常见的同步原语是锁（Lock）。

threading.Lock

acquire()

release()

acquire()

release()

with lock:

OpenMP多线程编程指南 WORD版

本文档主要讲述的是OpenMP多线程编程指南；OpenMP是由OpenMP Architecture Review Board牵头提出的，并已被广泛接受的，用于共享内存并行系统的多线程程序设计的一套指导性注释(Compiler Directive)。OpenMP是一种面向共享内存以及分布式共享内存的多处理器多线程并行编程语言，能被用于显示指导多线程、共享内存并行的应用程序编程接口。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以过来看看

0

查看详情

除了基本的

Lock

• RLock

  登录后复制
  (可重入锁)：允许同一个线程多次获取同一个锁。这在递归函数或内部调用了其他需要相同锁的函数时非常有用，避免了线程自己把自己锁死。

• Semaphore

  登录后复制
  (信号量)：控制对有限资源的访问数量。它维护一个内部计数器，当计数器大于0时，线程可以获取信号量并使计数器减1；当计数器为0时，线程会被阻塞。当线程释放信号量时，计数器加1。这适用于需要限制并发访问数量的场景，比如连接池。

• Event

  登录后复制
  (事件)：一个简单的线程间通信机制。一个线程可以设置（

  set()

  登录后复制
  ）一个事件，另一个线程可以等待（

  wait()

  登录后复制
  ）这个事件被设置。

  wait()

  登录后复制
  方法会阻塞直到事件被设置。

• Condition

  登录后复制
  (条件变量)：比锁更强大的同步机制，通常与锁一起使用。它允许线程在某个条件不满足时等待，并在条件满足时被其他线程唤醒。这对于生产者-消费者模型等复杂场景非常有用。

• Queue

  登录后复制
  (队列)：

  Queue

  登录后复制
  模块提供了线程安全的队列，如

  Queue.Queue

  登录后复制
  、

  Queue.LifoQueue

  登录后复制
  、

  Queue.PriorityQueue

  登录后复制
  。它们内部已经处理了锁机制，是实现线程间安全通信和数据传递的推荐方式，尤其是在生产者-消费者模型中。

from queue import Queue

# 生产者函数
def producer(q, items_to_produce):
    for i in range(items_to_produce):
        item = f"产品-{i}"
        q.put(item) # 放入队列，如果队列满则阻塞
        print(f"生产者: 生产了 {item}")
        time.sleep(0.1)

# 消费者函数
def consumer(q, consumer_id):
    while True:
        item = q.get() # 从队列取出，如果队列空则阻塞
        print(f"消费者 {consumer_id}: 消费了 {item}")
        time.sleep(0.2)
        q.task_done() # 告知队列该任务已完成

# 创建一个线程安全的队列
q = Queue(maxsize=10) # 限制队列大小

# 启动生产者线程
producer_thread = threading.Thread(target=producer, args=(q, 20))
producer_thread.start()

# 启动多个消费者线程
consumer_threads = []
for i in range(3):
    c_thread = threading.Thread(target=consumer, args=(q, i+1), daemon=True) # 设置为守护线程
    consumer_threads.append(c_thread)
    c_thread.start()

# 等待所有生产者任务完成
producer_thread.join()

# 等待队列中的所有任务都被处理完毕
q.join()

print("所有产品都已生产和消费。")

在使用这些工具时，我发现最容易犯的错误是死锁（Deadlock）和活锁（Livelock）。死锁发生在多个线程互相等待对方释放资源时，而活锁则发生在线程不断地尝试获取资源但又不断地放弃，导致任务无法进展。避免这些问题的关键在于：

• 保持锁的粒度尽可能小：只在真正需要保护共享数据的关键代码段加锁。
• 遵循固定的加锁顺序：如果一个线程需要获取多个锁，始终以相同的顺序获取它们。
• 避免长时间持有锁：尽快释放锁，减少其他线程的等待时间。
• 使用高级抽象：

  Queue

  登录后复制
  模块通常比手动管理锁更安全、更简洁。

数据同步和通信是多线程编程的艺术，它要求开发者对程序的执行流程有清晰的认识，并能预见潜在的并发问题。

Python多线程与多进程、异步IO：如何选择最适合你的并发模型？

在Python中，我们有不止一种实现并发的方式：多线程（

threading

multiprocessing

asyncio

1. 多线程 (

   threading

   登录后复制
   )
   • 优点：
     • 线程间共享内存，数据交换方便。
     • 启动开销小，上下文切换快。
     • 适用于I/O密集型任务，如网络请求、文件读写，因为I/O操作会释放GIL。
   • 缺点：
     • 受GIL限制，无法在CPU密集型任务上实现真正的并行。
     • 数据同步复杂，容易出现竞态条件和死锁。
   • 适用场景：需要并发处理大量I/O操作的Web服务器、网络爬虫、GUI应用（保持界面响应）。

2. 多进程 (

   multiprocessing

   登录后复制
   )
   • 优点：
     • 每个进程有独立的内存空间和Python解释器，不受GIL限制，可以实现真正的并行计算。
     • 进程间相互隔离，一个进程崩溃通常不会影响其他进程。
   • 缺点：
     • 进程间数据共享复杂，需要专门的进程间通信（IPC）机制（如队列、管道、共享内存）。
     • 启动开销大，上下文切换比线程慢。
     • 消耗更多系统资源（内存）。
   • 适用场景：CPU密集型任务，如科学计算、图像处理、大规模数据分析、并行编译。

3. 异步IO (

   asyncio

   登录后复制
   )
   • 优点：
     • 在单线程内实现高并发，避免了线程/进程切换的开销和GIL的限制。
     • 资源消耗低。
     • 适用于I/O密集型任务，尤其是需要处理大量并发连接的场景。
   • 缺点：
     • 编程模型与传统的同步编程不同，需要使用

       async/await

       登录后复制
       语法，学习曲线相对陡峭。
     • 一旦某个

       await

       登录后复制
       able函数内部执行了CPU密集型操作而没有释放控制权，整个事件循环就会被阻塞。
     • 生态系统相对年轻，一些库可能还没有完全支持异步模式。
   • 适用场景：高并发Web服务、实时聊天应用、长连接服务、API网关、高吞吐量的I/O操作。

我的选择逻辑通常是这样的：

• 如果任务主要是等待外部资源（网络、磁盘），并且对实时性要求不是极高，线程往往是我的首选。 它简单易用，且对于I/O瓶颈的程序效果显著。
• 如果任务需要大量计算，并且可以分解成独立的子任务，那么我会毫不犹豫地选择进程。 牺牲一些启动开销来换取真正的并行计算，是值得的。
• 如果我需要构建一个高性能、高并发的服务，并且大部分操作都是非阻塞的I/O，那么

  asyncio

  登录后复制
  会是我的首选。 它的性能优势在这些场景下非常明显，但确实需要一些时间去适应它的编程范式。

有时候，你甚至会需要将它们结合起来使用。例如，一个

asyncio

以上就是Python如何实现多线程_Python多线程编程指南分享的详细内容，更多请关注php中文网其它相关文章！