精华内容
下载资源
问答
  • 信号接收方可以订阅特定的发送方,也可以接收任何发送发送信号。 它支持分派到连接的协程和接收器函数的任意混合。 >> > from blinker import signal >> > started = signal ( 'round-started' ) >> > def ...
  • 信号signal 是python进程间通信多种机制中的其中一种机制。可以对操作系统进程的控制,当进程中发生某种原因而中断时,可以异步处理这个异常。 信号通过注册的方式‘挂’在一个进程中,并且不会阻塞该进程的运行。...

    信号signal 是python进程间通信多种机制中的其中一种机制。可以对操作系统进程的控制,当进程中发生某种原因而中断时,可以异步处理这个异常。

    信号通过注册的方式‘挂’在一个进程中,并且不会阻塞该进程的运行。一个进程一旦接收到其他进程(可能是应用中的其他进程,也可能使操作系统中的进程)发送的信号就会打断原来的程序执行流程来处理这个信号。

     

    名词理解:

    异步: 程序在执行中利用内核功能帮助完成必要的辅助操作,不影响应用层持续执行

    注意: 这里的同步和异步机制是相对多进程而言的。

     

    在多个进程中通信的机制中,只有singal是异步执行的,另外python进程间通信的机制还有pipe(管道),queue(队列),value(共享空间)等等。

     

    signal可以用在什么地方?

    siganl的应用:

    1. 故障定位技术(进程的底层故障,例如进程突然中断和一些可能性较小的故障)

    2. 对进程的流程控制 

     

    首先说说与信号signal有关的几个函数

    (1)os.kill(pid,sig)

    发送一个信号给某个进程

    参数解析:

    pid 指定发送信号的进程号

    sig  要发送的信号代号(需要通过signal模块获取)

     

    (2)signal.alarm(sec)  非阻塞函数

    设置时钟信号,在一定时间后给自身发送一个SIGALRM信号

     

    原理: 时钟的创建是进程交由操作系统内核(kernal)帮助创建的

    时钟和进程之间是异步执行的,当时钟到时,内核会发送信号给进程,进程接收信号进行相应的响应操作。

    注意:如果设置多个时钟,后面的时钟会覆盖前面的时钟,一个进程只有一个挂起的时钟。

     

    (3)signal.pause()

    阻塞进程,等待一个信号.当接收到信号时就会停止阻塞

    例如:等待signal()函数的发送

     

    (4)signal.signal(sig,handler)

    这是信号中最关键的一个方法,用于声明一个信号。当进程运行过程中出现故障异常或者需要进程间通信时,由操作系统内核中的进程或者应用中的进程发出处理信号,通知注册了信号的进程进行处理。

    signal.signal(sig,handler)

    参数理解:

    sig 要处理的信号名称

    handler 信号处理方法  

    可选值: SIG_DFL    表示默认方法处理

                   SIG_IGN    表示忽略这个信号(一般为了避免父进程和子进程的互相干扰而使用)

                   handler       自定义回调函数

     

    自定义回调函数handler:

    这个是当用于在进程捕捉到其他进程发送的信号时调用的函数,当此函数返回时,进程继续继续按原来的逻辑顺序执行。此函数在定义时python普通函数的定义没有区别。函数名不一定是handler,但作为作为参数传入signal()方法的参数名一定是与定义handler函数的函数相同。

    def  handler(signum,frame):

        do  something…

     1)sig :接收到的信号编号,signal模块内部定义了一些常用的内核信号,并为它们进行了编号。

    例如:

    windows操作系统下

    SIGNALINT编号为2

    >>>signal.SIGINT

    <Signals.SIGINT: 2>

    SIGBREAK编号为21

    >>>signal.SIGBREAK

    <Signals.SIGBREAK: 21>

    注意:windows操作系统没有SIGUSR1和SIGUSR2这两个型号类型,linux操作系统才有。

     

    2) frame:信号结构对象(可以通过结构对象查看信号信息,基本不用)

     

    signal函数实际上是一个异步的回调函数,只要执行了该函数,则进程任意时候接收到相应信号都会处理。 这里的异步就是上文提到的异步机制,是计算机内核程序与本进程间同时运行,互相不干扰的一种机制,对于进程的正常执行有着关键的作用。这种异步机制在任何后端编程语言中都是存在的,只不过实现的方式和细节不一样而已。

     

    singnal怎么用?

    一般信号signal是在需要检测异常的程序的开头就定义好了,程序顺序向下运行时,一旦捕获到操作系统发出的signal或者其他进程发出的signal,马上就会停止当前的程序运行状态,去处理捕获到的signal。

    案例:
    注册signal
    import signal
    import os
    import time
    
    print("The process's PID is:",os.getpid())
    def handle_signal(signum,frame):
        print('Received and handle:',signum)
    
    #注册信号处理程序
    signal.signal(signal.SIGUSR1,handle_signal)
    signal.signal(signal.SIGUSR2,handle_signal)
    
    print("The process's PID is:",os.getpid())
    
    while True:
        print('Waiting...')
        print(time.ctime())
        time.sleep(2)

     

    终端分别输入输入:
    >>> os.kill(7094,signal.SIGUSR1)
    >>> os.kill(7094,signal.SIGUSR2)

    结果:

    Waiting...
    Sat Nov 17 12:19:26 2018
    Waiting...
    Sat Nov 17 12:19:28 2018
    Received and handle: 10
    Waiting...
    Sat Nov 17 12:19:30 2018
    
    Waiting...
    Sat Nov 17 12:22:21 2018
    Received and handle: 12
    Waiting...
    Sat Nov 17 12:22:23 2018

     

     

    处理interrupt

    import signal
    import os
    import sys
    import time
    
    print("The process's PID is:",os.getpid())
    
    def handle_signal(signum,frame):
        print('Received and handle:',signum)
    
    def handle_interrupt(signum,frame):
        print('Receive keyboard interrupt')
        sys.exit(0)  #退出进程
    
    #注册信号处理程序
    signal.signal(signal.SIGINT,handle_interrupt)
    signal.signal(signal.SIGUSR1,handle_signal)
    
    while True:
        print('Waiting...')
        print(time.ctime())
        time.sleep(2)

    终端输入:

    >>> os.kill(7625,signal.SIGINT)

    会退出进程

     

    如果注册函数改为

    signal.signal(signal.SIGINT,signal.SIG_IGN)

    则会忽略终端发出的SIGINT

     

    时钟

    给signal设定时钟
    def handle_signal(signum,frame):
        print('Time is up!',signum)
        sys.exit()
    
    signal.signal(signal.SIGALRM,handle_signal)
    signal.alarm(3)
    
    while True:
        print(time.ctime())
        time.sleep(1)

    结果:

    Sat Nov 17 13:21:51 2018
    Sat Nov 17 13:21:52 2018
    Sat Nov 17 13:21:53 2018
    Time is up! 14

     

    附录:

    windows下的sig信号类型

    >>> dir(signal)

    ['CTRL_BREAK_EVENT', 'CTRL_C_EVENT', 'Handlers', 'NSIG', 'SIGABRT', 'SIGBREAK', 'SIGFPE', 'SIGILL', 'SIGINT', 'SIGSEGV', 'SIGTERM', 'SIG_DFL', 'SIG_IGN', 'Signals', '_IntEnum', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_enum_to_int', '_int_to_enum', '_signal', 'default_int_handler', 'getsignal', 'set_wakeup_fd', 'signal']

     

    linux下的sig信号类型

    >>> dir(signal)

    ['ITIMER_PROF', 'ITIMER_REAL', 'ITIMER_VIRTUAL', 'ItimerError', '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__', '__package__', 'alarm', 'default_int_handler', 'getitimer', 'getsignal', 'pause', 'set_wakeup_fd', 'setitimer', 'siginterrupt', 'signal']

     

    常用信号类型解析

    SIGHUP   断开连接

    SIGINT    ctrl-C

    SIGUIT    ctrl-\

    SIGTSTP   ctrl-z

    SIGKILL    终止进程且不能被处理

    SIGSTOP   暂停进程且不能被处理

    SIGALRM   时钟进程

    SIGCHLD   子进程状态改变发送给父进程信息号(但一般父进程不会处理)

     

    参考文章:

    https://www.cnblogs.com/xautxuqiang/p/5339602.html

    https://www.cnblogs.com/madsnotes/articles/5688681.html

     


     

    转载于:https://www.cnblogs.com/thomson-fred/p/9502497.html

    展开全文
  • 本文研究的主要是Python中的Signal 信号的相关内容,具体如下。 常用信号类型 SIGINT 终止进程 中断进程,不可通过signal.signal()捕捉(相当于Ctrl+C) SIGTERM 终止进程 软件终止信号,可通过signal.signal()捕捉...
  • 一、问题描述 在用Python爬取网络视频时,利用了ffmpeg下载并合并m3u8文件,在CMD上运行结果如下: C:\Users\fz.000&gt;ffmpeg -i "...

    一、问题描述

    在用Python爬取网络视频时,利用了ffmpeg下载并合并m3u8文件,在CMD上运行结果如下:

    C:\Users\fz.000>ffmpeg -i "https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone.m3u8?auth_key=1535101557-0-0-fedf56c648bfe0d60ef8e0aa89b6a297&expiration=1535101557&disable_local_cache=0" -c copy "E:/PycharmProjects/Video_Crack/video/video1.mp4"
    ffmpeg version N-91646-g78d4b6bd43 Copyright (c) 2000-2018 the FFmpeg developers
      built with gcc 8.2.1 (GCC) 20180813
      configuration: --enable-gpl --enable-version3 --enable-sdl2 --enable-fontconfig --enable-gnutls --enable-iconv --enable-libass --enable-libbluray --enable-libfreetype --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenjpeg --enable-libopus --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libtheora --enable-libtwolame --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxml2 --enable-libzimg --enable-lzma --enable-zlib --enable-gmp --enable-libvidstab --enable-libvorbis --enable-libvo-amrwbenc --enable-libmysofa --enable-libspeex --enable-libxvid --enable-libaom --enable-libmfx --enable-amf --enable-ffnvcodec --enable-cuvid --enable-d3d11va --enable-nvenc --enable-nvdec --enable-dxva2 --enable-avisynth
      libavutil      56. 19.100 / 56. 19.100
      libavcodec     58. 23.100 / 58. 23.100
      libavformat    58. 17.103 / 58. 17.103
      libavdevice    58.  4.101 / 58.  4.101
      libavfilter     7. 26.100 /  7. 26.100
      libswscale      5.  2.100 /  5.  2.100
      libswresample   3.  2.100 /  3.  2.100
      libpostproc    55.  2.100 / 55.  2.100
    [hls,applehttp @ 00000263fedba840] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00001.ts?auth_key=1535101557-0-0-e6986ea2f49dd0a3ad5954823a79b3d0' for reading
    [hls,applehttp @ 00000263fedba840] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00002.ts?auth_key=1535101557-0-0-1f6b4fb3db9df8067d972990c71a74cb' for reading
    Input #0, hls,applehttp, from 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone.m3u8?auth_key=1535101557-0-0-fedf56c648bfe0d60ef8e0aa89b6a297&expiration=1535101557&disable_local_cache=0':
      Duration: 00:00:59.12, start: 1.433556, bitrate: N/A
      Program 0
        Metadata:
          variant_bitrate : 0
        Stream #0:0: Video: h264 (High) ([27][0][0][0] / 0x001B), yuv420p, 1280x2276, 25 fps, 25 tbr, 90k tbn, 50 tbc
        Metadata:
          variant_bitrate : 0
        Stream #0:1: Audio: aac (LC) ([15][0][0][0] / 0x000F), 44100 Hz, stereo, fltp
        Metadata:
          variant_bitrate : 0
    Output #0, mp4, to 'E:/PycharmProjects/Video_Crack/video/video1.mp4':
      Metadata:
        encoder         : Lavf58.17.103
        Stream #0:0: Video: h264 (High) (avc1 / 0x31637661), yuv420p, 1280x2276, q=2-31, 25 fps, 25 tbr, 90k tbn, 90k tbc
        Metadata:
          variant_bitrate : 0
        Stream #0:1: Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp
        Metadata:
          variant_bitrate : 0
    Stream mapping:
      Stream #0:0 -> #0:0 (copy)
      Stream #0:1 -> #0:1 (copy)
    Press [q] to stop, [?] for help
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00003.ts?auth_key=1535101557-0-0-91103599f3d036c53025d4469811f47f' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00004.ts?auth_key=1535101557-0-0-5425a38189bbdc37cce8e75c99ab8bc0' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00005.ts?auth_key=1535101557-0-0-9b2cfb83e2058f2904be5b9fc3cd2665' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00006.ts?auth_key=1535101557-0-0-7c76c5b983dec9efe285a19beafe7fa4' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00007.ts?auth_key=1535101557-0-0-973c55d77a4dc646c11d79aeba2bac4f' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00008.ts?auth_key=1535101557-0-0-76f76084ff3e5bd058aa7e00336b07d4' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00009.ts?auth_key=1535101557-0-0-82b119c4d5e5e756c4449e5870e18f00' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00010.ts?auth_key=1535101557-0-0-3530886b5ebacb68c63dca9b1b0d31af' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00011.ts?auth_key=1535101557-0-0-22cba48926d6bfedd02711f7da42a577' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00012.ts?auth_key=1535101557-0-0-af00d2111cf04e0d1d81f6523cb3d2ab' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00013.ts?auth_key=1535101557-0-0-64bd48246a8ba362cedfff4a78d1ebfa' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00014.ts?auth_key=1535101557-0-0-b82190c2c1a4ddebeea337688c1a351e' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00015.ts?auth_key=1535101557-0-0-72da7559f7fbe2ec24f30ef0be2cbc50' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00016.ts?auth_key=1535101557-0-0-7c93a14b6c6c10b09d24b30ea4bf7db3' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00017.ts?auth_key=1535101557-0-0-a7ae4f217482020d64e85c2e78704cd2' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00018.ts?auth_key=1535101557-0-0-f74f9fb587e0b96e1a1a053bcb2e511d' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00019.ts?auth_key=1535101557-0-0-21fcb34bb2c06fb165ed29083d278014' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00020.ts?auth_key=1535101557-0-0-36b552cde620d564fe469a5d7138111a' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00021.ts?auth_key=1535101557-0-0-fd86d0f8d8e7815f3da90626f4855233' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00022.ts?auth_key=1535101557-0-0-6cfd887896c6292abb643c8fc6d05535' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00023.ts?auth_key=1535101557-0-0-513a1071888bd474984b9b37345b997c' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00024.ts?auth_key=1535101557-0-0-126f976c659bf9bc55eacb6dfdb0f1e0' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00025.ts?auth_key=1535101557-0-0-1a990e2b3bbb8167c9dc1c3ae4fe644b' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00026.ts?auth_key=1535101557-0-0-9fa465a24d3329a415484e286fbd252d' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00027.ts?auth_key=1535101557-0-0-6cb593e7c453f0d981e3ddc7baff6ace' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00028.ts?auth_key=1535101557-0-0-fbdf9f5f84c52e39c5d973e53eb01f75' for reading
    [https @ 00000263fedc0080] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00029.ts?auth_key=1535101557-0-0-95cf329432d5c39f98c8a7554194477e' for reading
    [https @ 00000263fee04180] Opening 'https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone-00030.ts?auth_key=1535101557-0-0-a601529344546d2b3733e2e6454b475c' for reading
    frame= 1479 fps= 58 q=-1.0 Lsize=   15220kB time=00:00:59.11 bitrate=2109.0kbits/s speed=2.33x
    video:14263kB audio:924kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.210394%
    
    C:\Users\fz.000>

    运行结束后,在相应的目录下就会有下载好的视频。

    运行命令后的结果中有这么一句:

    也就是说下载过程中按下“q”键会终止下载。用同样的视频m3u8链接尝试了一下,果然还没下载完就立刻停止了,从文件的大小就可以看出来,是比原来要小的,不过这时的视频仍然能够正常播放(这就是后面我们要的效果)。

    下面我们不用CMD,而是用python程序实现这个过程:

    该程序使用subprocess模块创建并返回一个子进程,并在这个子进程中执行指定的程序(也就是ffmpeg命令)。同时可以进行进程间通信,将子程序的输出信息(也就是采用命令行时的那一大片输出信息)打印出来。

    subprocess模块用法的相关用法参见:https://blog.csdn.net/polyhedronx/article/details/82015271

    import shlex
    import subprocess
    
    
    if __name__ == '__main__':
    	try:
    		shell_cmd = 'ffmpeg -i "https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone.m3u8?auth_key=1535101557-0-0-fedf56c648bfe0d60ef8e0aa89b6a297&expiration=1535101557&disable_local_cache=0" -c copy "E:/PycharmProjects/Video_Crack/video/video1.mp4"'
    		cmd = shlex.split(shell_cmd)
    		p = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    		while p.poll() is None:
    			line = p.stdout.readline().decode('gbk').strip()
    			print(line)
    		if p.returncode == 0:
    			print('subprocess success')
    		else:
    			print('subprocess failed with code', p.returncode)
    	except (OSError, ValueError):
    		print('stop here')
    

     程序写好之后,我们仍然不满足,想要把它做成一个图形界面,其中需要有三个按钮,“下载”、“停止”和“退出”,如下图。“下载”和“退出”都比较容易,问题就是这个停止按钮,怎么样才能实现按下“停止”按钮视频停止下载,并且已经下载好的部分还能正常播放呢?也就是说我们要写一个函数,按下“停止”按钮会启动该函数,而该函数的功能就是停止视频下载(并且保证已下载的部分能正常播放)。

    二、初步尝试

    首先,我们很自然的会想到,可以向子进程发送一个“q”,实现CMD中按下“q”的效果,而且查一下资料,的确有向subprocess子进程发送信息的命令:

    Popen.communicate(input='something', timeout=None)
    
    # or
    
    Popen.stdin.write('something')

    但是...这其实是行不通的,因为这样发送给子进程的是数据而不是命令,效果就像是在CMD上打印了一个“q”,并不能使视频下载停止。

    好吧,我们不要放弃,那有没有向子进程发送信号的命令呢?答案是有的:

    Popen.send_signal(signal)  # 向子进程发送signal信号
    
    Popen.terminate()  # 终止(stop)子进程
    
    Popen.kill()  # 杀死子进程。在Windows上,kill()和terminate()作用相同

    其中,signal信号的相关知识参见:https://blog.csdn.net/polyhedronx/article/details/81989918

    通过上面这篇博客,我们知道在Windows中还有两种方法可以分别向进程和进程组发送信号:

    os.kill(pid, sid)
    
    os.killpg(pgid, sid)

    其中,pid为进程号,比如“Popen.pid”,sid为要发送的信号。Windows中可以使用的信号是有限制的,详见:https://blog.csdn.net/polyhedronx/article/details/81988335

    下面两种方法的效果是一样的:

    Popen.send_signal(signal.SIGTERM)
    
    os.kill(Popen.pid, signal.SIGTERM)

    有了这么多可以用的命令,我们先来尝试一下 terminate() 和 kill() :

    import shlex
    import subprocess
    
    if __name__ == '__main__':
    	try:
    		shell_cmd = 'ffmpeg -i "https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone.m3u8?auth_key=1535110216-0-0-3d035cc32139ce884c8a1cbb14d0d04d&expiration=1535110216&disable_local_cache=0" -c copy "E:/PycharmProjects/Video_Crack/video/video1.mp4"'
    		cmd = shlex.split(shell_cmd)
    		p = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    		count = 0
    		while p.poll() is None:
    			line = p.stdout.readline().decode('gbk').strip()
    			print(line)
    			count += 1
    			if count == 50:
    				p.terminate()
    				# p.kill()
    		if p.returncode == 0:
    			print('subprocess success')
    		else:
    			print('subprocess failed with code', p.returncode)
    	except (OSError, ValueError, KeyboardInterrupt):
    		print('stop here')
    

    上面程序的意思是打印出50条语句时终止子进程,因为下载完成的话CMD中打印的语句肯定大于50条,也就是我们在它还没有下载完成时就把进程终止了:

    从图中可以看出,视频确实没有下载完成,因为下载完成之后视频会有15220KB,这样好像是已经满足我们的要求了,因为我们只要在按下“停止”按钮触发的函数里把子进程kill掉就好了。

    但是!!!这个视频是无法正常播放的。。。

    也即是说terminate() 和 kill()虽然可以终止视频下载,但也破坏了下载过程,使得下载好的部分无法播放。

    三、出现转机

    terminate() 和 kill()尝试失败后,现在我们只有下面两条命令可以用了:

    Popen.send_signal(signal)
    
    os.kill(Popen.pid, signal)

    希望全部寄托在了Windows可用的signal上,通过这篇文章python-subprocess模块用法了解到我们可用下面几种signal:

    # SIGTERM信号
    Popen.send_signal(signal.SIGTERM)
    os.kill(Popen.pid, signal.SIGTERM)
    
    # CTRL_C信号
    Popen.send_signal(signal.CTRL_C_EVENT)
    os.kill(Popen.pid, signal.CTRL_C_EVENT)
    
    # CTRL_BREAK信号
    Popen.send_signal(signal.CTRL_BREAK_EVENT)
    os.kill(Popen.pid, signal.CTRL_BREAK_EVENT)

    此外,需要注意的是,对于 os.kill(pidsig) ,在python文档中有如下描述:

    Windows:signal.CTRL_C_EVENT和signal.CTRL_BREAK_EVENT信号是特殊信号,只能发送到共享公共控制台窗口的控制台进程,例如某些子进程(subprocesses)。 sig的任何其他值都将导致进程被TerminateProcess API无条件地终止,并且退出代码将被设置为sig。 Windows版本的 kill() 还会占用进程句柄。

    原文:https://docs.python.org/3.6/library/os.html

    对于signal.CTRL_C_EVENT(signal.CTRL_BREAK_EVENT与此类似)python文档有如下描述:

    The signal corresponding to the Ctrl+C keystroke event. This signal can only be used with os.kill().

    Availability: Windows.

    New in version 3.2.

    原文:https://docs.python.org/3.6/library/signal.html#signal.CTRL_C_EVENT

    也就是说 signal.CTRL_C_EVENT 和 signal.CTRL_BREAK_EVENT 只能用于os.kill()。此外,由于在 Windows 上,SIGTERM和terminate() 的作用相同,所以我们弃用该方法。综上,只剩下了两种方法:

    # CTRL_C信号
    os.kill(Popen.pid, signal.CTRL_C_EVENT)
    
    # CTRL_BREAK信号
    os.kill(Popen.pid, signal.CTRL_BREAK_EVENT)

    看到CTRL+C,我们好像明白了什么,这不就是中断程序的命令吗!

    先在命令行试一下,下载过程中按下CTRL+C,程序终止,视频也下了一半,最重要的是,视频是可以正常播放的!

    这说明程序运行的过程中,我们只要给子进程发送一个Ctrl+C信号,就可以完美达到我们的目的,而Ctrl+C信号也正是我们有的:

    # CTRL_C信号
    os.kill(Popen.pid, signal.CTRL_C_EVENT)

    二话不说,立马在python程序中试一试:

    import os
    import shlex
    import signal
    import subprocess
    
    if __name__ == '__main__':
    	try:
    		shell_cmd = 'ffmpeg -i "https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone.m3u8?auth_key=1535110216-0-0-3d035cc32139ce884c8a1cbb14d0d04d&expiration=1535110216&disable_local_cache=0" -c copy "E:/PycharmProjects/Video_Crack/video/video1.mp4"'
    		cmd = shlex.split(shell_cmd)
    		p = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    		count = 0
    		while p.poll() is None:
    			line = p.stdout.readline().decode('gbk').strip()
    			print(line)
    			count += 1
    			if count == 50:
    				os.kill(p.pid, signal.CTRL_C_EVENT)
    		if p.returncode == 0:
    			print('subprocess success')
    		else:
    			print('subprocess failed with code', p.returncode)
    	except (OSError, ValueError, KeyboardInterrupt):
    		print('stop here')
    

    但是,可能是为了让我深刻认识到理论和实践的差距,果然程序又出了其它幺蛾子:视频并没有停止下载,而是下载完了之后才触发CTRL+C信号。。。

    请注意视频的大小是15220KB,也就是完整的下载了整个视频。

    当然,我也试了 CTRL_BREAK_EVENT 信号,结果也是下载完视频才触发信号:

    四、最终圣战

    到现在,所有想到的方法都试了一遍,但是没有一个既能中止视频下载,已经下载好的那部分又能正常播放的。当然,我们的努力还是有收获的,最接近我们最终目的的还是 CTRL_C_EVENT 信号,下面就继续拿他寻找解决办法。

    # CTRL_C信号
    os.kill(Popen.pid, signal.CTRL_C_EVENT)

    好吧,我就不卖关子了,最终我还是找到解决办法,很简单,只要这样就行了:

    os.kill(0, signal.CTRL_C_EVENT)

    详见:https://stackoverflow.com/questions/7085604/sending-c-to-python-subprocess-objects-on-windows

    上程序试一试:

    import os
    import shlex
    import signal
    import subprocess
    
    if __name__ == '__main__':
    	try:
    		shell_cmd = 'ffmpeg -i "https://vdn.vzuu.com/Act-ss-m3u8-hd/c5777f43b2ca4e588c3747d9c4ca2838/39068440-68b3-11e8-bb26-0242ac112a1eNone.m3u8?auth_key=1535110216-0-0-3d035cc32139ce884c8a1cbb14d0d04d&expiration=1535110216&disable_local_cache=0" -c copy "E:/PycharmProjects/Video_Crack/video/video1.mp4"'
    		cmd = shlex.split(shell_cmd)
    		p = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    		count = 0
    		while p.poll() is None:
    			line = p.stdout.readline().decode('gbk').strip()
    			print(line)
    			count += 1
    			if count == 50:
    				os.kill(0, signal.CTRL_C_EVENT)
    		if p.returncode == 0:
    			print('subprocess success')
    		else:
    			print('subprocess failed with code', p.returncode)
    	except (OSError, ValueError, KeyboardInterrupt):
    		print('stop here')
    

    能看到它能正常播放真是太舒服了,那这个终极方法的原理到底是什么呢?

    我们知道,os.kill() 有两个参数,即os.kill(pidsig),如果这两个参数中其中一个为0会是什么情况呢?

    (1)os.kill(pid, 0)

    若sig为0,则不发送任何信号,但仍执行错误检查;这可用于检查进程ID或进程组ID的存在。

    原文链接:https://unix.stackexchange.com/questions/169898/what-does-kill-0-do

    (2)os.kill(0, sig)

    例如:os.kill(0, signal.CTRL_C_EVENT) ,表示程序通过向cmd窗口中的所有进程发送CTRL_C_EVENT来获取CTRL-C信号。

    看一个例子(来源:https://www.programcreek.com/python/example/13966/signal.CTRL_C_EVENT):

    def pipe_server():
      ''' Part of attach/set_attach for Windows '''
      while 1:
        pipe = Pipe('vdb_%d' % os.getpid(), server=True)
        knock = pipe.read(3)
        if knock == 'vsi':
          os.kill(0, signal.CTRL_C_EVENT)      
          #ctypes.windll.kernel32.GenerateConsoleCtrlEvent(0, os.getpid())
        pipe.disconnect()
        pipe.close() 

     

    更新(2018/08/28):

    有一个小bug,使用os.kill(0, signal.CTRL_C_EVENT)之后,CTRL_C_EVENT信号发送给了当前子进程及其所有相关的父进程,所以我的图形界面也被关闭了!解决方法如下。原理就是接收到CTRL_C_EVENT信号之后会引发KeyboardInterrupt异常,我们捕捉这个异常,并在异常发生之后(此时GUI被关闭了)再次触发GUI,这个过程是很快的,所以我们不会发现GUI关闭过!

    class GUIOperate(object):
    	# 运行GUI
    	@staticmethod
    	def gui_loop():
    		try:
    			top.mainloop()
    		except KeyboardInterrupt:
    			print('下载中止...')
    			GUIOperate.gui_loop()

     

    参考:

    python-subprocess模块用法

    Python错误:AttributeError: module 'signal' has no attribute 'SIGALRM'

    https://docs.python.org/3.6/library/os.html

    https://docs.python.org/3.6/library/signal.html#signal.CTRL_C_EVENT

    Sending ^C to Python subprocess objects on Windows

    GenerateConsoleCtrlEvent function

    展开全文
  • 目录 进程间的信号 信号量(信号灯) 进程的同步互斥 ...$ kill -9 pid号对进程发送信号 信号名称 说明 1) SIGHUP 连接断开 2) SIGINT ctrl+c 3) SIGQUIT ctr...

    目录

    进程间的信号

    信号量(信号灯)

    进程的同步互斥

    Event事件

    Lock 锁


    进程间的信号

    信号是唯一的异步通信方法

    一个进程向另一个进程发送一个信号来传递某种信息,接受者根据传递的信息来做相应的事

    $ kill -l查看系统信号说明

    $ kill -9 pid号对进程发送信号

    信号名称 说明    
    1) SIGHUP 连接断开    
    2) SIGINT ctrl+c    
    3) SIGQUIT ctrl+\    
    20) SIGTSTP ctrl+z    
    9) SIGKILL 终止进程    
    19) SIGSTOP 暂停进程    
    26) SIGVTALRM 时钟信号    
    17) SIGCHLD 子进程退出时给父进程发的信号    
           

    在Python中import signal可以获取信号

    os.kill(pid, sig)

    功能:发送信号

    参数

    pid:要发送信号的PID号

    sig :信号名称

    import os
    import signal
    os.kill(12345,signal.SIGKILL) #杀死进程

    signal.alarm(time)

    个人理解:把发送信号的信息告知系统内核,应用层程序继续运行,时间到之后利用内核告知应用层程序进行处理

    功能:非阻塞函数,向自身进程发送一个时钟信号

    参数:time->整型时间秒

      import signal
      import time
      signal.alarm(3)#3秒后向自身发送一个时钟信号
      while True:
          time.sleep(1)
          print("等待时钟信号")
          
      '''打印结果
      等待时钟信号
      等待时钟信号
      闹钟
      '''        
      signal.alarm(3)#3秒后向自身发送一个时钟信号
      time.sleep(2)
      signal.alarm(5)#进程只有一个时钟信号,第二个会覆盖上面的时钟信号
      while True:
          time.sleep(1)
          print("等待时钟信号")
          
      '''打印结果
      等待时钟信号
      等待时钟信号
      等待时钟信号
      等待时钟信号
      闹钟
      '''

    signal.pause()

    功能:阻塞进程,然后等待信号

    signal.signal(signum, handler)

    功能:处理信号

    参数

    signum:要处理的信号

    handler:信号的处理方法

    SIG_DFL表示使用默认方法处理

    SIG_IGN表示忽略这个信号

    function表示传入一个函数,用指定的函数处理

    def function(sig, frame)

    sig:捕获到的信号

    frame:信号对象

    import signal
      from time import sleep
      
      signal.alarm(5)  # 5秒后向自身发送一个时钟信号
      # 使用信号的默认方法处理
      # signal.signal(signal.SIGALRM,signal.SIG_DFL)    
      # 忽略时钟信号
      # signal.signal(signal.SIGALRM,signal.SIG_IGN)
      # 忽略Ctrl+c信号
      # signal.signal(signal.SIGINT,signal.SIG_IGN)
      while True:
          sleep(2)
          print("等待时钟...")
      # 使用自定义函数处理信号
      import signal
      from time import sleep
      
      def fun1(sig, frame):
          if sig == signal.SIGALRM :
              print("接收到时钟信号")
          elif sig == signal.SIGINT :
              print("ctrl+c就不结束")
      
      signal.alarm(5)  # 5秒后向自身发送一个时钟信号
      # 使用自定义函数处理信号
      # 处理时钟信号
      signal.signal(signal.SIGALRM,fun1)    
      # 处理ctrl+c信号
      signal.signal(signal.SIGINT,fun1)
      
      while True:
          print("等待")
          sleep(2)
          
      '''打印结果
      等待
      等待
      等待
      接收到时钟信号
      等待
      ...
      '''   

    信号量(信号灯)

    原理:给定一个数量对多个进程可见,且多个进程都可以操作,进程可以对数量多少的判断执行各自的行为

    from multiprocessing import Semaphore
    
    sem = Semaphore(num)

    功能:创建信号量

    参数:信号量的初始值

    返回值:信号量的对象

    sem.get_value():获取信号量的值

    sem.acquire():将信号量 -1,当信号为0时会阻塞

    sem.release():将信号量 +1

    from multiprocessing import Semaphore, Process
    # 创建信号量对象
    sem = Semaphore(num)
    def fun():
        print("进程%d等待信号量"%os.getpid())
        # 消耗一个信号量
        sem.acquire()
        print("进程%d消耗信号量"%os.getpid())
        # 添加一个信号量
        sem.release()
        print("进程%d添加信号量"%os.getpid())
    
    jobs = []
    for i in range(4):
        p = Process(target = 4)
        jobs.append(p)
        p.start()
    for i in jobs:
        i.join()
    print(sem.get_value())

    进程的同步互斥

    临界资源:多个进程或者线程都能操作的共享资源

    临界区:操作临界区资源的代码段

    同步:同步是一种合作关系,为完成某个任务,多进程或者多线程之间形成的一种协调关系

    互斥:互斥是一种制约关系,

    Event事件

    from multiprocessing import Event

    e = Event():创建一个事件对象

    e.wait([timeout]):设置事件阻塞

    e.set():事件设置,当事件被设置后e.wait()不再阻塞,等于释放资源区

    e.clear():清除设置,当事件被设置e.clear()后,e.wait()又会阻塞,阻塞资源区

    e.is_set():事件状态判断,判断事件是否处于被设置的状态

    from multiprocessing import Event
    # 创建事件对象
    e = Event()
    # 查看
    print(e.is_set())        # False
    e.set()
    print(e.is_set())        # True
    e.wait(3)
    print(e.is_set())        # True
    e.clear()
    print(e.is_set())        # False
    from multiprocessing import Event,Process
    from time import sleep
    
    def wait_event1():
        print("1想操作临界区资源")
        e.wait()
        print("1开始操作临界区资源",e.is_set())
        with open("file") as f:
            print(f.read())
    def wait_event2():
        print("2也想操作临界区资源")
        # 超时3秒检测
        e.wait(3)
        # 判断是否被设置
        if e.is_set():
            print("2开始操作临界区资源",e.is_set())
            with open("file") as f:
                print(f.read())
        else:
            print("2不能操作")       
    
    # 创建事件对象
    e = Event()
    p1 = Process(target = wait_event1)
    p2 = Process(target = wait_event2)
    p1.start()
    p2.start()
    print("主进程操作")
    with open("file",'w') as f:
        f.write("HELLO WORD")
    
    # 延迟4秒释放临界区
    sleep(4)
    # 释放临界区资源
    e.set()
    print("释放临界区")
    p1.join()
    p2.join()

    Lock 锁

    from multiprocessing import Lock

    lock = Lock():创建一个锁对象

    lock.acquire():上锁,如果已经是上锁状态,调用此函数会阻塞

    lock.release():解锁

    from multiprocessing import Lock,Process
    import sys
    def writer1():
        # 上锁
        lock.acquire()
        for i in range(20):
            sys.stdout.write("writer1111\n")
        # 解锁
        lock.release() 
    def writer2():
        # 上锁
        lock.acquire()
        for i in range(20):
            sys.stdout.write("writer2222\n")
        # 解锁
        lock.release()
    lock = Lock()
    
    w1 = Process(target = writer1)
    w2 = Process(target = writer2)
    
    w1.start()
    w2.start()
    w1.join()
    w2.join()

    第二种方法

    使用with语句上锁,with语句执行完毕后会自动解

    with lock:
        .....
        .....
        
    
     
    
    展开全文
  • python信号Signal

    2020-05-07 19:00:26
    信号signal 是python进程间进行信号发送的一种机制,其原理是操作系统对进程的控制,是一种程序中断一个进程一旦接收到信号就会打断原来的程序执行流程来处理信号。那么singanl到底有什么用呢?siganl的应用:1. 故障...

    信号signal 是python进程间进行信号发送的一种机制,其原理是操作系统对进程的控制,是一种程序中断


    一个进程一旦接收到信号就会打断原来的程序执行流程来处理信号。


    那么singanl到底有什么用呢?


    siganl的应用:


    1. 故障定位技术(进程的底层故障,例如进程突然中断和一些可能性较小的故障)


    2. 对进程的流程控制 


    首先说说与信号signal有关的几个函数


    (1)os.kill(pid,sig)


    发送一个信号给某个进程


    参数解析:


    pid 指定发送信号的进程号


    sig  要发送的信号代号(需要通过signal模块获取)



    (2)signal.alarm(sec)  非阻塞函数


    设置时钟信号,在一定时间后给自身发送一个SIGALRM信号


    原理: 时钟的创建是进程交由操作系统内核(kernal)帮助创建的


    时钟和进程之间是异步执行的,当时钟到时,内核会发送信号给进程,进程接收信号进行相应的响应操作.这就是所谓的python异步处理方案.


    后面的时钟会覆盖前面的时钟,一个进程只有一个挂起的时钟


    名词的理解:


    异步: 程序在执行中利用内核功能帮助完成必要的辅助操作,不影响应用层持续执行



    注意: 这里的同步和异步机制是相对多进程而言的.(注意与多线程的异步执行相区分,之后我会写写多线程的异步机制的相关文章)



    在进程中通信这个概念下,只有singal是异步执行的,另外python进程间通信的机制还有pipe(管道),queue(队列),value(共享空间)等等


    有机会会将这几种机制进行一个对比


    (3)signal.pause()


    阻塞进程,等待一个信号.当接收到信号时就会停止阻塞


    例如:等待signal()函数的发送


    (4)signal.signal(sig,handler)


    当进程运行过程中出现故障异常或者需要进程间通信时,操作系统内核/进程发出处理信号


    参数理解:


    sig 要处理的信号名称


    handler 信号处理方法   可选值: SIG_DFL   表示默认方法处理

    SIG_IGN    表示忽略这个信号(一般为了避免父进程和子进程的互相干扰而使用)

    func       自定义函数(实际上是回调函数的一类,信号发生时,调用处理函数,完成之后,回到原来的位置继续执行下面的程序)


    自定义函数格式: (跟定义python普通函数的定义没有区别)


    def  func(sig,frame):


     sig : 接收到的信号


     frame: 信号结构对象(可以通过结构对象查看信号信息,基本不用)


    signal函数实际上是一个异步处理函数,只要执行了该函数,则进程任意时候接收到相应信号都会处理


     这里的异步就是上文提到的异步机制,是计算机内核程序与本进程间同时运行,互相不干扰的一种机制,对于进程的正常执行有着关键的作用。


    这种异步机制在任何后端编程语言中都是存在的,只不过实现的方式和细节不一样而已。


    那么singnal怎么用呢?


    一般信号signal是在需要检测异常的程序的开头就定义好了,程序顺序向下运行时,一旦捕获到操作系统发出的signal或者其他进程发出的signal


    马上就会停止当前的程序运行状态,去处理捕获到的signal。


    展开全文
  • 在 Java 中打印当前线程的方法栈,可以用 kill -3 命令向 JVM 发送一个 OS 信号,JVM 捕捉以后会自动 dump 出来;当然,也可以直接使用 jstack 工具完成,这些方法好几年前我在这篇性能分析的文章 中介绍过。这样的...
  • Python进程、线程

    2016-09-18 17:21:00
    Event : 是最简单的线程间通信的方式,一个线程可以发送信号,其他的线程接收到信号后执行操作。 我们知道,在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码段、堆栈...
  • 内核也可以因为内部事件而给进程发送信号,通知进程发生了某个事件。注意,信号只是用来通知某进程发生了什么事件,并不给该进程传递任何数据。 信号种类 Linux中的信号种类(从图中可以看到没有32、33这俩个信号...
  • 进程补充进程间的信号信号量(信号灯)进程的同步互斥Event事件Lock 锁 进程补充 进程间的信号 信号是唯一的异步通信方法 ...$ kill -9 pid号对进程发送信号 信号名称说明 1) SIGHUP 连接断开 ...
  • Python处理Unix信号

    2019-03-25 14:16:00
    简而言之,信号是软件中断,它被发送到程序(或进程),将重要事件或请求通知程序,以便运行特殊的代码序列。接收到信号的程序要么停止或继续执行其指令,要么在有或没有内存转储的情况下终止,甚至干脆忽略该信号。 ...
  • 在 Java 中打印当前线程的方法栈,可以用 kill -3 命令向 JVM 发送一个 OS 信号,JVM 捕捉以后会自动 dump 出来;当然,也可以直接使用 jstack 工具完成,这些方法好几年前我在这篇性能分析的文章 中介绍过。这样的...
  • 如何利用python dbus来发送一个信号

    千次阅读 2017-10-16 11:50:48
    ...dbus用于进程间通信,可以降低不同程序间的耦合性,dbus的原理同分布式计算很象,其中一个介绍原理的...用python来操作dbus很方便,python-dbus的教程: 教程    一些官方例子: 例子 简单过程
  • Python Signal 信号

    2015-04-02 22:38:01
    1、基本概念 信号机制是进程之间相互传递消息...内核也可以因为内部事件而给进程发送信号,通知进程发生了某个事件。注意,信号只是用来通知某进程发生了什么事件,并不给该进程传递任何数据。 收 到信号的进程对各种
  • python信号量机制

    千次阅读 2019-07-15 19:11:09
    信号通信 ...kill -sig PID 向一个进程发送信号 信号介绍: 信号名称 信号含义 默认处理方法 SIGHUP 连接断开 SIGINT CTRL-C SIGQUIT CTRL-\ SIGTSTP CTRL-Z SIGKILL 终止一个进程 ...
  • python signal信号

    2016-03-31 00:26:00
    信号可以由系统本身生成,也可以从一个进程发送到另一个进程。 由于信号会中断程序的正常控制流,如果在中间接收到信号,有些操作(特别是I/O操作)可能会发生错误。 接收信号:  signal.signal(sig,action) ...
  • 除此之外,我们在进程间通信时会用到信号,向某一个进程发送信号,该进程中设置信号处理函数,然后当该进程收到信号时,执行某些操作。 其实在线程中,也可以接受信号,利用这种机制,我们也可以用来实现线程同步。...
  • 经实测分享两种方法: 1,采用信号量的方式,signal。通过partial函数给signal传入参数 ...即可停止该进程,并发送信号停止其他进程。 主函数: import multiprocessing as mp from multiprocessing import ...
  • python信号处理

    2019-10-09 03:42:12
    有两个信号python中是无法处理和更改的:SIGTOP和SIGKILL,之前想到用supervisord管理tomcat进程,我们向代理程序发送这个信号并拦截的思路不能实现。 会提示以下错误: hartnettmatoMacBook-Pro:python ...
  • 先说说线程在多线程中,...除此之外,我们在进程间通信时会用到信号,向某一个进程发送信号,该进程中设置信号处理函数,然后当该进程收到信号时,执行某些操作。其实在线程中,也可以接受信号,利用这种机制,我们...
  • Python信号处理

    千次阅读 2017-04-30 19:35:00
    SIGKILL信号是无法在程序内部捕获的,一旦发送SIGKILL信号进程,Linux就将进程停止在那里。Python自己并不检查SIGKILL,而是直接把底层标准C的运行时错误返回。
  • 进程之间可以调用系统来传递信号, 本身内核也可以发送信号进程, 告诉该进程发生了某个事件. 在应用层将消息传递给内核监控,当消息处理完毕后,内核将消息反馈给应用层;这样操作不会出现阻塞等待,保持信号处理...
  • python Linux 信号编程 signals

    千次阅读 2015-04-24 11:37:47
    内核也可以因为内部事件而给进程发送信号,通知进程发生了某个事件。注意,信号只是用来通知某进程发生了什么事件,并不给该进程传递任何数据。信号是进程控制的一部分,也是 Linux编程中非常重要的部分。   ...
  • python 信号--Signal

    2018-10-27 10:58:40
    信号signal 是python进程间进行信号发送的一种机制,其原理是操作系统对进程的控制,是一种程序中断 一个进程一旦接收到信号就会打断原来的程序执行流程来处理信号。   那么singanl到底有什么用呢? siganl的...
  • python 信号通信

    2019-09-29 17:17:12
    当售票员捕捉到 SIGINT信号时 给司机发送 SIGUSR1信号,此时司机打印 “老司机开车了” 当售票员捕捉到 SIGQUIT时 给司机发送 SIGUSR2信号,此时司机打印“系好安全带,车速有点快” 当司机捕捉到 SIGTSTP时,发送...
  • 信号: 一个进程向另一个进程通过信号传递某种信息 kill -l 查看信号 kill -signame PID 给PID的进程发送一个信号 关于信号: 信号的名称:系统定义,信号的名字 信号的含义:系统定义,信号的作用 信号的...

空空如也

空空如也

1 2 3 4 5
收藏数 96
精华内容 38
关键字:

python进程发送信号

python 订阅