Python线程因Pandas操作出现“饥饿”，主线程卡顿如何解决？

问题描述 #

我用Python开发Qt UI应用，为保证UI响应流畅，将Pandas DataFrame相关操作放在独立的threading.Thread中执行。单个Pandas指令耗时并不显著，但主线程仍存在约1秒的卡顿。我了解全局解释器锁（GIL），按说它会在数毫秒后释放，为何子线程执行整整1秒仍在占用GIL？如何合理解决该卡顿问题？我发现在子线程中穿插time.sleep(0.00001)可消除卡顿，但这并非合理方案。若执行不含Pandas的纯Python密集计算，主线程无延迟问题。

复现代码 #

import threading
import time
from datetime import datetime
import pandas as pd

longest_so_far = 0
last_timestamp = datetime.now()
first_run = True


def print_delta_time(interval=0.001):
    global longest_so_far
    global last_timestamp
    global first_run
    while True:
        time.sleep(interval)
        current_time = datetime.now()

        if first_run:
            first_run = False
        else:
            delta_time = (current_time - last_timestamp).total_seconds()
            if delta_time > longest_so_far:
                print("New longest deltaTime:", delta_time)
                longest_so_far = delta_time
        last_timestamp = current_time


def perform_pandas_operations():
    time.sleep(1)
    print("Starting pandas operations")
    df = pd.DataFrame({
        'A': [f"{i}" for i in range(1000)],
    })
    for _ in range(20000):
        df['A'].str.contains(r'123$').sum()
        # time.sleep(0.0000001)
    print("Finished pandas operations")


pandas_thread = threading.Thread(target=perform_pandas_operations)
pandas_thread.daemon = True  # Ensure the thread exits when the main program exits
pandas_thread.start()

print_delta_time()

原因分析 #

• GIL释放规则的例外：Python的GIL会在纯Python代码执行一定字节码后（默认1000条）自动释放，但Pandas的核心操作（比如str.contains）基于C扩展实现。如果C扩展代码没有主动释放GIL，就会持续占用直到整个C函数执行完毕。你的循环中每次调用df['A'].str.contains(r'123$').sum()，底层是连续的C级字符串匹配与求和操作，这段C代码未主动释放GIL，导致每次调用都长时间占用GIL，主线程无法抢到时间片，进而出现卡顿。
• 纯Python计算无卡顿的原因：纯Python密集计算会触发GIL的定期释放，主线程能频繁抢到执行权，因此不会出现明显延迟。

合理解决方案 #

1. 拆分Pandas操作，主动触发GIL释放 #

将大循环拆分为小批次，在批次间插入不耗时但能释放GIL的操作（如time.sleep(0)），给主线程抢GIL的机会：

def perform_pandas_operations():
    time.sleep(1)
    print("Starting pandas operations")
    df = pd.DataFrame({
        'A': [f"{i}" for i in range(1000)],
    })
    batch_size = 100  # 拆分批次大小
    for batch in range(0, 20000, batch_size):
        for _ in range(batch_size):
            df['A'].str.contains(r'123$').sum()
        time.sleep(0)  # 触发GIL释放，不占用额外时间
    print("Finished pandas operations")

2. 使用multiprocessing替代threading #

GIL仅限制同一进程内的线程，多进程可完全绕过GIL限制。将Pandas操作放到独立进程中执行，子进程的GIL占用不会影响主线程的UI响应：

import multiprocessing  # 替换threading为multiprocessing

def perform_pandas_operations():
    time.sleep(1)
    print("Starting pandas operations")
    df = pd.DataFrame({
        'A': [f"{i}" for i in range(1000)],
    })
    for _ in range(20000):
        df['A'].str.contains(r'123$').sum()
    print("Finished pandas operations")

if __name__ == "__main__":
    pandas_process = multiprocessing.Process(target=perform_pandas_operations)
    pandas_process.daemon = True
    pandas_process.start()

    print_delta_time()

注意：多进程间数据传递存在开销，若需与主线程交互数据，可使用multiprocessing.Queue或Pipe等工具。

3. 优化Pandas操作逻辑，减少重复调用 #

你的代码中循环20000次执行相同的str.contains和sum，可优化为一次性计算，避免重复调用C扩展函数：

def perform_pandas_operations():
    time.sleep(1)
    print("Starting pandas operations")
    df = pd.DataFrame({
        'A': [f"{i}" for i in range(1000)],
    })
    # 一次性计算结果，无需循环20000次
    result = df['A'].str.contains(r'123$').sum()
    print("Finished pandas operations")

若业务上必须重复计算，可考虑用Numba将重复逻辑编译为C级代码，同时手动控制GIL释放。

内容的提问来源于stack exchange，提问作者AirToTec