【美高梅开户网址】信号的定义,开首理解Python进度的信号通信

信号的定义

信号(signal)–     进度之间通讯的办法,是一种软件中断。多个进程一旦接到到信号就会阻塞原来的程序执行流程来处理信号。

几个常用信号:

SIGINT     终止进程  中断进度  (control+c)

SIGTELANDM   终止进度     软件终止信号

SIGKILL   终止进程     杀死进度

SIGALRM 闹钟信号

 

发端驾驭Python进度的信号通信,python进度信号

信号的定义

信号(signal)–    
进度之间通信的办法,是一种软件中断。八个经过一旦接收到信号就会堵塞原来的程序执行流程来处理信号。

【美高梅开户网址】信号的定义,开首理解Python进度的信号通信。多少个常用信号:

SIGINT     终止进程  中断进程  (control+c)

SIGTETucsonM   终止进度     软件终止信号

SIGKILL   终止进度     杀死进程

SIGALENCOREM 闹钟信号
进程停止信号 SIGTE卡宴M和SIGKILL的不一样

SIGTE卡宴M相比友好,进度能捕捉这几个信号,依照你的须要来关闭程序。在关闭程序从前,您能够了结打开的笔录文件和姣好正在做的职责。在好几意况下,若是进度正在开始展览作业并且不能够暂停,那么进程能够忽略那几个SIGTECRUISERM信号。

对此SIGKILL信号,进程是无法忽视的。那是多个“俺任由您在做什么样,马上甘休”的信号。假诺你发送SIGKILL信号给进程,Linux就将经过截至在这边。
出殡信号一般有三种原因:

1(被动式) 
内核检查和测试到八个种类事件.例如子进程退出会像父进度发送SIGCHLD信号.键盘按下control+c会发送SIGINT信号

2(主动式)  通过系统调用kill来向钦赐进度发送信号
linux操作系统提供的信号

[[email protected]
myppt]$ kill -l

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL

 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE

 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2

13) SIGPIPE     14) SIGALRM     15) SIGTERM     16) SIGSTKFLT

17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP

21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU

25) SIGXFSZ     26) SIGVTALRM   27) SIGPROF     28) SIGWINCH

29) SIGIO       30) SIGPWR      31) SIGSYS      34) SIGRTMIN

35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3  38) SIGRTMIN+4

39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8

43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12

47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14

51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10

55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7  58) SIGRTMAX-6

59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2

63) SIGRTMAX-1  64) SIGRTMAX

Python提供的信号

