当前位置：物联沃-IOTWORD物联网 > 技术教程 > Python threading库实现多线程编程详解
代码收藏家代码收藏家 技术教程

Python threading库实现多线程编程详解

目录

1. 前言

2. 创建线程与threading基本语法

2.1 与主线程并发执行

2.2 阻塞主线程，专注于子线程

3. 线程同步

3.1 Lock

3.2 RLock

4. 守护线程

5. 线程通信

5.1 Event

5.2 Condition

5.3 Queue

6. 总结

1. 前言

随着计算机技术的飞速发展，多核处理器已经成为主流配置，如何充分利用多核 CPU 的计算能力，让程序能够同时处理多个任务，成为了现代编程中至关重要的课题。而 Python 的 threading 库，正是应对这一需求的强大工具，它允许我们在程序中创建和管理多个线程，让程序具备同时执行多个操作的能力，从而在处理 I/O 密集型任务、提高程序响应速度以及优化资源利用率等方面发挥着不可替代的作用，以下为解析介绍与学习理解。

2. 创建线程与threading基本语法

2.1 与主线程并发执行

在 threading 库中，创建线程主要通过 Thread 类来实现。我们只需将希望在线程中执行的目标函数作为参数传递给 Thread 类的构造函数，即可轻松创建一个线程对象。例如：

import threading

def print_numbers():
    for i in range(1, 6):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()

上述代码中，我们定义了一个 print_numbers 函数，用于打印 1 到 5 的数字。接着，通过 threading.Thread 创建了一个线程对象 thread，并将 print_numbers 函数作为目标函数传入。

调用 start() 方法后，线程便开始运行，与主线程并发执行。

2.2 阻塞主线程，专注于子线程

而在 Python 的 threading 库中，thread1.join() 则它用于主线程等待子线程 thread1 完成后再继续执行。换句话说，当主线程遇到 thread1.join() 时，会阻塞自己，直到 thread1 执行完毕后，主线程才会继续向下执行，如下：

import threading
import time

def print_numbers():
    for i in range(5):
        time.sleep(1)
        print(i)

thread1 = threading.Thread(target=print_numbers)
thread1.start()

# 主线程等待 thread1 完成
thread1.join()

print("Thread 1 has finished.")

在这个例子中，thread1 是一个子线程，负责打印 0 到 4 的数字，每个数字之间间隔 1 秒。主线程在启动 thread1 后，调用 thread1.join() 阻塞自己，等待 thread1 执行完毕。当 thread1 打印完所有数字后，主线程才继续执行，打印 "Thread 1 has finished."。 

具体使用场景有：

  1. 确保线程完成：当需要确保某个子线程的任务完成后再继续执行后续代码时，可以使用 join()。例如，在多线程爬虫中，主线程可能需要等待所有子线程完成数据抓取后，再进行数据的统一处理。

  2. 线程同步：在复杂的多线程程序中，join() 可以用于线程间的同步操作，确保线程按预期的顺序执行。

3. 线程同步

当多个线程同时访问共享资源时，可能会引发数据不一致的问题，这就需要我们对线程进行同步操作。threading 库提供了多种同步原语，如 Lock、RLock 等，帮助我们确保线程安全。

3.1 Lock

Lock 是最简单的同步机制，它遵循“先到先得”的原则，同一时刻只能被一个线程获取。当一个线程获取到锁后，其他线程必须等待该线程释放锁后才能继续获取。例如：

import threading

counter = 0
lock = threading.Lock()

def increment_counter():
    global counter
    for _ in range(100000):
        lock.acquire()
        counter += 1
        lock.release()

thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print(counter)  # 输出 200000

在这个例子中，我们使用 Lock 来保护对共享变量 counter 的访问。每个线程在修改 counter 之前都需要先获取锁，修改完成后释放锁，从而避免了多个线程同时修改 counter 导致数据混乱的问题。

3.2 RLock

RLock 是可重入锁，它允许同一线程多次获取同一把锁，而不会造成死锁。这对于一些需要在同一个线程中多次进入临界区的场景非常有用。使用方式与 Lock 类似，只需将 threading.Lock() 替换为 threading.RLock() 即可。

4. 守护线程

在 threading 库中，线程可以设置为守护线程（Daemon Thread）。守护线程的特殊之处在于，当程序中所有的非守护线程（包括主线程）都结束时，守护线程会自动被终止，而无需显式等待其完成。这在一些后台运行的辅助任务中非常实用，例如日志记录、监控等。设置守护线程的方式很简单，只需在创建线程时将 daemon 参数设置为 True：

thread = threading.Thread(target=my_function, daemon=True)

以下是守护线程的一个简单的示例：

import threading
import time

def background_task():
    while True:
        print("守护线程正在运行...")
        time.sleep(2)

# 创建守护线程
daemon_thread = threading.Thread(target=background_task, daemon=True)

# 启动守护线程
daemon_thread.start()

# 主线程继续执行其他任务
for i in range(5):
    print("主线程正在运行...")
    time.sleep(1)

