最近在項目中遇到一個需求，前端發來一個命令，這個命令是去執行傳遞過來的一個腳本（shell 或者python），并返回腳本的標準輸出和標準出錯，如果執行超過設定時間還沒結束就超時，然后終止腳本的執行。實現這個功能，自然而然先想到的是subprocess這個庫了。

因此，在后端的一個腳本中調用python的subprocess去執行傳遞過來的腳本，通常情況下subprocess都能運行的很好，完成腳本的執行并返回。最初的實現代碼如下：
run_cmd.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
import subprocess
from threading import Timer
import os

class test(object):
    def __init__(self):
        self.stdout = []
        self.stderr = []
        self.timeout = 10
        self.is_timeout = False
        pass

    def timeout_callback(self, p):
        print 'exe time out call back'
        print p.pid
        try:
            p.kill()
        except Exception as error:
            print error

    def run(self):
        cmd = ['bash', '/home/XXXX/test.sh']
        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        my_timer = Timer(self.timeout, self.timeout_callback, [p])
        my_timer.start()
        try:
            print "start to count timeout; timeout set to be %d \n" % (self.timeout,)
            stdout, stderr = p.communicate()
            exit_code = p.returncode
            print exit_code
            print type(stdout), type(stderr)
            print stdout
            print stderr
        finally:
            my_timer.cancel()

但是偶然間測試一個shell腳本，這個shell腳本中有一行ping www.baidu.com &，shell腳本如下：
test.sh

#!/bin/bash
ping   www.baidu.com (&) #加不加&都沒區別
echo $$

python（父進程）用subprocess.Popen新建一個進程（子進程）去開啟一個shell， shell新開一個子進程（孫進程）去執行ping www.baidu.com的命令。由于孫進程ping www.baidu.com一直在執行,就類似于一個daemon程序，一直在運行。在超時時間后，父進程殺掉了shell子進程，但是父進程阻塞在了p.communicate函數了，是阻塞在了調用wait()函數之前，感興趣的朋友可以看一下源碼_communicate函數，linux系統重點看_communicate_with_poll和_communicate_with_select函數，你會發現是阻塞在了while循環里面，因為父進程一直在獲取輸出，而孫進程一直像一個daemon程序一樣，一直在往子進程的輸出寫東西，而子進程的文件句柄繼承自父進程。雖然shell子進程被殺掉了，但是父進程里面的邏輯并沒有因為子進程被意外的干掉而終止，（因為孫進程一直有輸出到子進程的stdout，導致子進程的stdout一直有輸出，也就是父進程的stdout也有輸出），所以while循環一直成立，就導致了阻塞，進而導致wait()沒有被調用，所以子進程沒有被回收，就成了僵尸進程。

要完美的解決這個問題就是即要能獲取到subprocess.Popen的進程的輸出，在超時又要能殺掉子進程，讓主進程不被阻塞。

一開始比較急，也對subprocess.Popen沒有深入的去用過，嘗試了一個low B的辦法，就是不用subprocess.Popen.communicate()去獲取輸出，而是直接去讀文件，然后超時后不去讀文件。代碼如下：
run_cmd.py第一個改版

#!/usr/bin/python
# -*- coding: utf-8 -*-
import subprocess
from threading import Timer
import os

class test(object):
    def __init__(self):
        self.stdout = []
        self.stderr = []
        self.timeout = 10
        self.is_timeout = False
        pass

    def timeout_callback(self, p):
        self.is_timeout = True
        print "time out"

    def run(self):
        cmd = ['bash', '/home/zhangxin/work/baofabu/while_test.sh']
        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        my_timer = Timer(self.timeout, self.timeout_callback, [p])
        my_timer.start()
        try:
            print "start to count timeout; timeout set to be %d \n" % (self.timeout,)
            for line in iter(p.stdout.readline, b''):
                print line
                if self.is_timeout:
                    break
            for line in iter(p.stderr.readline, b''):
                print line
                if self.is_timeout:
                    break
        finally:
            my_timer.cancel()
            p.stdout.close()
            p.stderr.close()
            p.kill()
            p.wait()