Python 2.4.3 (#1, Jun 11 2009, 14:09:58)

[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> import signal

>>> dir(signal)

['NSIG', 'SIGABRT', 'SIGALRM', 'SIGBUS', 'SIGCHLD', 'SIGCLD', 'SIGCONT', 'SIGFPE', 'SIGHUP', 'SIGILL', 'SIGINT', 'SIGIO', 'SIGIOT', 'SIGKILL', 'SIGPIPE', 'SIGPOLL', 'SIGPROF', 'SIGPWR', 'SIGQUIT', 'SIGRTMAX', 'SIGRTMIN', 'SIGSEGV', 'SIGSTOP', 'SIGSYS', 'SIGTERM', 'SIGTRAP', 'SIGTSTP', 'SIGTTIN', 'SIGTTOU', 'SIGURG', 'SIGUSR1', 'SIGUSR2', 'SIGVTALRM', 'SIGWINCH', 'SIGXCPU', 'SIGXFSZ', 'SIG_DFL', 'SIG_IGN', '__doc__', '__name__', 'alarm', 'default_int_handler', 'getsignal', 'pause', 'signal']

操作系统规定了经过收到信号以往的私下认可行为

但是,大家得以经过绑定信号处理函数来修改进程收到信号以往的表现

美高梅开户网址,有多少个信号是不足更改的SIGTOP和SIGKILL
绑定信号处理函数

  import os  
  import signal  
  from time import sleep  

  def onsignal_term(a,b):  
    print '收到SIGTERM信号'  

  #这里是绑定信号处理函数,将SIGTERM绑定在函数onsignal_term上面  
  signal.signal(signal.SIGTERM,onsignal_term)  

  def onsignal_usr1(a,b):  
    print '收到SIGUSR1信号'  
  #这里是绑定信号处理函数,将SIGUSR1绑定在函数onsignal_term上面  
  signal.signal(signal.SIGUSR1,onsignal_usr1)  

  while 1:  
    print '我的进程id是',os.getpid()  
    sleep(10)  

运转该程序。然后经过别的3个经过来发送信号。
出殡信号

发送信号的代码如下:

  import os  
  import signal  

  #发送信号,16175是前面那个绑定信号处理函数的pid,需要自行修改  
  os.kill(16175,signal.SIGTERM)  
  #发送信号,16175是前面那个绑定信号处理函数的pid,需要自行修改  
  os.kill(16175,signal.SIGUSR1)  

SIGCHLD信号

接下来彰显一个子进度甘休后活动向父进度发送SIGCHLD信号的例证。

  ''''''' 
  子进程结束会向父进程发送SIGCHLD信号 
  '''  
  import os  
  import signal  
  from time import sleep  

  def onsigchld(a,b):  
    print '收到子进程结束信号'  
  signal.signal(signal.SIGCHLD,onsigchld)  

  pid = os.fork()  
  if pid == 0:  
    print '我是子进程,pid是',os.getpid()  
    sleep(2)  
  else:  
    print '我是父进程,pid是',os.getpid()  
    os.wait() #等待子进程结束  

接纳信号需求特别注意的地方:

若果二个历程收到3个SIGUS揽胜极光1信号,然后实施信号绑定函数,第2个SIGUS奥迪Q32信号又来了,第八个信号从未被处理实现的话,第二个信号就会甩掉。

之所以,尽量不要在多线程中应用信号。

本条不妥,测试没察觉有信号丢失

事例演示:

收受信号的次第,你会意识只要有别的一端接纳二十八线程向这么些进度发送信号,会一知半解一些信号。

  import os  
  import signal  
  from time import sleep  
  import Queue  

  QCOUNT = Queue.Queue() #初始化队列  

  def onsigchld(a,b):  
    '''''''收到信号后向队列中插入一个数字1'''  
    print '收到SIGUSR1信号'  
    sleep(2)  
    QCOUNT.put(1) #向队列中写入  

  def exithanddle(s,e): 
    raise SystemExit('收到终止命令,退出程序')  

  signal.signal(signal.SIGUSR1,onsigchld) #绑定信号处理函数  
  signal.signal(signal.SIGINT,exithanddle) #当按下Ctrl + C 终止进程 

  while 1:  
    print '我的pid是',os.getpid()  
    print '现在队列中元素的个数是',QCOUNT.qsize()  
    sleep(2) 

八线程发信号端的次第:

 

  ''''''' 
  使用多线程向另外一个进程发送信号 
  '''  
  import threading  
  import os  
  import signal  

  def sendusr1():  
    print '发送信号'  
    #这里的进程id需要写前一个程序实际运行的pid  
    os.kill(17788, signal.SIGUSR1)  

  WORKER = []  

  #开启6个线程  
  for i in range(1, 7):  
    threadinstance = threading.Thread(target = sendusr1)  
    WORKER.append(threadinstance)  

  for i in WORKER:  
    i.start()  

  for i in WORKER:  
    i.join()  

  print '主线程完成'  

内容增加补充:

Alarms
是二个非正规信号类型,它能够让程序须求系统经过一段时间对友好发送文告。os
标准模块中提议,它可用于制止无界定阻塞 I/O 操作或别的系统调用。

像上面例子,原本程序睡眠 10 后才打字与印刷出 print ‘After :’,
time.ctime(),然而出于 signal.alarm(2),所以 2 秒后就进行了打字与印刷。

  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(10) 
  print 'After :', time.ctime()  

留神Signal唯有主线程才能采取信号,像上面例子,print ‘Done waiting’
语句打字与印刷不出去,借使不调用 signal.alarm(2) ,程序将永久阻塞

  import signal 
  import threading 
  import os 
  import time 

  def signal_handler(num, stack): 
    print 'Received signal %d in %s' % \ 
      (num, threading.currentThread().name) 

  signal.signal(signal.SIGUSR1, signal_handler) 

  def wait_for_signal(): 
    print 'Waiting for signal in', threading.currentThread().name 
    signal.pause() 
    print 'Done waiting' 

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

  def send_signal(): 
    print 'Sending signal in', threading.currentThread().name 
    os.kill(os.getpid(), signal.SIGUSR1) 

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

  # Wait for the thread to see the signal (not going to happen!) 
  print 'Waiting for', receiver.name 
  signal.alarm(2) 
  receiver.join() 

还有一些亟待小心的是,就算 alarms
类信号能够在此外线程中调用,不过只幸好主线程中吸收接纳,像上边例子正是子线程
use_alarm 中调用  signal.alarm(1) ,可是不起作用 :

  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' 

信号的概念 信号(signal)–
进度之间通信的章程,是一种软件中断。2个经过一旦接受到信…

信号的定义

信号(signal)–     进度之间通信的办法,是一种软件中断。叁个进度一旦接收到信号就会阻塞原来的程序执行流程来处理信号。

多少个常用信号:

SIGINT     终止进程  中断进度  (control+c)

SIGTEGL450M   终止进度     软件终止信号

SIGKILL   终止进度     杀死进度

SIGAL福睿斯M 闹钟信号

 

信号的定义,信号概念

进程甘休信号 SIGTEPAJEROM和SIGKILL的区分

SIGTE奥迪Q7M相比友好,进度能捕捉那一个信号,根据你的必要来关闭程序。在关闭程序以前,您能够了结打开的笔录文件和成就正在做的职责。在少数情形下,若是进度正在拓展作业并且不能够暂停,那么进度能够忽略那些SIGTEQX56M信号。

对此SIGKILL信号,进度是无法忽视的。那是二个 “小编随便你在做如何,马上停下”的信号。若是你发送SIGKILL信号给过程,Linux就将经过结束在那边。

 

进度停止信号 SIGTE中华VM和SIGKILL的分别

SIGTE奔驰G级M相比友好,进度能捕捉这么些信号,依据你的必要来关闭程序。在关闭程序以前,您能够了结打开的记录文件和形成正在做的职责。在一些境况下,假如进度正在进行学业并且不能够暂停,那么进程能够忽略那些SIGTERubiconM信号。

对于SIGKILL信号,进度是无法忽视的。那是一个 “小编任由你在做哪些,霎时甘休”的信号。借使你发送SIGKILL信号给进度,Linux就将经过结束在那里。

 

信号的概念

信号(signal)–     进度之间通信的点子,是一种软件中断。五个进度一旦接收到信号就会阻塞原来的程序执行流程来处理信号。

多少个常用信号:

SIGINT     终止进度  中断进度  (control+c)

SIGTELacrosseM   终止进度     软件终止信号

SIGKILL   终止进度     杀死进度

SIGAL智跑M 闹钟信号

 

出殡信号一般有三种原因:

1(被动式)  内核检查和测试到多少个系统事件.例如子进度退出会像父进度发送SIGCHLD信号.键盘按下control+c会发送SIGINT信号

2(主动式)  通过系统调用kill来向钦命进度发送信号

 

 

操作系统规定了经过收到信号未来的暗许行为

唯独,大家得以由此绑定信号处理函数来修改进度收到信号以往的行事

有多个信号是不足更改的SIGTOP和SIGKILL

绑定信号处理函数:

 

  1.  

    import os

  2.  

    import signal

  3.  

    from time import sleep

  4.  

     

  5.  

    def onsignal_term(a,b):

  1.  

    print ‘收到SIGTERM信号’

  2.  

     

  3.  

    #此地是绑定信号处理函数,将SIGTEPRADOM绑定在函数onsignal_term上面

  1.  

    signal.signal(signal.SIGTERM,onsignal_term)

  2.  

     

  3.  

    def onsignal_usr1(a,b):

  1.  

    print ‘收到SIGUSR1信号’

  2.  

    #此处是绑定信号处理函数,将SIGUS奇骏1绑定在函数onsignal_term上面

  1.  

    signal.signal(signal.SIGUSR1,onsignal_usr1)

  2.  

     

  3.  

    while 1:

  1.  

    print ‘作者的经过id是’,os.getpid()

  2.  

    sleep(10)

 

运作该程序。然后经过别的一个进程来发送信号。

出殡音讯的代码如下:

  1.  

    import os

  2.  

    import signal

  3.  

     

  4.  

    #出殡信号,16175是近年来那二个绑定信号处理函数的pid,必要活动修改

  1.  

    os.kill(16175,signal.SIGTERM)

  2.  

    #发送信号,16175是前面那些绑定信号处理函数的pid,要求活动修改

  1.  

    os.kill(16175,signal.SIGUSR1)

出殡信号一般有三种原因:

1(被动式)  内核检查和测试到二个系统事件.例如子进度退出会像父进度发送SIGCHLD信号.键盘按下control+c会发送SIGINT信号

2(主动式)  通过系统调用kill来向钦点进度发送信号

 

 

操作系统规定了经过收到信号未来的私下认可行为

只是,大家得以因而绑定信号处理函数来修改进程收到信号未来的所作所为

有三个信号是不可改变的SIGTOP和SIGKILL

绑定信号处理函数

import os  
import signal  
from time import sleep  

def onsignal_term(a,b):  
    print '收到SIGTERM信号'  

#这里是绑定信号处理函数,将SIGTERM绑定在函数onsignal_term上面  
signal.signal(signal.SIGTERM,onsignal_term)  

def onsignal_usr1(a,b):  
    print '收到SIGUSR1信号'  
#这里是绑定信号处理函数,将SIGUSR1绑定在函数onsignal_term上面  
signal.signal(signal.SIGUSR1,onsignal_usr1)  

while 1:  
    print '我的进程id是',os.getpid()  
    sleep(10)  

运转该程序。然后通过别的三个历程来发送信号。

发送音信的代码如下:

 

import os  
import signal  

#发送信号,16175是前面那个绑定信号处理函数的pid,需要自行修改  
os.kill(16175,signal.SIGTERM)  
#发送信号,16175是前面那个绑定信号处理函数的pid,需要自行修改  
os.kill(16175,signal.SIGUSR1) 

 

 

接纳信号供给尤其注意的地点**:**

固然三个历程收到叁个SIGUSavancier1信号,然后实施信号绑定函数,第一个SIGUSR2信号又来了,第一个信号从未被处理达成的话,第②个信号就会放任。

因此,尽量不要在十六线程中应用信号。

本条不妥,测试没察觉有信号丢失

事例演示:

采用信号的程序,你会发觉只要有其余一端应用十六线程向这些进程发送信号,会管中窥豹一些信号。

进度截止信号 SIGTEWranglerM和SIGKILL的分别

SIGTE奥迪Q5M比较协调,进度能捕捉这么些信号,遵照你的内需来关闭程序。在关闭程序此前,您能够甘休打开的笔录文件和到位正在做的天职。在好几情况下,假设进度正在开始展览作业并且不能暂停,那么进程能够忽略这几个SIGTETiggoM信号。

对于SIGKILL信号,进度是不能忽视的。那是叁个 “笔者随便您在做什么样,立即停下”的信号。固然你发送SIGKILL信号给进程,Linux就将经过甘休在那边。

 

运用信号供给尤其注意的地点:

比方3个进程收到3个SIGUS库罗德1信号,然后实施信号绑定函数,第二个SIGUSXC602信号又来了,第一个信号没有被处理达成的话,第叁个信号就会废弃。

故而,尽量不要在三十二线程中选择信号。

以此不妥,测试没觉察有信号丢失

事例演示:

收取信号的顺序,你会发觉只要有别的一端应用二十二十四线程向这一个历程发送信号,会盲人摸象一些信号。

 

发送信号一般有二种原因:

1(被动式)  内核检查和测试到2个系统事件.例如子进度退出会像父进度发送SIGCHLD信号.键盘按下control+c会发送SIGINT信号

2(主动式)  通过系统调用kill来向钦命进度发送信号

 

 

操作系统规定了经过收到信号以往的私下认可行为

然而,我们得以由此绑定信号处理函数来修改进度收到信号今后的行事

有五个信号是不足更改的SIGTOP和SIGKILL

绑定信号处理函数

import os  
import signal  
from time import sleep  

def onsignal_term(a,b):  
    print '收到SIGTERM信号'  

#这里是绑定信号处理函数,将SIGTERM绑定在函数onsignal_term上面  
signal.signal(signal.SIGTERM,onsignal_term)  

def onsignal_usr1(a,b):  
    print '收到SIGUSR1信号'  
#这里是绑定信号处理函数,将SIGUSR1绑定在函数onsignal_term上面  
signal.signal(signal.SIGUSR1,onsignal_usr1)  

while 1:  
    print '我的进程id是',os.getpid()  
    sleep(10)  

运作该程序。然后经过其余2个历程来发送信号。

发送消息的代码如下:  

import os  
import signal  

#发送信号,16175是前面那个绑定信号处理函数的pid,需要自行修改  
os.kill(16175,signal.SIGTERM)  
#发送信号,16175是前面那个绑定信号处理函数的pid,需要自行修改  
os.kill(16175,signal.SIGUSR1) 

 

  选择信号须要特别注意的地点**:**

若果二个历程收到2个SIGUS瑞虎1信号,然后实施信号绑定函数,第二个SIGUSCRUISER2信号又来了,第四个信号从未被处理完结的话,第一个信号就会放任。

因而,尽量不要在三十二线程中央银行使信号。

本条不妥,测试没察觉有信号丢失

事例演示:

收取信号的次序,你会发觉只要有其它一端采取二十多线程向那个历程发送信号,会夏虫语冰一些信号。

信号的定义
信号(signal)–进度之间通信的章程,是一种软件中断。3个进程一旦接到到信号就会阻塞原来的顺序执…

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图