Python多线程下sigwait与SIGALRM解析

本文深入探讨了在Python多线程环境下使用`sigwait`处理`SIGALRM`信号时常见的行为不一致问题。核心在于理解`signal()`与`pthread_sigmask()`在多线程中的作用，以及信号传递机制。教程将详细阐述如何通过正确配置线程的信号掩码，并结合`threading.Event`实现跨线程的信号同步处理，从而确保`sigwait`能按预期捕获并响应信号。

在Unix-like系统中，信号（Signals）是一种进程间通信或进程内事件通知的机制。Python的signal模块提供了与Unix信号交互的能力。然而，在多线程程序中处理信号，尤其是使用sigwait这类同步信号等待函数时，常常会遇到预期之外的行为。本文将聚焦于SIGALRM信号，并解释如何在Python多线程环境中正确地使用sigwait。

理解sigwait与信号处理机制

sigwait函数用于同步等待一个或多个信号。当调用sigwait的线程阻塞时，它会等待指定的信号集中的任一信号被传递到该进程，并且该信号必须被调用线程的信号掩码所阻塞。一旦信号到达，sigwait会解除阻塞并返回接收到的信号编号。

然而，signal.signal()函数设置的信号处理函数（Signal Handler）与sigwait的工作方式存在一个关键冲突点：

1. 异步处理（signal.signal()）: 如果一个信号没有被进程或线程的信号掩码阻塞，并且已经通过signal.signal()设置了处理函数，那么当该信号到达时，系统会立即调用注册的信号处理函数。
2. 同步等待（sigwait()）: sigwait只会在信号被阻塞时才有效。如果信号未被阻塞，它将直接触发信号处理函数（如果已注册）或执行默认动作（如终止进程），而不会被sigwait捕获。

这意味着，如果在某个线程中调用了signal.signal(SIGALRM, handler)来注册一个SIGALRM的处理器，并且SIGALRM没有被阻塞，那么当alarm()触发SIGALRM时，handler会被调用，但sigwait()将永远不会返回，因为它等待的是一个被阻塞的信号。

多线程环境中的信号传递与pthread_sigmask

在多线程程序中，信号传递机制变得更为复杂：

• 进程级信号: 信号是发送给整个进程的，但通常只由进程中的一个线程处理。
• 信号掩码继承: 新创建的线程会继承其父线程的信号掩码。
• signal()的限制: Python官方文档及POSIX标准都指出，signal()在多线程进程中的效果是未定义的。通常，signal()应该只在主线程中调用，因为它会影响整个进程的信号处理方式。

为了在特定线程中同步处理信号，我们需要精确控制每个线程的信号掩码，这正是signal.pthread_sigmask()的作用。pthread_sigmask()允许线程独立地修改自己的信号掩码，从而控制哪些信号可以被阻塞或解除阻塞。

常见的sigwait误用示例

考虑以下最初的代码尝试，它试图在一个子线程中使用sigwait等待SIGALRM：

from threading import Thread
from signal import signal, alarm, sigwait, SIGALRM, SIG_BLOCK, pthread_sigmask

class Check(Thread):
    def __init__(self):
        super().__init__()
        # 在子线程中设置信号处理器，这本身就是问题
        signal(SIGALRM, self.handler) 

    def handler(self, *_):
        print("Hello")

    def run(self):
        mask = SIGALRM,
        # 在子线程中阻塞SIGALRM
        pthread_sigmask(SIG_BLOCK, mask)

        for _ in range(5):
            alarm(1) # 这会向进程发送SIGALRM
            print("Waiting...")
            sigwait(mask) # 期望在此接收信号
            print("done")

if __name__ == "__main__":
    (check := Check()).start()
    check.join()

尽管在run方法中调用了pthread_sigmask(SIG_BLOCK, mask)来阻塞SIGALRM，但如果在__init__中调用了signal(SIGALRM, self.handler)，那么当alarm(1)触发SIGALRM时，Hello可能会被打印，但这表明信号被signal()注册的处理器捕获了，而不是被sigwait捕获。由于sigwait只等待被阻塞的信号，并且信号已经被处理器处理，sigwait将永远不会返回。

即使不设置信号处理器，如果主线程没有阻塞SIGALRM，alarm()触发的信号可能由主线程接收并执行SIGALRM的默认动作（终止进程），或者被其他未阻塞SIGALRM的线程接收。

正确的多线程sigwait信号处理模式

要正确地在子线程中使用sigwait，需要遵循以下原则：

1. 主线程（或所有非接收线程）阻塞或忽略目标信号: 确保SIGALRM不会在主线程或其他不希望处理它的线程中被意外捕获或触发默认行为。这可以通过pthread_sigmask(SIG_BLOCK, mask)或pthread_sigmask(SIG_IGN, mask)实现。
2. 接收信号的子线程阻塞目标信号: 在子线程的run方法开始时，使用pthread_sigmask(SIG_BLOCK, mask)确保sigwait能够捕获到信号。
3. 避免在子线程中调用signal.signal(): 信号处理器通常是进程级的，不适合在特定线程中设置。
4. 使用threading.Event进行跨线程同步: sigwait是阻塞的，当信号到达时，接收线程会解除阻塞。如果主线程或其他线程需要知道信号已被处理，可以使用threading.Event作为同步机制。

以下是一个符合上述原则的示例代码：

import signal
import threading
import time

# 定义要处理的信号掩码
TARGET_SIGNAL = signal.SIGALRM
signal_mask = (TARGET_SIGNAL,)