這樣雖然能獲取輸出，在超時后也不再阻塞，寫完過后返回來再看時發現，其實在最開始的那一版代碼中，只要在超時的回調函數中加上p.stdout.close()和p.stderr.clode(), p.communicate就不再阻塞了，其實問題也就解決了。 但是還會存在一個潛在的問題，父進程結束了，沒有其他進程去讀取PIPE，daemon孫進程一直往PIPE寫，最后導致PIPE填滿，孫進程也被阻塞。

所以這樣處理其實沒任何意義，因為孫進程沒有被終止掉，只是簡單的關閉了管道。 所以在假期，我仔細的在網上找了找，看了看subprocess，發現subprocess.Popen有一個參數preexec_fn，調用subprocess.Popen時傳遞preexec_fn=os.setsid或者preexec_fn=os.setpgrp，然后在超時的時候執行os.killpg(p.pid, signal.SIGKILL)就可以殺掉子進程以及在同一個會話的所有進程。所以將run函數的subprocess.Popen改為

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=os.setsid)

同時將timeout_callback函數改成如下就可以了：
def timeout_callback(self, p):
    self.is_timeout = True
    print 'exe time out call back'
    print p.pid
    try:
        os.killpg(p.pid, signal.SIGKILL)
    except Exception as error:
        print error

關于preexec_fn=os.setsid的作用，以下摘自https://blog.tonyseek.com/post/kill-the-descendants-of-subprocess/

運行程序 fork 以后，產生的子進程都享有獨立的進程空間和 pid，也就是它超出了我們觸碰的范圍。好在 subprocess.Popen 有個 preexec_fn 參數，它接受一個回調函數，并在 fork 之后 exec 之前的間隙中執行它。我們可以利用這個特性對被運行的子進程做出一些修改，比如執行 setsid() 成立一個獨立的進程組。

Linux 的進程組是一個進程的集合，任何進程用系統調用 setsid 可以創建一個新的進程組，并讓自己成為首領進程。首領進程的子子孫孫只要沒有再調用 setsid 成立自己的獨立進程組，那么它都將成為這個進程組的成員。 之后進程組內只要還有一個存活的進程，那么這個進程組就還是存在的，即使首領進程已經死亡也不例外。 而這個存在的意義在于，我們只要知道了首領進程的 pid (同時也是進程組的 pgid)， 那么可以給整個進程組發送 signal，組內的所有進程都會收到。

因此利用這個特性，就可以通過 preexec_fn 參數讓 Popen 成立自己的進程組， 然后再向進程組發送 SIGTERM 或 SIGKILL，中止 subprocess.Popen 所啟動進程的子子孫孫。當然，前提是這些子子孫孫中沒有進程再調用 setsid 分裂自立門戶。

至于setsid和setpgrp有什么區別，看了各自的man page，還不是很明白，如果有大兄弟知道，并且不吝留言分享告知，感激涕零！

subprocess.Popen只能運行命令或者腳本，而不能像threading的thread庫一樣運行函數，那么如何在一個只有.py文件的情況下像thread一樣運行subprocess.Popen呢？ 在調用subprocess.Popen的py我們可以把要執行的腳本內容寫到一個臨時文件，也即是類似于thread的target函數，然后用subprocess.Popen執行這個臨時腳本，這樣就可以不用預先存在多個腳本。。如下面的例子：

import os
import signal
import subprocess
import tempfile
import time
import sys


def show_setting_prgrp():
    print('Calling os.setpgrp() from {}'.format(os.getpid()))
    os.setpgrp()
    print('Process group is now {}'.format(
        os.getpid(), os.getpgrp()))
    sys.stdout.flush()

# 這次的重點關注是這里
script = '''#!/bin/sh
echo "Shell script in process $$"
set -x
python3 signal_child.py
'''
script_file = tempfile.NamedTemporaryFile('wt')
script_file.write(script)
script_file.flush()

proc = subprocess.Popen(
    ['sh', script_file.name],
    preexec_fn=show_setting_prgrp,
)
print('PARENT      : Pausing before signaling {}...'.format(
    proc.pid))
sys.stdout.flush()
time.sleep(1)
print('PARENT      : Signaling process group {}'.format(
    proc.pid))
sys.stdout.flush()
os.killpg(proc.pid, signal.SIGUSR1)
time.sleep(3)

當然也可以在shell腳本里面用exec來運行命令，那么就只有父進程和子進程，沒有孫進程的概念了。

