Python3多线程基础：原理、模块与同步机制详解

不晚

发布时间：2026-10-13| 6人浏览过

原创

本文详细介绍Python3中多线程的基础知识，涵盖_thread与threading模块的区别、线程创建方式（函数式与类封装）、线程同步机制（锁的使用）以及线程安全队列Queue的应用。通过实例解析如何避免数据不同步问题，掌握多线程编程核心技巧。

多线程允许程序同时执行多个不同的任务，其运行具备以下显著优势：

将耗时较长的任务移至后台处理，从而优化主流程的执行效率。
提升用户界面的交互体验。例如，当用户点击按钮触发特定事件时，程序可弹出进度条实时显示处理进度，避免界面假死。
在特定场景下，程序的总体运行速度可能得到提升。
在处理用户输入、文件读写或网络数据收发等等待型任务时，多线程表现尤为出色。此时，程序可以释放如内存占用等宝贵系统资源。

每个线程均拥有独立的CPU寄存器组，这被称为线程上下文，它记录了线程上次运行时CPU寄存器的状态。其中，指令指针和堆栈指针寄存器是两个最关键的寄存器。线程始终在进程的上下文中运行，这些地址均指向拥有该线程的进程地址空间内的内存区域。

线程支持被抢占（即中断）。
当其他线程正在运行时，当前线程可以暂时挂起（即进入睡眠状态），这被称为线程的退让。

根据实现方式，线程主要可分为两类：

内核线程：由操作系统内核负责创建和撤销。
用户线程：无需内核支持，直接在用户程序中实现的线程。

在Python3中，常用的两个线程模块为：

_thread
threading（官方推荐使用）

注意，thread模块已被废弃。用户应使用threading模块替代。因此，在Python3中无法再直接使用“thread”模块。为了保持向后兼容性，Python3将thread模块重命名为“_thread”。

开始学习Python线程

在Python中使用线程主要有两种方式：通过函数调用或使用类来包装线程对象。

函数式方法：通过调用_thread模块中的start_new_thread()函数来生成新线程。其语法结构如下：

_thread.start_new_thread ( function, args[, kwargs] )

参数说明如下：

function：指定线程执行的函数。
args：传递给线程函数的参数，必须为tuple类型。
kwargs：可选的关键字参数。

具体实例如下：

#!/usr/bin/python3

import _thread
import time

# 为线程定义一个函数
def print_time( threadName, delay):
 count = 0
 while count < 5:
  time.sleep(delay)
  count += 1
  print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# 创建两个线程
try:
 _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
 _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
 print ("Error: 无法启动线程")

while 1:
 pass

运行上述程序，输出结果如下：

Thread-1: Wed Apr 6 11:36:31 2016
Thread-1: Wed Apr 6 11:36:33 2016
Thread-2: Wed Apr 6 11:36:33 2016
Thread-1: Wed Apr 6 11:36:35 2016
Thread-1: Wed Apr 6 11:36:37 2016
Thread-2: Wed Apr 6 11:36:37 2016
Thread-1: Wed Apr 6 11:36:39 2016
Thread-2: Wed Apr 6 11:36:41 2016
Thread-2: Wed Apr 6 11:36:45 2016
Thread-2: Wed Apr 6 11:36:49 2016

程序运行后，可按Ctrl+C组合键退出。

线程模块

Python3通过两个标准库_thread和threading提供对线程的支持。

_thread提供了低级别的原始线程功能及简单锁机制，其功能相比threading模块较为有限。而threading模块不仅包含_thread模块中的所有方法，还额外提供了其他高级方法：

threading.currentThread()：返回当前线程的变量。
threading.enumerate()：返回一个包含当前正在运行的线程列表。这里的“正在运行”指线程已启动且未结束的状态，不包括启动前或终止后的线程。
threading.activeCount()：返回当前正在运行的线程数量，其结果与len(threading.enumerate())相同。

除了直接使用上述方法外，线程模块还提供了Thread类来处理线程。Thread类提供了以下核心方法：

run()：定义线程活动逻辑的方法。
start()：启动线程活动。
join([time])：阻塞调用线程，直到调用join()方法的线程中止（正常退出或抛出未处理异常）或发生可选的超时。
isAlive()：返回线程是否处于活动状态。
getName()：返回线程的名称。
setName()：设置线程的名称。

使用threading模块创建线程

我们可以通过继承threading.Thread类来创建新的子类，实例化后调用start()方法启动新线程，这实际上会调用线程的run()方法：

#!/usr/bin/python3

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
 def __init__(self, threadID, name, counter):
  threading.Thread.__init__(self)
  self.threadID = threadID
  self.name = name
  self.counter = counter
 def run(self):
  print ("开始线程：" + self.name)
  print_time(self.name, self.counter, 5)
  print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
 while counter:
  if exitFlag:
   threadName.exit()
  time.sleep(delay)
  print ("%s: %s" % (threadName, time.ctime(time.time())))
  counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")

上述程序的执行结果如下：

