每週一個 Python 模組 | signal

yongxinz發表於2018-12-07
Python

專欄地址：每週一個 Python 模組

訊號是 Unix 系統中常見的一種程式間通訊方式（IPC），例如我們經常操作的 kill -9 pid，這裡的 -9對應的就是 SIGKILL 訊號，9 就是這個訊號的編號，SIGKILL 是它的名稱。 由於不同版本的 *nux 的實現會有差異，具體請參照系統 API，可以使用 man 7 signal 檢視所有訊號的定義。

那麼，訊號有哪些使用場景呢？與其他程式間通訊方式（例如管道、共享記憶體等）相比，訊號所能傳遞的資訊比較粗糙，只是一個整數。但正是由於傳遞的資訊量少，訊號也更便於管理和使用，可以用於系統管理相關的任務。例如通知程式終結、中止或者恢復等。每種訊號用一個整型常量巨集表示，以 SIG 開頭，比如 SIGCHLD、SIGINT 等。

接收訊號

Python 中使用 signal 模組來處理訊號相關的操作，定義如下：

signal.signal(signalnum, handler)
複製程式碼

signalnum 為某個訊號，handler 為該訊號的處理函式。程式可以無視訊號，可以採取預設操作，還可以自定義操作。當 handler 為 signal.SIG_IGN 時，訊號被無視（ignore）；當 handler 為 singal.SIG_DFL，程式採取預設操作（default）；當 handler 為一個函式名時，程式採取函式中定義的操作。

寫一個小程式，來處理 ctrl+c事件和 SIGHUP，也就是 1 和 2 訊號。

#coding:utf-8

import signal
import time
import sys
import os

def handle_int(sig, frame):
    print "get signal: %s, I will quit"%sig
    sys.exit(0)

def handle_hup(sig, frame):
    print "get signal: %s"%sig


if __name__ == "__main__":
    signal.signal(2, handle_int)
    signal.signal(1, handle_hup)
    print "My pid is %s"%os.getpid()
    while True:
        time.sleep(3)
複製程式碼

我們來測試下，首先啟動程式（根據列印的 pid），在另外的視窗輸入 kill -1 21838 和 kill -HUP 21838, 最後使用 ctrl+c關閉程式。 程式的輸出如下：

# python recv_signal.py
My pid is 21838
get signal: 1
get signal: 1
^Cget signal: 2, I will quit
複製程式碼

再來看另一個函式，可以對訊號理解的更加透徹：

signal.getsignal(signalnum)
複製程式碼

根據 signalnum 返回訊號對應的 handler，可能是一個可以呼叫的 Python 物件，或者是 signal.SIG_IGN（表示被忽略）, signal.SIG_DFL（預設行為已經被使用）或 None（Python 的 handler 還沒被定義）。

看下面這個例子，獲取 signal 中定義的訊號 num 和名稱，還有它的 handler 是什麼。

#coding:utf-8

import signal

def handle_hup(sig, frame):
    print "get signal: %s"%sig

signal.signal(1, handle_hup)

if __name__ == "__main__":

    ign = signal.SIG_IGN
    dfl = signal.SIG_DFL
    print "SIG_IGN", ign
    print "SIG_DFL", dfl
    print "*"*40

    for name in dir(signal):
        if name[:3] == "SIG" and name[3] != "_":
            signum = getattr(signal, name)
            gsig = signal.getsignal(signum)

            print name, signum, gsig
複製程式碼

執行的結果：可以看到大部分訊號都是都有預設的行為。

SIG_IGN 1
SIG_DFL 0
****************************************
SIGABRT 6 0
SIGALRM 14 0
SIGBUS 10 0
SIGCHLD 20 0
SIGCONT 19 0
SIGEMT 7 0
SIGFPE 8 0
SIGHUP 1 <function handle_hup at 0x109371c80>
SIGILL 4 0
SIGINFO 29 0
SIGINT 2 <built-in function default_int_handler>
SIGIO 23 0
SIGIOT 6 0
SIGKILL 9 None
SIGPIPE 13 1
SIGPROF 27 0
SIGQUIT 3 0
SIGSEGV 11 0
SIGSTOP 17 None
SIGSYS 12 0
SIGTERM 15 0
SIGTRAP 5 0
SIGTSTP 18 0
SIGTTIN 21 0
SIGTTOU 22 0
SIGURG 16 0
SIGUSR1 30 0
SIGUSR2 31 0
SIGVTALRM 26 0
SIGWINCH 28 0
SIGXCPU 24 0
SIGXFSZ 25 1
複製程式碼

常用的幾個訊號：

編號 名稱 作用
1 SIGHUP 終端掛起或者終止程式。預設動作為終止程式
2 SIGINT 鍵盤中斷 <ctrl+c> 經常會用到。預設動作為終止程式
3 SIGQUIT 鍵盤退出鍵被按下。一般用來響應 <ctrl+d>。 預設動作終止程式
9 SIGKILL 強制退出。 shell中經常使用
14 SIGALRM 定時器超時，預設為終止程式
15 SIGTERM 程式結束訊號，程式一般會清理完狀態在退出，我們一般說的優雅的退出

傳送訊號

signal 包的核心是設定訊號處理函式。除了 signal.alarm() 向自身傳送訊號之外，並沒有其他傳送訊號的功能。但在 os 包中，有類似於 Linux 的 kill 命令的函式，分別為：

os.kill(pid, sid)
os.killpg(pgid, sid)
複製程式碼