其實關于阻塞問題，也可以將subprocess.Popen的輸出重定向到文件。

#!/usr/bin/python
# -*- coding: utf-8 -*-
import subprocess
from threading import Timer
import os
import time
import signal

class test(object):
    def __init__(self):
        self.stdout = []
        self.stderr = []
        self.timeout = 6
        self.is_timeout = False
        pass

    def timeout_callback(self, p):
        print 'exe time out call back'
        try:
            p.kill()
            # os.killpg(p.pid, signal.SIGKILL)
        except Exception as error:
            print error

    def run(self):
        stdout = open('/tmp/subprocess_stdout', 'wb')
        stderr = open('/tmp/subprocess_stderr', 'wb')
        cmd = ['bash', '/home/xxx/while_test.sh']
        p = subprocess.Popen(cmd, stdout=stdout.fileno(), stderr=stderr.fileno())
        my_timer = Timer(self.timeout, self.timeout_callback, [p])
        my_timer.start()
        print p.pid
        try:
            print "start to count timeout; timeout set to be %d \n" % (self.timeout,)
            p.wait()
        finally:
            my_timer.cancel()
            stdout.flush()
            stderr.flush()
            stdout.close()
            stderr.close()

寫在最后，關于p = subprocess.Popen，最好用p.communicate.而不是直接用p.wait()， 因為p.wait()有可能因為子進程往PIPE寫的時候寫滿了，但是子進程還沒有結束，導致子進程阻塞，而父進程一直在wait()，導致父進程阻塞。而且p.wait()和p.communicate不能一起用，因為p.communicate里面也會去調用wait()。
在linux平臺下，p.wait()其實最后調用的是os.waitpid()， 我們自己用的時候，也盡量用waitpid,而不是wait(),因為多次調用waitpid去wait同一個進程不會導致阻塞，但是程序中多次調用wait就很有可能會被阻塞，詳見wait函數的作用。

其實阻塞的根本原因還是因為PIPE滿了，所以用PIPE的時候，最好和select或者poll模型一起使用，防止讀、寫阻塞。 PIPE管道是系統調用，os.pipe產生的一個文件，只不過他有兩個fd，一個用于讀，一個用于寫，當讀寫端都被關閉后，內核會自動回收。你可以理解內核在內存中開辟了一個隊列，一端讀，一端寫。

管道在進程間通信(IPC)使用很廣泛，shell命令就使用的很廣泛。比如：
ps –aux | grep mysqld
上述命令表示獲取mysqld進程相關的信息。這里ps和grep兩個命令通信就采用了管道。管道有幾個特點：

1.  管道是半雙工的，數據只能單向流動，ps命令的輸出是grep的輸出
   

2.  只能用于父子進程或兄弟進程通信，這里可以認為ps和grep命令都是shell（bash/pdksh/ash/dash）命令的子進程，兩者是兄弟關系。
   

3.  管道相對于管道兩端的進程而言就是一個文件，并且只存在于內存中。
   

4.  寫入端不斷往管道寫，并且每次寫到管道末尾；讀取端則不斷從管道讀，每次從頭部讀取。
   

   到這里大家可能會有一個疑問，管道兩端的進程，寫入進程不斷的寫，讀取進程不斷的讀，那么什么時候結束呢？比如我們剛剛這個命令很快就結束了，它的原理是怎么樣的呢？對于管道，這里有兩個基本原則：
   1.當讀一個寫端已經關閉的管道時，在所有數據被讀取后，read返回0，以指示達到文件結束處。
   2.當寫一個讀端已經關閉的管道時，會產生sigpipe信息。
   結合這個例子，當ps寫管道結束后，就會自動關閉，此時grep進程read就會返回0，然后自動結束。
   具體pipe可以參見http://man7.org/linux/man-pages/man7/pipe.7.html

最近有發現了一個有趣的shell命令timeout，結合python 2.7的subprocess.Popen（python3的subprocess.Popen自帶timeout參數），可以做到超時后終止進程。

cmd = ['timeout', 'bash', 'xxxxx']
subprocess.Popen(cmd)

參考來源：
https://pymotw.com/3/subprocess/#process-groups-sessions
http://www.cnblogs.com/cchust/p/3899832.html