每週一個 Python 模塊 | signal
專欄地址：每週一個 Python 模塊html
信號是 Unix 系統中常見的一種進程間通訊方式（IPC），例如咱們常常操做的 kill -9 pid，這裏的 -9對應的就是 SIGKILL 信號，9 就是這個信號的編號，SIGKILL 是它的名稱。 因爲不一樣版本的 *nux 的實現會有差別，具體請參照系統 API，可使用 man 7 signal 查看全部信號的定義。python
那麼，信號有哪些使用場景呢？與其餘進程間通訊方式（例如管道、共享內存等）相比，信號所能傳遞的信息比較粗糙，只是一個整數。但正是因爲傳遞的信息量少，信號也更便於管理和使用，能夠用於系統管理相關的任務。例如通知進程終結、停止或者恢復等。每種信號用一個整型常量宏表示，以 SIG 開頭，好比 SIGCHLD、SIGINT 等。git
接收信號
Python 中使用 signal 模塊來處理信號相關的操做，定義以下：github
signal.signal(signalnum, handler)
複製代碼
signalnum 爲某個信號，handler 爲該信號的處理函數。進程能夠無視信號，能夠採起默認操做，還能夠自定義操做。當 handler 爲 signal.SIG_IGN 時，信號被無視（ignore）；當 handler 爲 singal.SIG_DFL，進程採起默認操做（default）；當 handler 爲一個函數名時，進程採起函數中定義的操做。shell
寫一個小程序，來處理 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
複製代碼
再來看另外一個函數，能夠對信號理解的更加透徹：bash
signal.getsignal(signalnum)
複製代碼
根據 signalnum 返回信號對應的 handler，多是一個能夠調用的 Python 對象，或者是 signal.SIG_IGN（表示被忽略）, signal.SIG_DFL（默認行爲已經被使用）或 None（Python 的 handler 還沒被定義）。多線程
看下面這個例子，獲取 signal 中定義的信號 num 和名稱，還有它的 handler 是什麼。app
#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。
相關文檔：
- 1. 每週一個 Python 模塊 | signal
- 2. 每週一個 Python 模塊 | socket
- 3. 每週一個 Python 模塊 | contextlib
- 4. 每週一個 Python 模塊 | ipaddress
- 5. 每週一個 Python 模塊 | struct
- 6. 每週一個 Python 模塊 | multiprocessing
- 7. 每週一個 Python 模塊 | datetime
- 8. 每週一個 Python 模塊 | operator
- 9. 每週一個 Python 模塊 | os.path
- 10. 每週一個 Python 模塊 | hashlib
- 更多相關文章...
- • Lua 模塊與包 - Lua 教程
- • DTD - XML 構建模塊 - DTD 教程
- • 委託模式
- • 使用Rxjava計算圓周率
-
每一个你不满意的现在，都有一个你没有努力的曾经。