print("主线程结束")

运行结果如下：

 在这个示例中，background_task 是守护线程执行的任务，它会无限循环地打印消息。主线程则执行自己的任务并在 5 秒后结束。由于守护线程的 daemon 参数被设置为 True，当主线程结束后，Python 解释器会自动退出，即使守护线程仍在运行。

5. 线程通信

在多线程编程中，线程之间往往需要进行通信，以协调工作或共享数据。threading 库提供了多种机制来实现线程间的通信，如 Event、Condition、Queue 等。

5.1 Event

Event 是一个简单的线程通信机制，它允许线程等待某个事件的发生。它内部维护一个标志位，线程可以通过 wait() 方法等待事件发生，而其他线程可以通过 set() 方法将事件标志设置为 True，通知等待的线程继续执行。例如：

import threading

event = threading.Event()

def wait_for_event():
    print("Waiting for event...")
    event.wait()
    print("Event occurred!")

thread = threading.Thread(target=wait_for_event)
thread.start()

# 模拟其他线程触发事件
import time
print("其他线程开始")
time.sleep(2)
event.set()

运行结果如下：

在这个例子中，wait_for_event 线程会等待 event 被设置，直到其他线程调用 event.set() 后，它才会继续执行。

5.2 Condition

Condition 是一种更高级的线程通信机制，它允许线程在某个条件满足时通知其他线程。Condition 通常与一个锁关联，线程可以通过 acquire() 和 release() 方法来控制对共享资源的访问，并通过 wait()、notify() 和 notify_all() 方法来进行线程间的通信。例如：

import threading

condition = threading.Condition()
data = []

def producer():
    with condition:
        data.append("product")
        condition.notify_all()

def consumer():
    with condition:
        while not data:
            condition.wait()
        item = data.pop()
        print("Consumed:", item)

producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

producer_thread.start()
consumer_thread.start()

在这个例子中，程序先创建了一个条件变量condition和一个空列表data，然后定义了生产者和消费者函数。生产者函数在获取条件变量的锁后，向data中添加一个产品并通知所有等待的线程，之后释放锁；消费者函数获取锁后，若data为空则等待，被唤醒后从data中取出产品并打印，最后释放锁。接着创建并启动了生产者和消费者线程，它们按照上述逻辑执行，完成生产与消费的任务后程序结束。

5.3 Queue

Queue 是一个线程安全的队列实现，它允许线程以先进先出（FIFO）的方式存储和获取数据。Queue 在多线程编程中非常常用，尤其是在生产者 – 消费者模式中。生产者线程将数据放入队列，消费者线程从队列中取出数据进行处理，整个过程无需担心线程安全问题。例如：

import threading
import queue
import time

q = queue.Queue()

def producer():
    for i in range(5):
        q.put(i)
        print("Produced:", i)
        time.sleep(0.5)

def consumer():
    while True:
        item = q.get()
        print("Consumed:", item)
        q.task_done()

consumer_thread = threading.Thread(target=consumer)
consumer_thread.daemon = True
consumer_thread.start()

producer_thread = threading.Thread(target=producer)
producer_thread.start()

producer_thread.join()
q.join()
print("全部完成")

在这个例子中，producer 线程将数据放入队列，consumer 线程从队列中取出数据并处理。Queue 的 get() 方法会阻塞，直到队列中有数据可获取，而 task_done() 方法用于表示队列中的一个任务已完成。当消费者处理完一项数据后，就可以使用 task_done() 方法通知队列，这样 Queue 对象就可以知道队列中那一项已经被处理完毕了。

其中，使用队列时，我们通常使用 put() 方法将项目添加到队列中，然后使用 get() 方法从队列中获取项目进行处理。在处理完一个项目后，我们可以使用 task_done() 方法通知队列管理器，这个项目已经被处理完了。如果我们使用了 join() 方法等待所有的项目都被处理完，那么这个方法会在所有的项目都被处理完后返回

6. 总结

threading 库作为 Python 标准库中不可或缺的一部分，为多线程编程提供了强大而灵活的支持。通过 Thread 类，我们可以轻松创建和启动线程，让程序具备并发执行的能力；借助 Lock、RLock 等同步机制，我们能够确保线程安全，避免数据竞争和不一致的问题；利用守护线程、线程通信等特性，我们还可以实现更加复杂和高效的多线程应用程序架构。

在实际开发中，合理运用 threading 库，能够显著提升程序的性能和用户体验。无论是处理 I/O 密集型任务，如网络请求、文件操作等，还是在需要同时执行多个独立任务的场景下，threading 库都能发挥其独特的优势。然而，多线程编程也并非没有挑战，线程间的同步、通信以及潜在的死锁等问题，都需要我们在设计和实现时仔细考虑和妥善处理。我是橙色小博，关注我，一起在人工智能领域学习进步。

作者：橙色小博

物联沃分享整理
物联沃-IOTWORD物联网 » Python threading库实现多线程编程详解

代码收藏家 普通

分享到：

相关推荐

发表回复