信号的概念,信号概念

信号的概念

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

多少个常用信号:

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

SIGTELANDM   终止进度     软件终止信号

SIGKILL   终止进程     杀死进度

SIGALSportageM 闹钟信号

 

起来驾驭Python进度的信号通信,python进度信号

信号的定义

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

多少个常用信号:

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

SIGTE奥迪Q7M   终止进程     软件终止信号

SIGKILL   终止进程     杀死进度

SIGALPAJEROM 闹钟信号
进程结束信号 SIGTECRUISERM和SIGKILL的区分

SIGTECRUISERM相比较友好,进程能捕捉这一个信号,遵照你的须求来关闭程序。在关闭程序在此以前,您能够了结打开的记录文件和姣好正在做的职务。在某些意况下,假设进程正在开始展览学业并且不能够暂停,那么进度能够忽略这几个SIGTERubiconM信号。

对于SIGKILL信号,进程是不能够忽视的。这是2个“笔者随便您在做什么样,立时停下”的信号。借使你发送SIGKILL信号给进度,Linux就将经过结束在那边。
发送信号一般有二种原因:

1(被动式) 
内核检查和测试到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)  

运作该程序。然后通过另外二个进度来发送信号。
出殡信号

发送信号的代码如下:

  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() #等待子进程结束  

应用信号必要尤其注意的地点:

只要叁个进度收到贰个SIGUS昂科拉1信号,然后实施信号绑定函数,第3个SIGUSHighlander2信号又来了,第三个信号没有被处理完结的话,第一个信号就会遗弃。

因此,尽量不要在多线程中利用信号。

这一个不妥,测试没觉察有信号丢失

事例演示:

收起信号的次第,你会发现只要有此外一端应用二十四线程向那一个历程发送信号,会眼光浅短一些信号。

  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)–
进度之间通讯的点子,是一种软件中断。多个进度一旦接受到信…

信号的定义

信号(signal)–     进度之间通信的格局,是一种软件中断。2个历程一旦接到到信号就会卡住原来的程序执行流程来拍卖信号。

多少个常用信号:

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

SIGTE奥迪Q3M   终止进度     软件终止信号

SIGKILL   终止进程     杀死进度

SIGAL科雷傲M 闹钟信号

 

信号的定义,信号概念

经过甘休信号 SIGTESportageM和SIGKILL的分别

SIGTECRUISERM比较和谐,进度能捕捉那么些信号,依据你的急需来关闭程序。在关闭程序此前,您能够终结打开的笔录文件和到位正在做的职分。在好几景况下,即便进度正在开始展览学业并且不能够暂停,那么进度能够忽略那些SIGTE福睿斯M信号。

对于SIGKILL信号,进度是不可能忽视的。那是多个 “笔者任由您在做什么,立时截止”的信号。假诺你发送SIGKILL信号给进度,Linux就将经过截至在那边。

 

进程停止信号 SIGTEENCOREM和SIGKILL的分别

SIGTEENVISIONM相比较友好,进度能捕捉那个信号,遵照你的须要来关闭程序。在关闭程序此前,您能够了结打开的记录文件和姣好正在做的职分。在一些情形下,假使进度正在开始展览学业并且不能暂停,那么进程能够忽略那个SIGTE酷路泽M信号。

对于SIGKILL信号,进度是不可能忽视的。那是二个 “笔者随便您在做哪些,立时停下”的信号。如果你发送SIGKILL信号给进程,Linux就将经过甘休在那边。

 

信号的概念

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

多少个常用信号:

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

SIGTEENVISIONM   终止进程     软件终止信号

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.  

    #此地是绑定信号处理函数,将SIGTE昂科威M绑定在函数onsignal_term上面

  1.  

    signal.signal(signal.SIGTERM,onsignal_term)

  2.  

     

  3.  

    def onsignal_usr1(a,b):

  1.  

    print ‘收到SIGUSR1信号’

  2.  

    #此处是绑定信号处理函数,将SIGUS本田UR-V1绑定在函数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)  

运行该程序。然后通过其余3个进程来发送信号。

出殡消息的代码如下:

 

import os  
import signal  

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

 

 

使用信号要求特别注意的地点**:**

万一二个进度收到四个SIGUS瑞鹰1信号,然后实施信号绑定函数,第③个SIGUSPAJERO2信号又来了,第1个信号没有被处理完成的话,第①个信号就会丢掉。

故此,尽量不要在多线程中利用信号。

这几个不妥,测试没察觉有信号丢失

事例演示:

收取信号的顺序,你会发觉只要有此外一端应用十二线程向这么些进度发送信号,会一孔之见一些信号。

进度结束信号 SIGTE奥迪Q3M和SIGKILL的分别

SIGTE陆风X8M相比较和谐,进程能捕捉那个信号,根据你的急需来关闭程序。在关闭程序从前,您能够终结打开的记录文件和成就正在做的任务。在一些意况下,如果进度正在进展学业并且不可能暂停,那么进度能够忽略那么些SIGTERubiconM信号。

对此SIGKILL信号,进度是不能够忽视的。那是三个 “作者随便您在做什么,立时停下”的信号。假诺你发送SIGKILL信号给进度,Linux就将经过截至在那边。

 

应用信号必要尤其注意的地方:

假诺八个进度收到2个SIGUS奇骏1信号,然后实施信号绑定函数,第3个SIGUS奥迪Q32信号又来了,第三个信号没有被处理实现的话,第一个信号就会屏弃。

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

这几个不妥,测试没觉察有信号丢失

事例演示:

收纳信号的次第,你会发现只要有此外一端应用十六线程向这么些进度发送信号,会一孔之见一些信号。

 

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

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)  

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

发送新闻的代码如下:  

import os  
import signal  

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

 

  选用信号须求尤其注意的地方**:**

一旦贰个历程收到1个SIGUS揽胜极光1信号,然后实施信号绑定函数,第三个SIGUSHighlander2信号又来了,第3个信号没有被处理达成的话,第2个信号就会吐弃。

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

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

事例演示:

收起信号的主次,你会发觉只要有此外一端接纳多线程向这几个进度发送信号,会盲人摸象一些信号。

信号的定义
信号(signal)–进度之间通信的法门,是一种软件中断。三个历程一旦接受到信号就会卡住原来的程序执…

网站地图xml地图