# 用于线程间通信的事件对象
signal_received_event = threading.Event()

class SignalReceiver(threading.Thread):
    """
    负责接收并处理指定信号的线程。
    """
    def __init__(self):
        super().__init__(daemon=True) # 设置为守护线程，主线程退出时自动终止

    def run(self):
        print(f"信号接收线程 {self.name} 启动，准备阻塞并等待 {TARGET_SIGNAL}...")
        # 在此线程中阻塞目标信号，确保sigwait能够捕获它
        signal.pthread_sigmask(signal.SIG_BLOCK, signal_mask)

        while True:
            # 同步等待信号
            sig = signal.sigwait(signal_mask)
            if sig == TARGET_SIGNAL:
                print(f"信号接收线程 {self.name} 收到信号: {sig}")
                # 通知主线程信号已收到
                signal_received_event.set()
            else:
                print(f"信号接收线程 {self.name} 收到未知信号: {sig}")

class MainProcessLogic:
    """
    模拟主进程的逻辑，负责发送信号并等待接收线程的通知。
    """
    def __init__(self, num_alarms=3):
        self.num_alarms = num_alarms

    def execute(self):
        # 启动信号接收线程
        receiver_thread = SignalReceiver()
        receiver_thread.start()

        # 主线程阻塞或忽略TARGET_SIGNAL，防止它被主线程处理
        # 这里使用SIG_IGN来忽略，也可以使用SIG_BLOCK来阻塞
        print(f"主线程设置 {TARGET_SIGNAL} 为忽略...")
        signal.pthread_sigmask(signal.SIG_IGN, signal_mask)

        print(f"主线程开始发送 {self.num_alarms} 次警报...")
        for i in range(self.num_alarms):
            print(f"\n[{i+1}/{self.num_alarms}] 主线程设置警报 (1秒后触发)...")
            signal.alarm(1) # 设置一个1秒后触发的SIGALRM

            print("主线程等待信号接收线程的通知...")
            # 等待信号接收线程设置事件，表示信号已收到
            signal_received_event.wait()
            print("主线程收到通知，信号已处理。")
            # 清除事件，为下一次等待做准备
            signal_received_event.clear()

            # 可以在这里加入一些主线程的其他操作
            time.sleep(0.1) # 稍微延迟一下，避免CPU空转

        print("\n所有警报发送并处理完毕。")

if __name__ == "__main__":
    main_logic = MainProcessLogic(num_alarms=3)
    main_logic.execute()
    # 确保子线程有时间处理完，或者等待其结束（对于守护线程通常不需要显式join）
    # time.sleep(2) 
    print("程序退出。")

代码解析与注意事项

1. signal_mask = (signal.SIGALRM,): 定义了一个元组，包含我们希望处理的信号。
2. signal_received_event = threading.Event(): 创建了一个Event对象，用于主线程和SignalReceiver线程之间的同步。
3. SignalReceiver线程:
   • super().__init__(daemon=True): 将接收线程设置为守护线程，这意味着当所有非守护线程（此处即主线程）结束时，守护线程会自动终止。
   • signal.pthread_sigmask(signal.SIG_BLOCK, signal_mask): 这是关键一步。在run方法开始时，SignalReceiver线程将其自身的信号掩码设置为阻塞SIGALRM。这样，当SIGALRM到达进程时，如果其他线程没有阻塞它，它会优先传递给未阻塞的线程。但如果所有其他线程都阻塞或忽略了它，它就会被传递给SignalReceiver，并由sigwait捕获。
   • signal.sigwait(signal_mask): 阻塞等待signal_mask中定义的信号。当SIGALRM到达并被该线程捕获时，sigwait返回SIGALRM的编号。
   • signal_received_event.set(): 信号被接收并处理后，设置事件，通知主线程。
4. 主线程:
   • signal.pthread_sigmask(signal.SIG_IGN, signal_mask): 主线程设置SIGALRM为忽略。这意味着即使SIGALRM被发送到进程，主线程也不会处理它，从而允许它被SignalReceiver线程捕获。使用SIG_BLOCK也是一个有效的选项。
   • signal.alarm(1): 在主线程中设置一个定时器，1秒后发送SIGALRM到进程。
   • signal_received_event.wait(): 主线程阻塞，直到SignalReceiver线程设置了signal_received_event，表明信号已成功接收。
   • signal_received_event.clear(): 在每次循环结束时清除事件，以便下一次wait()能够正常工作。

通过这种模式，我们确保了SIGALRM在主线程中不会被处理，而是被专门的SignalReceiver线程通过sigwait同步捕获，并利用threading.Event实现了线程间的有效通信。这种方法是处理Python多线程环境中异步信号的健壮方式。

总结

在Python多线程应用中使用sigwait处理信号，尤其是像SIGALRM这样的异步信号，需要对Unix信号处理机制和Python的signal模块有深入理解。核心在于：

• 隔离信号处理: 避免在多线程环境中使用signal.signal()注册处理器，尤其是在非主线程中。
• 精确控制信号掩码: 利用signal.pthread_sigmask()在主线程中阻塞或忽略目标信号，并在专门的接收线程中阻塞目标信号，以便sigwait能够捕获它。
• 同步机制: 使用threading.Event或其他同步原语来协调信号接收线程与主线程或其他工作线程之间的操作。

遵循这些原则，可以有效地在Python多线程程序中实现可靠的信号处理逻辑。