Python3 多线程与线程同步：深入探讨线程锁机制-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaohong_busy/article/details/148923327

在 Python 中，多线程允许同时执行多个任务，通常用于提高程序效率（但有时也不能提高效率，希望可以正确理解与运用），优化用户体验以及处理长时间的任务。今天，我们将深入探讨多线程的原理，如何创建线程，并重点讲解线程同步与锁机制。

多线程的基本概念

多线程意味着在同一个进程中，多个线程可以并发执行。每个线程都有自己的执行序列，CPU 会在这些线程之间切换。线程能够显著提高程序执行效率，特别是在处理 I/O 密集型任务时，像文件读写、网络请求等非常适合运用。

如何使用 Python 创建多线程

Python3 的 threading 模块提供了丰富的线程管理功能。我们可以通过继承 threading.Thread 类来创建自己的线程类。

首先，让我们看一个简单的线程创建实例：

import threading
import time

# 线程执行函数
def print_numbers():
    for i in range(5):
        time.sleep(1)
        print(f"数字：{i}")

# 创建并启动线程
thread = threading.Thread(target=print_numbers)
thread.start()

# 等待线程完成
thread.join()
print("主线程已退出")

输出：

线程同步：避免数据不一致

当多个线程操作共享数据时，可能会导致数据不一致的问题。例如，如果两个线程同时修改同一列表中的元素，可能会出现数据竞争，导致程序结果错误。

为了避免这种情况，我们可以使用锁（Lock）来实现线程同步。锁机制确保同一时间只有一个线程可以访问共享资源，其他线程必须等待锁被释放。

锁的应用实例

假设有两个线程，一个线程从后往前修改列表，另一个线程从前往后读取列表并打印。如果没有锁的保护，可能会发生读取到不一致的数据。
以下是无锁的线程同步代码示例：

import threading
import time

# 共享数据
data = [0, 0, 0, 0, 0]
# 锁对象
lock = threading.Lock()

# 线程1：修改数据
def modify_data():
    global data
    for i in range(len(data)-1, -1, -1):
        time.sleep(1)
        data[i] = 1
        print(f"修改数据：{data}")

# 线程2：读取数据
def read_data():
    global data
    for i in range(len(data)):
        time.sleep(1.5)
        print(f"读取数据：{data}")

# 创建线程
thread1 = threading.Thread(target=modify_data)
thread2 = threading.Thread(target=read_data)

# 启动线程
thread1.start()
thread2.start()

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

print("主线程已退出")

输出示例：

以下是带有锁的线程同步代码示例：

import threading
import time

# 共享数据
data = [0, 0, 0, 0, 0]
# 锁对象
lock = threading.Lock()

# 线程1：修改数据
def modify_data():
    global data
    with lock:
        for i in range(len(data)-1, -1, -1):
            time.sleep(1)
            data[i] = 1
            print(f"修改数据：{data}")

# 线程2：读取数据
def read_data():
    global data
    for i in range(len(data)):
        time.sleep(1.5)
        with lock:  # 为读取数据加锁
            print(f"读取数据：{data}")

# 创建线程
thread1 = threading.Thread(target=modify_data)
thread2 = threading.Thread(target=read_data)

# 启动线程
thread1.start()
thread2.start()

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

print("主线程已退出")

输出示例：

在这个例子中，两个线程通过 lock 锁确保操作共享数据时的线程安全。每个线程在对共享数据进行操作时都必须先获得锁，这样就能保证数据的一致性，避免了竞态条件（race condition）问题。

优化：使用队列进行线程间的通信

为了在多个线程之间进行高效的数据交换，Python 提供了 queue 模块。队列不仅能保证线程安全，还能帮助我们实现更复杂的多线程任务。我们可以使用 queue.Queue 来传递数据，确保数据的有序处理。

优先级队列实例

我们将使用队列来模拟一个多线程任务处理场景，多个线程从一个共享队列中获取任务并处理：

import threading
import queue
import time

# 线程任务处理函数
def worker(task_queue):
    while True:
        task = task_queue.get()
        if task is None:
            break
        print(f"正在处理任务：{task}")
        time.sleep(1)
        task_queue.task_done()

# 创建一个队列
task_queue = queue.Queue()

# 创建并启动线程
threads = []
for i in range(3):
    t = threading.Thread(target=worker, args=(task_queue,))
    t.start()
    threads.append(t)

# 向队列中添加任务
tasks = ["任务1", "任务2", "任务3", "任务4", "任务5"]
for task in tasks:
    task_queue.put(task)

# 等待所有任务完成
task_queue.join()

# 停止所有线程
for i in range(3):
    task_queue.put(None)
for t in threads:
    t.join()

print("主线程已退出")

输出示例：