Python多线程实现后台非阻塞接收串口数据

周叙
周叙
发布时间:2026-11-17 | 20人浏览过
原创

详细讲解在Python中使用threading多线程和pyserial库实现后台非阻塞接收串口数据的完整方案,涵盖系统架构、核心代码、单线程与多线程对比及优雅退出机制。

在开发涉及串口通信的 Python 程序时,最棘手的问题往往是底层 I/O 的阻塞等待。当程序调用 serial.Serial.read() 或 readline() 读取硬件发来的数据时,如果传感器尚未发送数据,主线程就会停滞等待;如果程序同时承载了图形界面(GUI)、Web 服务或高频计算逻辑,整个主界面就会陷入假死或掉帧。要解决这一冲突,最标准、稳妥的工程路径是通过 threading 模块创建独立的后台接收子线程,配合微小超时时间(Timeout)在后台专职监听串口,并将接收到的数据帧注入线程安全的 queue.Queue 队列,主线程则以非阻塞方式按需提取处理。本文将系统拆解该方案的底层机制、完整可运行代码以及避免资源泄漏的注意事项。

一、串口 I/O 阻塞痛点与多线程解耦思路

串口通信本质上是一种串行流式传输。物理硬件发送数据的时间由下位机或传感器决定,在两次数据传输之间可能存在数百毫秒甚至数秒的静默期。如果主线程直接调用阻塞式读取方法,主事件循环就会被底层系统调用挂起,导致无法响应键盘按键、无法绘制 UI 图表、无法处理网络请求。

多线程解耦的核心原则是“职责分离”:

  • 主业务线程:专注于业务计算、界面渲染、用户交互控制,始终保持轻量与高响应度,绝不直接执行可能挂起的长耗时系统调用。
  • 后台子线程:全权接管物理串口的数据拉取与初步解包。子线程可以在串口没有数据时短暂休眠或阻塞,而完全不会拖慢主线程。
  • 通信通道(Queue):利用 Python 标准库内置的 queue.Queue 作为生产者与消费者之间的安全缓冲区。子线程充当生产者将数据放入队列,主线程充当消费者通过非阻塞的 get_nowait() 获取数据。
  • 生命周期同步(Event):主线程通过 threading.Event 跨线程通知子线程何时安全退出,避免强制杀线程引发的硬件端口死锁。
Python多线程实现后台非阻塞接收串口数据
图 1:多线程后台非阻塞串口接收架构与数据交互流向图

二、关键实现步骤与完整工程代码

在 Python 中实现串口通信需依赖社区成熟的 pyserial 模块。在终端或虚拟环境中执行以下命令完成安装:

pip install pyserial

为了让代码具备良好的复用性与健壮性,推荐将串口与后台线程封装为一个专用的控制类。下面是一个完整且经过充分容错设计的代码实现:

import serial
import threading
import queue
import time
from typing import Optional

class SerialReceiver:
    """后台非阻塞串口接收器"""
    def __init__(self, port: str, baudrate: int = 115200, timeout: float = 0.5, max_queue_size: int = 1000):
        self.port = port
        self.baudrate = baudrate
        self.timeout = timeout
        
        # 初始化线程安全缓冲队列
        self.data_queue: queue.Queue = queue.Queue(maxsize=max_queue_size)
        
        # 初始化停止事件信号
        self._stop_event = threading.Event()
        
        self.serial_inst: Optional[serial.Serial] = None
        self.worker_thread: Optional[threading.Thread] = None

    def start(self) -> bool:
        """打开串口并启动后台监听线程"""
        try:
            # 打开底层串口,必须设置合理的超时时间
            self.serial_inst = serial.Serial(
                port=self.port,
                baudrate=self.baudrate,
                timeout=self.timeout
            )
            self._stop_event.clear()
            
            # 创建并启动后台工作线程
            self.worker_thread = threading.Thread(
                target=self._read_loop,
                name="SerialWorkerThread",
                daemon=False  # 使用主动受控退出,而非强制 daemon 杀停
            )
            self.worker_thread.start()
            return True
        except serial.SerialException as e:
            print(f"[错误] 无法打开串口 {self.port}: {e}")
            return False

    def _read_loop(self):
        """后台监听线程主循环"""
        print(f"[{threading.current_thread().name}] 已进入后台监听循环...")
        try:
            while not self._stop_event.is_set():
                if self.serial_inst and self.serial_inst.is_open:
                    # 先检查系统驱动缓冲区是否有数据,减少无效 read 的耗时
                    if self.serial_inst.in_waiting > 0:
                        raw_bytes = self.serial_inst.readline()
                        if raw_bytes:
                            line_str = raw_bytes.decode('utf-8', errors='replace').strip()
                            try:
                                # 非阻塞写入队列;若队列已满则丢弃最旧数据防内存撑爆
                                self.data_queue.put_nowait(line_str)
                            except queue.Full:
                                _ = self.data_queue.get_nowait()
                                self.data_queue.put_nowait(line_str)
                    else:
                        # 暂无数据时微秒级休眠,交出 CPU 时间片,防止单核跑满 100%
                        time.sleep(0.01)
                else:
                    break
        except serial.SerialException as err:
            print(f"[异常] 串口读取异常中断: {err}")
        finally:
            # 确保无论发生何种异常,退出循环前均关闭底层句柄
            if self.serial_inst and self.serial_inst.is_open:
                self.serial_inst.close()
                print("[通知] 后台线程已释放底层串口句柄")

    def get_data(self) -> Optional[str]:
        """供主线程非阻塞提取单条数据"""
        try:
            return self.data_queue.get_nowait()
        except queue.Empty:
            return None

    def stop(self):
        """通知后台线程退出,并阻塞等待资源回收"""
        print("[主线程] 正在向后台子线程下发停止信号...")
        self._stop_event.set()
        if self.worker_thread and self.worker_thread.is_alive():
            # 给子线程预留等待退出的缓冲时间
            self.worker_thread.join(timeout=2.0)
        print("[主线程] 串口后台服务已安全终止")

