Python中如何终止工作线程中已执行的HTTP POST请求？

这个问题我之前也碰到过，确实挺闹心的——明明想马上退出应用，结果被30秒的timeout卡着动不了，用守护线程又怕留下资源泄漏、请求中途中断导致脏数据之类的隐患。给你几个靠谱的解决方案：

1. 用requests Session结合事件+关闭连接池中断请求 #

requests底层依赖urllib3，我们可以通过手动关闭连接池里的连接来强制中断正在执行的请求，再配合线程事件标记停止循环，这样就能快速退出。示例代码如下：

import requests
import threading
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# 用于标记是否停止工作线程的事件
stop_event = threading.Event()

def worker():
    # 创建Session，方便管理连接
    session = requests.Session()
    # 配置适配器，关闭重试（避免重试延长退出时间）
    retry = Retry(total=0, backoff_factor=0)
    adapter = HTTPAdapter(max_retries=retry)
    session.mount('http://', adapter)
    session.mount('https://', adapter)

    while not stop_event.is_set():
        mydata = get_data_from_queue()  # 替换成你的队列取数据逻辑
        try:
            # 发送请求
            resp = session.post('http://www.test.com', data=mydata, timeout=30)
            # 这里处理响应逻辑...
        except requests.exceptions.RequestException as e:
            # 如果是因为停止事件触发的连接中断，直接退出循环
            if stop_event.is_set():
                break
            # 其他异常正常处理
            print(f"请求出错: {e}")
    # 最后清理Session
    session.close()

def stop_worker():
    # 标记停止事件
    stop_event.set()
    # 关闭所有连接池中的连接，强制中断正在进行的请求
    for scheme in ['http://', 'https://']:
        for pool in worker.session.adapters[scheme].poolmanager.pools.values():
            pool.close()

原理很简单：当触发停止时，我们先标记线程停止循环，再直接关闭Session的连接池，这样正在执行的POST请求会立刻抛出连接关闭的异常，跳出等待流程，快速退出线程。

2. 改用异步请求框架aiohttp（更优雅的方案） #

如果你的应用可以调整为异步架构，用aiohttp会是更合适的选择——异步任务支持直接取消，不需要等待超时，而且资源管理更规范。示例代码：

import asyncio
import aiohttp

async def worker(queue, stop_event):
    async with aiohttp.ClientSession() as session:
        while not stop_event.is_set():
            try:
                # 从异步队列取数据
                mydata = await queue.get()
                async with session.post('http://www.test.com', data=mydata, timeout=30) as resp:
                    # 处理响应逻辑...
                    queue.task_done()
            except asyncio.CancelledError:
                # 任务被取消，直接退出
                break
            except aiohttp.ClientError as e:
                print(f"请求出错: {e}")
                pass

async def main():
    queue = asyncio.Queue()
    stop_event = asyncio.Event()
    # 创建工作任务
    worker_task = asyncio.create_task(worker(queue, stop_event))
    
    # 模拟运行一段时间后触发退出
    await asyncio.sleep(10)
    # 标记停止事件并取消任务
    stop_event.set()
    worker_task.cancel()
    # 等待任务结束
    await worker_task

asyncio.run(main())

当你需要退出时，只需要调用worker_task.cancel()，正在执行的POST请求会立刻抛出CancelledError，线程可以快速退出，完全不需要等30秒超时。

3. Unix系统下用信号+关闭套接字中断（底层方案） #

如果是在Linux/macOS这类Unix系统上，还可以通过捕获退出信号（比如SIGINT、SIGTERM），直接关闭当前请求的套接字来强制中断。不过这种方式需要手动跟踪套接字，跨平台性差，适合特定场景：

import requests
import threading
import signal
import socket

stop_flag = False
current_socket = None

def signal_handler(signum, frame):
    global stop_flag
    stop_flag = True
    # 如果当前有正在使用的套接字，直接关闭
    if current_socket:
        current_socket.close()

def worker():
    global current_socket
    while not stop_flag:
        mydata = get_data_from_queue()
        try:
            # 手动构建请求，获取底层套接字
            req = requests.Request('POST', 'http://www.test.com', data=mydata)
            prepared = req.prepare()
            with requests.Session() as session:
                adapter = session.get_adapter(prepared.url)
                conn = adapter.get_connection(prepared.url, proxies=None)
                current_socket = conn.sock
                # 发送请求
                resp = adapter.send(prepared, timeout=30, stream=False, verify=False, cert=None, proxies=None)
                current_socket = None
                # 处理响应...
        except (socket.error, requests.exceptions.RequestException) as e:
            if stop_flag:
                break
            print(f"请求出错: {e}")

# 注册信号处理器
signal.signal(signal.SIGTERM, signal_handler)
signal.signal(signal.SIGINT, signal_handler)

# 启动工作线程
worker_thread = threading.Thread(target=worker)
worker_thread.start()

另外补充一下你提到的守护线程问题：确实不建议用这种方式，因为主线程退出时守护线程会被强制终止，可能导致请求中途中断后服务器收到不完整数据，或者客户端这边的连接没有正确关闭，长期运行容易积累资源泄漏问题。

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