分別向程式和程式組傳送訊號。sid 為訊號所對應的整數或者 singal.SIG*。

定時發出 SIGALRM 訊號

它被用於在一定時間之後，向程式自身傳送 SIGALRM 訊號，這對於避免無限期地阻塞 I/O 操作或其他系統呼叫很有用。

import signal
import time


def receive_alarm(signum, stack):
    print('Alarm :', time.ctime())


# Call receive_alarm in 2 seconds
signal.signal(signal.SIGALRM, receive_alarm)
signal.alarm(2)

print('Before:', time.ctime())
time.sleep(4)
print('After :', time.ctime())

# output
# Before: Sat Apr 22 14:48:57 2017
# Alarm : Sat Apr 22 14:48:59 2017
# After : Sat Apr 22 14:49:01 2017
複製程式碼

在此示例中，呼叫 sleep() 被中斷，但在訊號處理後繼續，因此sleep()返回後列印的訊息顯示程式執行時間與睡眠持續時間一樣長。

忽略訊號

要忽略訊號，請註冊 SIG_IGN 為處理程式。

下面這個例子註冊了兩個程式，分別是 SIGINT 和 SIGUSR1，然後用 signal.pause() 等待接收訊號。

import signal
import os
import time


def do_exit(sig, stack):
    raise SystemExit('Exiting')


signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGUSR1, do_exit)

print('My PID:', os.getpid())

signal.pause()

# output
# My PID: 72598
# ^C^C^C^CExiting
複製程式碼

通常 SIGINT（當使用者按下 Ctrl-C 時由 shell 傳送到程式的訊號）會引發 KeyboardInterrupt。這個例子在它看到 SIGINT 時直接忽略了。輸出中的每個 ^C 表示嘗試從終端終止指令碼。

從另一個終端使用 kill -USR1 72598 將指令碼退出。

訊號與執行緒

多執行緒環境下使用訊號，只有 main thread 可以設定 signal 的 handler，也只有它能接收到 signal. 下面用一個例子看看效果，在一個執行緒中等待訊號，並從另一個執行緒傳送訊號。

#coding:utf-8
#orangleliu py2.7
#thread_signal.py

import signal
import threading
import os
import time

def usr1_handler(num, frame):
    print "received signal %s %s"%(num, threading.currentThread())

signal.signal(signal.SIGUSR1, usr1_handler)

def thread_get_signal():
    #如果在子執行緒中設定signal的handler 會報錯
    #ValueError: signal only works in main thread
    #signal.signal(signal.SIGUSR2, usr1_handler)

    print "waiting for signal in", threading.currentThread()
    #sleep 程式直到接收到訊號
    signal.pause()
    print "waiting done"

receiver = threading.Thread(target=thread_get_signal, name="receiver")
receiver.start()
time.sleep(0.1)

def send_signal():
    print "sending signal in ", threading.currentThread()
    os.kill(os.getpid(), signal.SIGUSR1)

sender = threading.Thread(target=send_signal, name="sender")
sender.start()
sender.join()

print 'pid', os.getpid()
# 這裡是為了讓程式結束，喚醒 pause
signal.alarm(2)
receiver.join()

# output
# waiting for signal in <Thread(receiver, started 123145306509312)>
# sending signal in  <Thread(sender, started 123145310715904)>
# received signal 30 <_MainThread(MainThread, started 140735138967552)>
# pid 23188
# [1]    23188 alarm      python thread_signal.py
複製程式碼

Python 的 signal 模組要求，所有的 handlers 必需在 main thread 中註冊，即使底層平臺支援執行緒和訊號混合程式設計。即使接收執行緒呼叫了 signal.pause()，但還是沒有接收到訊號。程式碼結尾處的 signal.alarm(2) 是為了喚醒接收執行緒的 pause()，否則接收執行緒永遠不會退出。

儘管 alarms 可以在任意的執行緒中設定，但他們只能在 main thread 接收。

import signal
import time
import threading


def signal_handler(num, stack):
    print(time.ctime(), 'Alarm in',
          threading.currentThread().name)


signal.signal(signal.SIGALRM, signal_handler)


def use_alarm():
    t_name = threading.currentThread().name
    print(time.ctime(), 'Setting alarm in', t_name)
    signal.alarm(1)
    print(time.ctime(), 'Sleeping in', t_name)
    time.sleep(3)
    print(time.ctime(), 'Done with sleep in', t_name)


# Start a thread that will not receive the signal
alarm_thread = threading.Thread(
    target=use_alarm,
    name='alarm_thread',
)
alarm_thread.start()
time.sleep(0.1)

# Wait for the thread to see the signal (not going to happen!)
print(time.ctime(), 'Waiting for', alarm_thread.name)
alarm_thread.join()

print(time.ctime(), 'Exiting normally')

# output
# Sat Apr 22 14:49:01 2017 Setting alarm in alarm_thread
# Sat Apr 22 14:49:01 2017 Sleeping in alarm_thread
# Sat Apr 22 14:49:01 2017 Waiting for alarm_thread
# Sat Apr 22 14:49:02 2017 Alarm in MainThread
# Sat Apr 22 14:49:04 2017 Done with sleep in alarm_thread
# Sat Apr 22 14:49:04 2017 Exiting normally
複製程式碼

alarm 並沒有中斷 use_alarm() 中的 sleep。

相關文件：

pymotw.com/3/signal/in…

orangleliu.info/2016/03/06/…

www.cnblogs.com/vamei/archi…

相關文章