开始线程：Thread-1
开始线程：Thread-2
Thread-1: Wed Apr 6 11:46:46 2016
Thread-1: Wed Apr 6 11:46:47 2016
Thread-2: Wed Apr 6 11:46:47 2016
Thread-1: Wed Apr 6 11:46:48 2016
Thread-1: Wed Apr 6 11:46:49 2016
Thread-2: Wed Apr 6 11:46:49 2016
Thread-1: Wed Apr 6 11:46:50 2016
退出线程：Thread-1
Thread-2: Wed Apr 6 11:46:51 2016
Thread-2: Wed Apr 6 11:46:53 2016
Thread-2: Wed Apr 6 11:46:55 2016
退出线程：Thread-2
退出主线程

线程同步

若多个线程共同修改同一数据，可能导致不可预知的结果。为确保数据正确性，需对多个线程进行同步处理。使用Thread对象的Lock和Rlock可实现简单的线程同步，这两个对象均具备acquire和release方法。对于每次仅允许一个线程操作的数据，可将其操作置于acquire和release方法之间。示例如下：

多线程的优势在于能同时运行多个任务（至少在感知上如此）。然而，当线程需要共享数据时，可能存在数据不同步的风险。

考虑一种场景：一个列表中的所有元素初始值为0，线程“set”从后向前将所有元素修改为1，而线程“print”负责从前向后读取列表并打印。

若线程“set”开始修改时，线程“print”恰好开始打印列表，输出结果将变成一半0一半1，这就是数据不同步的现象。为避免此问题，引入了锁的概念。

锁具有两种状态：锁定和未锁定。当线程（如“set”）访问共享数据时，必须先获取锁；若其他线程（如“print”）已持有锁，则线程“set”需暂停（即同步阻塞）；待线程“print”访问完毕并释放锁后，线程“set”方可继续执行。经过此类处理，打印列表时要么全输出0，要么全输出1，不再出现一半0一半1的情况。

具体实例如下：

#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
 def __init__(self, threadID, name, counter):
  threading.Thread.__init__(self)
  self.threadID = threadID
  self.name = name
  self.counter = counter
 def run(self):
  print ("开启线程： " + self.name)
  # 获取锁，用于线程同步
  threadLock.acquire()
  print_time(self.name, self.counter, 3)
  # 释放锁，开启下一个线程
  threadLock.release()

def print_time(threadName, delay, counter):
 while counter:
  time.sleep(delay)
  print ("%s: %s" % (threadName, time.ctime(time.time())))
  counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
 t.join()
print ("退出主线程")

运行上述程序，输出结果为：

开启线程： Thread-1
开启线程： Thread-2
Thread-1: Wed Apr 6 11:52:57 2016
Thread-1: Wed Apr 6 11:52:58 2016
Thread-1: Wed Apr 6 11:52:59 2016
Thread-2: Wed Apr 6 11:53:01 2016
Thread-2: Wed Apr 6 11:53:03 2016
Thread-2: Wed Apr 6 11:53:05 2016
退出主线程

线程优先级队列（Queue）

Python的Queue模块提供了同步且线程安全的队列类，包括FIFO（先入先出）队列Queue、LIFO（后入先出）队列LifoQueue以及优先级队列PriorityQueue。

这些队列均实现了锁原语，可直接在多线程中使用，可用于实现线程间的同步。Queue模块中常用方法包括： Queue.qsize()：返回队列的大小。 Queue.empty()：若队列为空，返回True，否则返回False。 Queue.full()：若队列已满，返回True，否则返回False。Queue.full与maxsize大小对应。 Queue.get([block[, timeout]])：获取队列元素，block控制阻塞行为，timeout指定等待时间。 Queue.get_nowait()：相当于Queue.get(False)。 Queue.put(item)：写入队列元素，block控制阻塞行为，timeout指定等待时间。 Queue.put_nowait(item)：相当于Queue.put(item, False)。 Queue.task_done()：在完成一项工作后，向已完成任务的队列发送信号。 Queue.join()：意味着等待队列为空，再执行其他操作。

具体实例如下：

#!/usr/bin/python3

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
 def __init__(self, threadID, name, q):
  threading.Thread.__init__(self)
  self.threadID = threadID
  self.name = name
  self.q = q
 def run(self):
  print ("开启线程：" + self.name)
  process_data(self.name, self.q)
  print ("退出线程：" + self.name)

def process_data(threadName, q):
 while not exitFlag:
  queueLock.acquire()
  if not workQueue.empty():
   data = q.get()
   queueLock.release()
   print ("%s processing %s" % (threadName, data))
  else:
   queueLock.release()
  time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# 创建新线程
for tName in threadList:
 thread = myThread(threadID, tName, workQueue)
 thread.start()
 threads.append(thread)
 threadID += 1

# 填充队列
queueLock.acquire()
for word in nameList:
 workQueue.put(word)
queueLock.release()

# 等待队列清空
while not workQueue.empty():
 pass

# 通知线程是时候退出
exitFlag = 1

# 等待所有线程完成
for t in threads:
 t.join()
print ("退出主线程")

上述程序的执行结果：

开启线程：Thread-1
开启线程：Thread-2
开启线程：Thread-3
Thread-3 processing One
Thread-1 processing Two
Thread-2 processing Three
Thread-3 processing Four
Thread-1 processing Five
退出线程：Thread-3
退出线程：Thread-2
退出线程：Thread-1
退出主线程