# ================= 演示主线程调用 =================
if __name__ == "__main__":
    # 请根据实际操作系统替换端口名(Windows 为 'COM3',Linux 为 '/dev/ttyUSB0')
    receiver = SerialReceiver(port="/dev/ttyUSB0", baudrate=115200, timeout=0.2)
    
    if receiver.start():
        try:
            # 模拟主线程繁忙的业务或渲染逻辑
            for tick in range(20):
                # 非阻塞消费数据
                while True:
                    item = receiver.get_data()
                    if item is None:
                        break
                    print(f">>> [主线程处理业务数据]: {item}")
                
                # 主线程可以自由执行耗时或 UI 计算,完全不卡顿
                time.sleep(0.2)
        except KeyboardInterrupt:
            print("[主线程] 捕捉到 Ctrl+C 中断指令")
        finally:
            receiver.stop()
Python多线程实现后台非阻塞接收串口数据
图 2:后台串口子线程生命周期流转与执行流程

三、两种实现方案的对比分析

为了深刻理解多线程解耦的工程价值,我们将“单线程主循环直接读取”与“独立子线程+队列解耦”在相同硬件波特率与测试场景下进行横向对照:

考量维度 方案 A:单线程直接读取 方案 B:多线程后台解耦 (本文方案)
主线程响应度 差。调用 readline() 时主线程被锁死,UI 冻结或控制台无响应。 极高。主线程通过 get_nowait() 读取队列,耗时在微秒级,界面丝滑无卡顿。
数据突发吞吐 易丢包。若主线程正忙于计算,驱动缓冲区溢出,新数据会被物理丢弃。 优良。后台子线程随时从底层 FIFO 读走数据压入 Queue,大幅缓解丢包风险。
CPU 占用表现 不稳定。若采用 timeout=0 纯轮询,单核 CPU 往往飙升至 100%。 稳定。子线程设置 0.2~0.5s 微超时,无数据时出让 GIL,CPU 占用率低于 1%。
代码复杂度 极低。仅需一个 while 循环与基础读写。 中等。需要设计线程安全队列、优雅停止机制以及异常回收闭环。
Python多线程实现后台非阻塞接收串口数据
图 3:单线程阻塞模型与多线程解耦模型的执行时序与性能特征对比

四、生产实践关键避坑与细节把控

1. 为什么必须为 Serial 设置 timeout,而不能设为 None?

很多开发者发现后台线程启动后程序无法通过 Ctrl+C 正常关闭,强制退出还会导致下一次运行报“串口已被占用”的错误。根源在于将 timeout 设为了 None(永久阻塞)。当底层无数据到达时,子线程会卡在 C 语言层的系统调用里,完全没有机会执行下一轮 while not self._stop_event.is_set() 的判断。只有赋予串口一个适度的超时(如 0.2~0.5s),子线程才能周期性醒来检查退出信号,从而实现毫秒级优雅停机。

2. 为什么不用 daemon=True 一刀切?

将子线程设为 daemon=True 虽然在主线程退出时会跟随关闭,但这是一种非正常强杀行为。在强杀瞬间,串口底层设备文件句柄可能未能执行 ser.close(),操作系统未完成串口状态寄存器的复位,从而引发 Windows 下“Access Denied (拒绝访问)”或 Linux 下设备节点死锁。工程实践中,必须通过 threading.Event 主动通知子线程执行 ser.close(),再调用 join() 确认回收。

3. 队列背压控制与内存防爆

如果硬件端以每秒 5000 次的高频狂发传感器数据,而主线程每秒只能处理 100 次,若使用无界队列(默认 queue.Queue()),内存将被堆积的字节对象迅速吞噬直至 OOM 崩盘。因此,务必在构造函数中指明 maxsize。当队列满时,可根据业务选择覆盖丢弃最旧数据或报警限流,保证系统在极限工况下的稳态运行。

Python多线程实现后台非阻塞接收串口数据
图 4:高可靠后台串口接收系统四项设计支柱与核心机制总结

五、总结

通过多线程与线程安全队列构建后台非阻塞接收系统,是处理 Python 串口这类低速、高延迟流式通信的最佳工程解法。其核心在于将具有阻塞特性的底层 I/O 调用约束在后台工作线程中,利用微小超时机制周期性出让 CPU 与检查退出事件,并通过 queue.Queue 在主从线程间构建起一道抗突发、无冲突的数据缓冲带。掌握超时控制、事件同步与异常资源清理三大闭环,便能在工业控制、桌面上位机与数据采集场景中打造出稳定可靠的通信架构。

相关专题:

本站声明

本文内容仅供参考,不代表本站观点。转载或引用请注明出处。如发现内容问题,请通过联系我们页面反馈。

Python 相关产品和应用

全部下载

专题列表