Python3 與 C# 併發編程之～進程先導篇
在線預覽：http://github.lesschina.com/python/base/concurrency/1.併發編程～進程先導篇.htmlhtml
Python3 與 C# 併發編程之～ 進程篇：http://www.javashuo.com/article/p-hufkkonm-d.htmlpython
Linux專項¶
先寫幾個問號來概況下今天準備說的內容：（謎底本身解開，文中都有）linux
- 你知道
Ctrl+C終止進程的本質嗎？你知道Kill -9 pid的真正含義嗎？ - 你知道那些跨平臺框架（Python，NetCore）在Linux下建立進程幹了啥？
- 你瞭解
殭屍進程和孤兒進程的悲催生產史嗎？孤兒找乾爹，殭屍送往生想知道不？ - 想知道建立子進程後怎麼
李代桃僵嗎？ps aux | grep xxx的背後到底隱藏了什麼？ - 你瞭解Linux磁盤中p類型的文件究竟是個啥嗎？
- 爲何要realase發佈而不用debug直接部署?這背後的性能相差幾何？
- 還有更多進程間的
密密私語等着你來查看哦～
關於幫助文檔的說明：git
- 全部用到的系統函數你均可以使用
man查看，eg：man 2 pipe - Python裏面的方法你均可以經過
help查看，eg：help(os.pipe)
1.概念引入¶
正式講課以前，先說些基本概念，難理解的用程序跑跑而後再理解：若有錯誤歡迎批評指正程序員
併發 :一個時間段中有幾個程序都處於已啓動運行到運行完畢之間，且這幾個程序都是在同一個處理機上運行，但任一個時刻點上只有一個程序在處理機上運行。github
並行 :當一個CPU執行一個線程時，另外一個CPU能夠執行另外一個線程，兩個線程互不搶佔CPU資源，能夠同時進行，這種方式咱們稱之爲並行(Parallel)。（在同一個時間段內，兩個或多個程序執行，有時間上的重疊）算法
通俗的舉個例子：mongodb
小明、小潘、小張、小康去食堂打飯，4個小夥子Coding了3天，餓爆了，如今須要1分鐘內讓他們都吃上飯，否則就有可怕的事情發生。編程
按照正常的流程，1分鐘可能只夠他們一我的打飯，這不行啊，因而有了幾種處理方法：json
併發：快快快，一人先吃一口，輪着來，一直喂到大家都飽了(只有一個食堂打飯的窗口)（單核CPU）
並行：
- 開了2~3個窗口，和上面處理同樣，只是競爭的強度沒那麼大了
- 開了4個窗口，不着急，一人一個窗口妥妥的
對於操做系統來講，一個任務就是一個進程（Process），好比打開一個瀏覽器就是啓動一個瀏覽器進程，打開兩個瀏覽器就啓動了兩個瀏覽器進程。
有些進程還不止同時幹一件事，好比Word，它能夠同時進行打字、拼寫檢查、打印等事情。在一個進程內部，要同時幹多件事，就須要同時運行多個「子任務」，咱們把進程內的這些「子任務」稱爲線程（Thread）。
因爲每一個進程至少要幹一件事，因此，一個進程至少有一個線程。像Word這種複雜的進程能夠有多個線程，多個線程能夠同時執行，多線程的執行方式和多進程是同樣的，也是由操做系統在多個線程之間快速切換，讓每一個線程都短暫地交替運行，看起來就像同時執行同樣。
通俗講：線程是最小的執行單元，而進程由至少一個線程組成。如何調度進程和線程，徹底由操做系統決定，程序本身不能決定何時執行，執行多長時間
PS：進程5態下次正式講程序的時候會說，而後就是==> 程序實戰不會像今天這樣繁瑣的，Code很簡單，可是不懂這些基本概念日後會吃不少虧，逆天遇到太多坑了，因此避免你們入坑，簡單說說這些概念和一些偏底層的東西～看不懂沒事，有個印象便可，之後遇到問題至少知道從哪一個方向去解決
2.進程相關¶
示例代碼：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux
2.1.fork引入¶
示例代碼：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/base
(linux/unix)操做系統提供了一個fork()系統調用。普通的函數調用，調用一次，返回一次，可是fork()一次調用，兩次返回。
由於操做系統自動把父進程複製了一份，分別在父進程和子進程內返回。爲了便於區分，操做系統是這樣作的：子進程永遠返回0，而父進程返回子進程的ID
查看下幫助文檔：
import os
help(os.fork)
Help on built-in function fork in module posix:
fork()
Fork a child process.
Return 0 to child process and PID of child to parent process.
咱們來跑個程序驗證一下：（PID返回值若是小於0通常都是出錯了）
import os
def main():
print("準備測試～PID：%d" % os.getpid())
pid = os.fork()
if pid == 0:
print("子進程：PID：%d,PPID：%d" % (os.getpid(), os.getppid()))
elif pid > 0:
print("父進程：PID：%d,PPID：%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
結果：
準備測試～PID：11247 父進程：PID：11247,PPID：11229 子進程：PID：11248,PPID：11247
能夠查看下這個進程是啥： 
這個指令若是還不熟悉，Linux基礎得好好複習下了：http://www.javashuo.com/article/p-zvrxpwdj-bx.html，簡單分析下吧：a是查看全部（能夠聯想ls -a），u是顯示詳細信息，x是把不依賴終端的進程也顯示出來（終端能夠理解爲：人與機器交互的那些）
技巧：指令學習能夠遞增式學習：ps，ps a ps au ps aux ps ajx
如今驗證一下複製一份是什麼意思：（代碼原封不動，只是在最下面添加了一行輸出）
import os
def main():
print("準備測試～PID：%d" % os.getpid())
pid = os.fork() # 子進程被父進程fork出來後，在fork處往下執行
if pid == 0:
print("子進程：PID：%d,PPID：%d" % (os.getpid(), os.getppid()))
elif pid > 0:
print("父進程：PID：%d,PPID：%d" % (os.getpid(), os.getppid()))
print("PID:%d,我是賣報的小行家，大風大雨都不怕" % os.getpid())
if __name__ == '__main__':
main()
輸出：（父子進程的執行順序是系統調度決定的）
準備測試～PID：13081 父進程：PID：13081,PPID：9388 PID:13081,我是賣報的小行家，大風大雨都不怕 子進程：PID：13083,PPID：13081 PID:13083,我是賣報的小行家，大風大雨都不怕
的確是Copy了一份，Code都同樣（玩過逆向的應該知道，這份Code其實就放在了.text（代碼段）裏面）
子進程被父進程fork出來後，在fork處往下執行（Code和父進程同樣），這時候他們就爲了搶CPU各自爲戰了
最後驗證一下：各個進程地址空間中數據是徹底獨立的（有血緣關係的則是：讀時共享，寫時複製，好比父子進程等）
import os
def main():
num = 100
pid = os.fork()
# 子進程
if pid == 0:
num += 10
elif pid > 0:
num += 20
print("PID:%d，PPID：%d，Num=%d" % (os.getpid(), os.getppid(), num))
if __name__ == '__main__':
main()
輸出：（進程間通訊下一節課會系統的講，今天只談Linux和概念）
PID:6369，PPID：6332，Num=120 PID:6376，PPID：6369，Num=110
擴展：（簡單瞭解下便可）
- 程序：二進制文件（佔用磁盤）
- 進程：啓動的程序（全部數據都在內存中，須要佔用CPU、內存等資源）
- 進程是CPU、內存、I/0設備的抽象（各個進程地址空間中數據是徹底獨立的）
- 0號進程是Linux內核進程（這麼理解：初代吸血鬼）
- 1號進程是用戶進程，全部進程的建立或多或少和它有關係（
initorsystemd） - 2號進程和1號進程同樣，都是0號進程建立的，全部線程調度都和他有關係
先看看Linux啓動的圖示：（圖片來自網絡）
查看一下init進程
CentOS進行了優化管理～systemd
其實程序開機啓動方式也能夠知道區別了：systemctl start mongodb.service and sudo /etc/init.d/ssh start
Win系列的0號進程：
第5點的說明：（以遠程CentOS服務器爲例） pstree -ps
systemd(1)─┬─NetworkManager(646)─┬─{NetworkManager}(682)
│ └─{NetworkManager}(684)
├─agetty(1470)
├─auditd(600)───{auditd}(601)
├─crond(637)
├─dbus-daemon(629)───{dbus-daemon}(634)
├─firewalld(645)───{firewalld}(774)
├─lvmetad(483)
├─master(1059)─┬─pickup(52930)
│ └─qmgr(1061)
├─polkitd(627)─┬─{polkitd}(636)
│ ├─{polkitd}(639)
│ ├─{polkitd}(640)
│ ├─{polkitd}(642)
│ └─{polkitd}(643)
├─rsyslogd(953)─┬─{rsyslogd}(960)
│ └─{rsyslogd}(961)
├─sshd(950)───sshd(50312)───sshd(50325)───bash(50326)───pstree(54258)
├─systemd-journal(462)
├─systemd-logind(626)
├─systemd-udevd(492)
└─tuned(951)─┬─{tuned}(1005)
├─{tuned}(1006)
├─{tuned}(1007)
└─{tuned}(1048)
再看一個例子：
[dnt@localhost ~]$ pstree dnt -ps
sshd(50325)───bash(50326)───pstree(54471)
[dnt@localhost ~]$ pstree 50325 -ps
systemd(1)───sshd(950)───sshd(50312)───sshd(50325)───bash(50326)───pstree(54489)
其實你能夠在虛擬機試試乾死1號進程，就到了登陸頁面了【如今大部分系統都不讓你這麼幹了】 kill -9 1
-bash: kill: (1) - 不容許的操做
2.2.殭屍進程和孤兒進程¶
示例代碼：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/base
先看看定義：
孤兒進程 ：一個父進程退出，而它的一個或多個子進程還在運行，那麼那些子進程將成爲孤兒進程。孤兒進程將被init進程(進程號爲1)所收養，並由init進程對它們完成狀態收集工做。
殭屍進程 ：一個進程使用fork建立子進程，若是子進程退出，而父進程並無調用wait或waitpid獲取子進程的狀態信息，那麼子進程的進程描述符仍然保存在系統中。這種進程稱之爲僵死進程。
通俗講就是：
孤兒進程：你爸在你以前死了，你成了孤兒，而後你被進程1收養，你死後的事宜你乾爹幫你解決
殭屍進程：你掛了，你爸忙着幹其餘事情沒有幫你安葬，你變成了孤魂野鬼，你的怨念一直長存世間
舉個例子看看：
import os
import time
def main():
pid = os.fork()
if pid == 0:
print("子進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
time.sleep(1) # 睡1s
elif pid > 0:
print("父進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
print("pid=%d,over" % os.getpid())
if __name__ == '__main__':
main()
輸出：
import os
import time
def main():
pid = os.fork()
if pid == 0:
print("子進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
elif pid > 0:
print("父進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
while True:
print("父親我忙着呢，沒時間管你個小屁孩")
time.sleep(1)
print("pid=%d,over" % os.getpid())
if __name__ == '__main__':
main()
輸出+測試：
其實殭屍進程的危害真的很大，這也就是爲何有些人爲了追求效率過分調用底層，不考慮本身實際狀況最後發現還不如用自託管的效率高
殭屍進程是殺不死的，必須殺死父類才能完全解決它們，下面說說怎麼讓父進程爲子進程‘收屍’
2.3.父進程回收子進程（wait and waitpid）¶
講解以前先簡單分析一下上面的Linux指令（防止有人不太清楚）
kill -9 pid ==> 之前逆天說過，是無條件殺死進程，其實這種說法不許確，應該是發信號給某個進程
-9指的就是信號道里面的SIGKILL（信號終止），你寫成kill -SIGKILL pid也同樣
-9只是系統給的一種簡化寫法（好像記得1~31信號，各個Linux中都差很少，其餘的有點不同）
dnt@MZY-PC:~/桌面/work/PC/python/Thread/Linux 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
通常搜索進程中的某個程序通常都是用這個：ps -aux | grep xxx （|其實就是管道，用於有血緣關係進程間通訊，等會講）
若是安裝了pstree就更方便了：pstree 13570 -ps （Ubuntu自帶，CentOS要裝下yum install psmisc）
systemd(1)───systemd(1160)───gnome-terminal-(21604)───bash(8169)───python3(13570)───python3(13571)
擴展：咱們平時Ctrl+C其實就是給 2）SIGINT發一個信號
2.3.1.wait¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/wait
步入正題：
Python的Wait和C系列的稍有不一樣，這邊重點說說Python：
help(os.wait)
Help on built-in function wait in module posix:
wait()
Wait for completion of a child process.
Returns a tuple of information about the child process:
(pid, status)
os.wait()返回一個元組，第一個是進程id，第二個是狀態，正常退出是0，被九號信號乾死就返回9
來個案例：
import os
import time
def main():
pid = os.fork()
if pid == 0:
print("子進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
elif pid > 0:
print("父進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
wpid, status = os.wait()
print(wpid)
print(status)
print("pid=%d,over" % os.getpid())
if __name__ == '__main__':
main()
輸出：
父進程：Pid=22322,PPID=10139 子進程：Pid=22323,PPID=22322 pid=22323,over 22323 0 pid=22322,over
演示一下被9號信號乾死的狀況：
import os
import time
def main():
pid = os.fork()
if pid == 0:
print("子進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
while True:
print("孩子老卵，就是不聽話")
time.sleep(1)
elif pid > 0:
print("父進程：Pid=%d,PPID=%d" % (os.getpid(), os.getppid()))
wpid, status = os.wait() # 調用一次只能回收一次，想都回收，就來個while循環，-1則退出
print(wpid)
print(status)
if status == 0:
print("正常退出")
elif status == 9:
print("被信號9乾死了")
print("pid=%d,over" % os.getpid())
if __name__ == '__main__':
main()
輸出：
擴展：（回收全部子進程，status返回-1表明沒有子進程了，Python裏面沒有子進程會觸發異常）
import os
import time
def main():
i = 0
while i < 3:
pid = os.fork()
# 防止產生孫子進程（能夠本身思索下）
if pid == 0:
break
i += 1
if i == 0:
print("i=%d,子進程：Pid=%d,PPID=%d" % (i, os.getpid(), os.getppid()))
time.sleep(1)
elif i == 1:
print("i=%d,子進程：Pid=%d,PPID=%d" % (i, os.getpid(), os.getppid()))
time.sleep(1)
elif i == 2:
print("i=%d,子進程：Pid=%d,PPID=%d" % (i, os.getpid(), os.getppid()))
time.sleep(3)
while True:
print("(PID=%d)我又老卵了，怎麼滴～" % os.getpid())
time.sleep(3)
elif i==3: # 循環結束後，父進程纔會退出，這時候i=3
print("i=%d,父進程：Pid=%d,PPID=%d" % (i, os.getpid(), os.getppid()))
while True:
print("等待回收子進程")
try:
wpid, status = os.wait()
print(wpid)
print(status)
if status == 0:
print("正常退出")
elif status == 9:
print("被信號9乾死了")
except OSError as ex:
print(ex)
break
print("pid=%d,over，ppid=%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
演示：看最後一句輸出，父進程掃尾工做作完就over了
2.3.2.waitpid¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/waitpid
上面說的wait方法是阻塞進程的一種方式，waitpid能夠設置不阻塞進程
help(os.waitpid)
Help on built-in function waitpid in module posix:
waitpid(pid, options, /)
Wait for completion of a given child process.
Returns a tuple of information regarding the child process:
(pid, status)
The options argument is ignored on Windows.
等待進程id爲pid的進程結束，返回一個tuple，包括進程的進程ID和退出信息(和os.wait()同樣)，參數options會影響該函數的行爲。在默認狀況下，options的值爲0。
- 若是pid是一個正數，waitpid()請求獲取一個pid指定的進程的退出信息
- 若是pid爲0，則等待並獲取當前進程組中的任何子進程的值
- 若是pid爲-1，則等待當前進程的任何子進程
- 若是pid小於-1，則獲取進程組id爲pid的絕對值的任何一個進程
- 當系統調用返回-1時，拋出一個OSError異常。
官方原話是這樣的：（英語好的能夠看看我有沒有翻譯錯）
If pid is greater than 0, waitpid() requests status information for that specific process. If pid is 0, the request is for the status of any child in the process group of the current process. If pid is -1, the request pertains to any child of the current process. If pid is less than -1, status is requested for any process in the process group -pid (the absolute value of pid).
options:（宏）
os.WNOHANG - 若是沒有子進程退出，則不阻塞waitpid()調用
os.WCONTINUED - 若是子進程從stop狀態變爲繼續執行，則返回進程自前一次報告以來的信息。
os.WUNTRACED - 若是子進程被中止過並且其狀態信息尚未報告過，則報告子進程的信息。
補充：
- 進程組：每個進程都屬於一個「進程組」，當一個進程被建立的時候，它默認是其父進程所在組的成員（大家一家）
- 會 話：幾個進程組又構成一個會話（大家小區）
用法和wait差很少，就是多了一個不阻塞線程的方法：
import os
import time
def main():
pid = os.fork()
if pid == 0:
print("[子進程]PID：%d，PPID：%d" % (os.getpid(), os.getppid()))
time.sleep(2)
elif pid > 0:
print("[父進程]PID：%d，PPID：%d" % (os.getpid(), os.getppid()))
while True:
try:
wpid, status = os.waitpid(-1, os.WNOHANG)
if wpid > 0:
print("回收子進程wpid:%d,狀態status:%d" % (wpid, status))
except OSError:
print("沒有子進程了")
break
print("父進程忙着掙錢養家呢～")
time.sleep(3)
print("[over]PID：%d，PPID：%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
輸出：
[父進程]PID：1371，PPID：29604 [子進程]PID：1372，PPID：1371 父進程忙着掙錢養家呢～ [over]PID：1372，PPID：1371 回收子進程wpid:1372,狀態status:0 父進程忙着掙錢養家呢～ 沒有子進程了 [over]PID：1371，PPID：29604
2.3.3.wait3 and wait4¶
代碼實例：https://github.com/lotapp/BaseCode/blob/master/python/5.concurrent/Linux/wait3.py
help(os.wait3)
Help on built-in function wait3 in module posix:
wait3(options)
Wait for completion of a child process.
Returns a tuple of information about the child process:
(pid, status, rusage)
help(os.wait4)
Help on built-in function wait4 in module posix:
wait4(pid, options)
Wait for completion of a specific child process.
Returns a tuple of information about the child process:
(pid, status, rusage)
這個是Python擴展的方法，用法和wait、waitpid差很少，我就不一個個的舉例子了，以wait3爲例
import os
import time
def main():
pid = os.fork()
if pid == 0:
print("[子進程]PID：%d，PPID：%d" % (os.getpid(), os.getppid()))
time.sleep(2)
elif pid > 0:
print("[父進程]PID：%d，PPID：%d" % (os.getpid(), os.getppid()))
while True:
try:
wpid, status, rusage = os.wait3(os.WNOHANG)
if wpid > 0:
print("回收子進程wpid:%d,狀態status:%d\n詳細信息：%s" % (wpid, status,
rusage))
except OSError:
print("沒有子進程了")
break
print("父進程忙着掙錢養家呢～")
time.sleep(3)
print("[over]PID：%d，PPID：%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
輸出
[父進程]PID：2638，PPID：29604 [子進程]PID：2639，PPID：2638 父進程忙着掙錢養家呢～ [over]PID：2639，PPID：2638 回收子進程wpid:2639,狀態status:0 詳細信息：resource.struct_rusage(ru_utime=0.0052179999999999995, ru_stime=0.0052179999999999995, ru_maxrss=7032, ru_ixrss=0, ru_idrss=0, ru_isrss=0, ru_minflt=869, ru_majflt=0, ru_nswap=0, ru_inblock=0, ru_oublock=0, ru_msgsnd=0, ru_msgrcv=0, ru_nsignals=0, ru_nvcsw=2, ru_nivcsw=0) 父進程忙着掙錢養家呢～ 沒有子進程了 [over]PID：2638，PPID：29604
擴展：execl and execlp¶
代碼實例：https://github.com/lotapp/BaseCode/blob/master/python/5.concurrent/Linux/execl.py
以前有說fork後，至關於copy了一份，.text裏面放的是代碼段，若是想要調用另外一個程序，可使用execlxxx，他會把.text裏面的代碼替換掉
help(os.execl)
Help on function execl in module os:
execl(file, *args)
execl(file, *args)
Execute the executable file with argument list args, replacing the
current process.
help(os.execlp)
Help on function execlp in module os:
execlp(file, *args)
execlp(file, *args)
Execute the executable file (which is searched for along PATH)
with argument list args, replacing the current process.
來看個例子，os.execl("絕對路徑","參數或者指令") or os.execlp("Path中包含的命令","參數或者指令")
提示：查看命令路徑：eg：which ls
import os
def main():
pid = os.fork()
if pid == 0:
# 第二個參數不能爲None,，第一個路徑爲絕對路徑 eg：os.execl("/bin/ls"," ")
os.execl("/bin/ls", "ls", "-al")
# os.execlp("ls", "ls", "-al") # 執行Path環境變量能夠搜索到的命令
print("exec函數族會替換代碼，我是不會被執行的，除非上面的出問題了")
print("-" * 10) # 父進程執行一次，子進程不會執行
if __name__ == '__main__':
main()
注意輸出信息：os.execlp("ls", "ls", "-al")
---------- 總用量 28 drwxrwxr-x 6 dnt dnt 4096 7月 26 05:23 . drwxrwxr-x 9 dnt dnt 4096 7月 24 20:55 .. drwxr-xr-x 2 dnt dnt 4096 7月 19 14:47 .ipynb_checkpoints drwxrwxr-x 6 dnt dnt 4096 7月 26 06:27 Linux -rw-rw-r-- 1 dnt dnt 93 7月 26 05:49 temp.py drwxrwxr-x 2 dnt dnt 4096 7月 24 15:29 .vscode drwxrwxr-x 2 dnt dnt 4096 7月 25 12:18 進程
2.4.1.進程間通訊～文件通訊¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/進程通訊/1.file
講管道以前，先說個簡單的：經過文件進行通訊
來一個簡單讀寫的案例先適應下文件操做：
In [1]:
!ls
# 這種寫法相似於Net的 using 託管
with open("test.txt", "w") as f:
f.write("從前有座山,山上有座廟,廟裏有個老和尚和一個小和尚。有一天,老和尚對小和尚說:")
with open("test.txt", "r") as f:
data = f.read()
print(data)
!ls
來個簡單的案例：
import os
import time
def main():
pid = os.fork()
if pid > 0:
print("父進程(pid=%d)開始寫入：" % os.getpid())
with open(str(pid), "w") as f:
f.write("[父進程寫入]從前有座山,山上有座廟,廟裏有個老和尚和一個小和尚。有一天,老和尚對小和尚說:\n")
time.sleep(2)
print("父進程(pid=%d)開始讀取：" % os.getpid())
with open(str(pid), "r") as f:
print(f.read())
wpid, status = os.wait() # 收屍
print("pid=%d已經回收,status:%d" % (wpid, status))
elif pid == 0:
print("子進程(pid=%d)開始讀取：" % os.getpid())
with open(str(os.getpid()), "r") as f:
print(f.read())
print("子進程(pid=%d)開始追加：" % os.getpid())
with open(str(os.getpid()), "a") as f: # 追加
f.write("[子進程追加]從前有座山,山上有座廟,廟裏有個老和尚和一個小和尚。有一天,老和尚對小和尚說:\n")
print("\n進程(pid=%d)完蛋了" % os.getpid())
if __name__ == '__main__':
main()
圖示：
2.4.2.進程間通訊～隊列 Queue（經常使用）¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/進程通訊/2.Queue
from multiprocessing import Queue
help(Queue)
Help on method Queue in module multiprocessing.context:
Queue(maxsize=0) method of multiprocessing.context.DefaultContext instance
Returns a queue object
實例化對象幫助文檔：
from multiprocessing import Queue
q = Queue(2)
help(q)
Help on Queue in module multiprocessing.queues object:
class Queue(builtins.object)
| Methods defined here:
|
| __getstate__(self)
|
| __init__(self, maxsize=0, *, ctx)
| Initialize self. See help(type(self)) for accurate signature.
|
| __setstate__(self, state)
|
| cancel_join_thread(self)
|
| close(self)
|
| empty(self)
|
| full(self)
|
| get(self, block=True, timeout=None)
|
| get_nowait(self)
|
| join_thread(self)
|
| put(self, obj, block=True, timeout=None)
|
| put_nowait(self, obj)
|
| qsize(self)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
詳細內容（如：非阻塞、池中應用等）下次講代碼的時候會詳說，簡單看個例子：
import os
from multiprocessing import Queue
def main():
q = Queue(1) # 建立一個容量爲1的隊列（只能put接受1條,get取出後才能夠放）
pid = os.fork()
if pid == 0:
print("[子進程]:pid:%d,ppid:%d" % (os.getpid(), os.getppid()))
q.put("父親大人，我能夠出去玩嗎？")
output = q.get()
print("[子進程]收到父親大人回覆：%s" % output)
elif pid > 0:
print("[父進程]:pid:%d,ppid:%d" % (os.getppid(), os.getppid()))
output = q.get() # 兒子天天出去都會說，等待ing
print("[父進程]收到兒子的話：%s" % output)
q.put("準了")
wpid, status = os.wait()
print("[父進程]幫pid:%d收屍，狀態：%d" % (wpid, status))
print("[OVER]:pid:%d,ppid:%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
輸出:
[父進程]:pid:12403,ppid:12403 [子進程]:pid:744,ppid:743 [父進程]收到兒子的話：父親大人，我能夠出去玩嗎？ [子進程]收到父親大人回覆：準了 [OVER]:pid:744,ppid:743 [父進程]幫pid:744收屍，狀態：0 [OVER]:pid:743,ppid:12403
2.4.3.進程間通訊～PIPE匿名管道（經常使用）¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/進程通訊/3.pipe
知識普及：
- 命令模式下默認有六個終端tty1-tty6
- tty7表明圖形登陸
- 遠程登陸會顯示pts/0,1,2...
若是終端的概念還不清楚能夠看以前的文章：http://www.javashuo.com/article/p-dgpdyqpb-x.html
help(os.pipe)
Help on built-in function pipe in module posix:
pipe()
Create a pipe.
Returns a tuple of two file descriptors:
(read_fd, write_fd)
匿名管道的模式其實咱們平時都在用，只是不知道而已，好比：ps aux | grep "python" 這個 | 就是匿名管道
本質：內核的緩衝區，不佔用磁盤空間（能夠當作僞文件）【默認4k，相差不大的狀況下系統會自動微調大小】
咱們來看一下：ulimit -a
Ubuntu 18.04
core file size (blocks, -c) 0 data seg size (kbytes, -d) unlimited scheduling priority (-e) 0 file size (blocks, -f) unlimited pending signals (-i) 14894 max locked memory (kbytes, -l) 16384 max memory size (kbytes, -m) unlimited open files (-n) 1024 pipe size (512 bytes, -p) 8 POSIX message queues (bytes, -q) 819200 real-time priority (-r) 0 stack size (kbytes, -s) 8192 cpu time (seconds, -t) unlimited max user processes (-u) 14894 virtual memory (kbytes, -v) unlimited file locks (-x) unlimited
CentOS 7.5
core file size (blocks, -c) 0 data seg size (kbytes, -d) unlimited scheduling priority (-e) 0 file size (blocks, -f) unlimited pending signals (-i) 3543 max locked memory (kbytes, -l) 64 max memory size (kbytes, -m) unlimited open files (-n) 1024 pipe size (512 bytes, -p) 8 POSIX message queues (bytes, -q) 819200 real-time priority (-r) 0 stack size (kbytes, -s) 8192 cpu time (seconds, -t) unlimited max user processes (-u) 3543 virtual memory (kbytes, -v) unlimited file locks (-x) unlimited
原理：算法實現的環形隊列（隊列：先進先出）
特色：
- 操做管道的進程被銷燬後，管道自動被釋放
- 管道默認是阻塞（讀、寫兩端都阻塞）
- 管道有兩個端，一個是讀端（read_fd，通常都爲3),一個是寫端（write_fd，通常都爲4）
- 單向傳輸
4的意思是這樣的（網上找個圖，而後改造一下）
驗證一下3：
爲何是3開始呢？查看一下源碼：（https://github.com/python/cpython/blob/v3.7.0/Lib/pty.py）
STDIN_FILENO = 0 # 看這：文件描述符輸入（讀端）
STDOUT_FILENO = 1 # 看這：文件描述符輸出（寫端）
STDERR_FILENO = 2 # 已經被佔用了0~2了，天然從3開始
# 下面的不用你會，上面Code看完，咱們的目的就達到了，下面看看便可
def fork():
"""fork() -> (pid, master_fd) Fork分叉後讓子進程成爲控制終端的會話領導者"""
try:
pid, fd = os.forkpty() # 設置會話領導
except (AttributeError, OSError):
pass
else: # 沒有錯誤執行
if pid == CHILD:
os.setsid()
return pid, fd
master_fd, slave_fd = openpty()
pid = os.fork()
if pid == CHILD:
# 創建一個新的會話
os.setsid()
os.close(master_fd)
# 把子進程裏面的 slave_fd 重定向到 stdin/stdout/stderr
os.dup2(slave_fd, STDIN_FILENO)
os.dup2(slave_fd, STDOUT_FILENO)
os.dup2(slave_fd, STDERR_FILENO)
if (slave_fd > STDERR_FILENO):
os.close (slave_fd)
# 顯式打開tty，使它成爲一個tty控制
tmp_fd = os.open(os.ttyname(STDOUT_FILENO), os.O_RDWR)
os.close(tmp_fd)
else:
os.close(slave_fd)
# Parent and child process.
return pid, master_fd
畫個大綱圖理解一下：（讀的時候關閉寫，寫的時候關閉讀）
結合單向傳輸理解一下：（父子只能一我的寫，另外一我的只能讀） 簡單概況上圖：子進程只讀，父進程只寫 or 子進程只寫，父進程只讀 (若是想要相互讀寫通訊～兩根管道走起)
簡單分析一下 ps aux | grep python ，原本ps aux是準備在終端中輸出的，如今寫入內核緩衝區了，grep從內核緩衝區裏面讀取，把符合條件的輸出到終端
終端文件描述獲取：
import sys
sys.stdin.fileno() # STDIN_FILENO = 0：文件描述符輸入（讀端）
sys.stdout.fileno() # STDOUT_FILENO = 1：看這：文件描述符輸出（寫端）
咱們用程序實現一個一樣效果的：(grep有顏色，其實就是加了--color=auto)
import os
import sys
def main():
# 建立內核緩存區（僞文件）
read_fd, write_fd = os.pipe()
print("read_fd:%s\nwrite_fd:%s" % (read_fd, write_fd))
pid = os.fork()
if pid > 0:
print("[父進程]pid=%d,ppid=%d" % (os.getpid(), os.getppid()))
# 寫或者讀，則須要關閉另外一端（防止本身寫本身讀）
os.close(read_fd)
# dup2(oldfd,newfd) 把寫端數據重定向到文件描述符輸出端
os.dup2(write_fd, sys.stdout.fileno()) # STDOUT_FILENO==1 (文件描述符輸出，寫端)
# 僵桃李代
os.execlp("ps", "ps", "aux")
elif pid == 0:
print("[子進程]pid=%d,ppid=%d" % (os.getpid(), os.getppid()))
# 子進程如今須要讀，關閉寫段
os.close(write_fd)
# dup2(oldfd,newfd) 把讀端數據重定向到文件描述符輸入端
os.dup2(read_fd, sys.stdin.fileno()) # STDOUT_FILENO == 0 (文件描述符輸入，讀端)
# 僵桃李代 （默認是從終端讀，重定向後從內核緩衝區讀）
os.execlp("grep", "grep", "python", "--color=auto")
if __name__ == '__main__':
main()
輸出：（用到的函數：os.pipe() and os.dup2(oldfd,newfd)）
PS：在C系列裏面若是你該關閉的fd沒關，會資源浪費，python好像作了處理，沒可以問題復現，因此仍是建議父子一方只讀，一方只寫
概念再理解：fork了兩個子進程，則文件描述符被複制了2份，你們文件描述符的三、4都指向了pipe管道的read_fd和write_fd
來張圖理解一下，哪些fd被close了(若是讓子進程之間通訊，父進程由於不讀不寫，因此讀寫都得關閉) 代碼演示：（此次註釋很全）
import os
import sys
import time
def main():
read_fd, write_fd = os.pipe() # 能夠思考爲啥在上面建立管道（提示.text代碼段都同樣）
i = 0
while i < 2:
pid = os.fork()
# 防止子進程生猴子
if pid == 0:
break
i += 1
# 子進程1
if i == 0:
print("[子進程%d]pid=%d，ppid=%d" % (i, os.getpid(), os.getppid()))
# 準備重定向到寫端，因此先關了讀端
os.close(read_fd)
os.dup2(write_fd, sys.stdout.fileno()) # STDOUT_FILENO == 1 (文件描述符輸出，寫端)
# 僵桃李代
os.execlp("ps", "ps", "-aux")
# 僵桃李代後，.text代碼段都被替換了，天然不會執行
print("我是不會執行的，不信你看唄")
elif i == 1:
print("[子進程%d]pid=%d，ppid=%d" % (i, os.getpid(), os.getppid()))
# 準備重定向到讀端，因此先關了寫端
os.close(write_fd)
os.dup2(read_fd, sys.stdin.fileno()) # STDIN_FILENO == 0 (文件描述符輸入，讀端)
# 僵桃李代 」bash「是查找關鍵詞，你寫你想找的字符串便可
os.execlp("grep", "grep", "bash", "--color=auto")
# 僵桃李代後，.text代碼段都被替換了，天然不會執行
print("我是不會執行的，不信你看唄")
elif i == 2:
print("[父進程]pid=%d，ppid=%d" % (os.getpid(), os.getppid()))
# 我不寫不讀
os.close(read_fd)
os.close(write_fd)
# 爲了你們熟練掌握wait系列，此次用waitpid
while True:
info = ()
try:
info = os.waitpid(-1, os.WNOHANG) # 非阻塞的方式回收全部子進程
except OSError:
break # waitpid返回-1的時候，Python會拋出異常
if info[0] > 0:
print("父進程收屍成功：pid=%d，ppid=%d，狀態status：%d" %
(os.getpid(), os.getppid(), info[1]))
print("父進程作其餘事情...")
time.sleep(0.005) # 休息 0.005s
print("[父進程-遺言]pid=%d，ppid=%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
結果：
[父進程]pid=18678，ppid=27202 [子進程0]pid=18679，ppid=18678 [子進程1]pid=18680，ppid=18678 父進程作其餘事情... 父進程作其餘事情... 父進程作其餘事情... 父進程作其餘事情... dnt 4622 0.0 0.1 24880 5688 pts/2 Ss 05:28 0:00 bash 父進程作其餘事情... dnt 15419 0.0 0.1 25152 5884 pts/0 Ss+ 06:29 0:00 /bin/bash dnt 18680 0.0 0.0 16184 1044 pts/4 S+ 13:25 0:00 grep bash --color=auto dnt 27202 0.0 0.1 25012 6052 pts/4 Ss 08:25 0:00 bash 父進程收屍成功：pid=18678，ppid=27202，狀態status：0 父進程作其餘事情... 父進程收屍成功：pid=18678，ppid=27202，狀態status：0 父進程作其餘事情... [父進程-遺言]pid=18678，ppid=27202
In [1]:
# 說管道讀寫以前，先複習個知識點：
bts = "尷尬".encode()
b_str = bts.decode()
print(bts)
print(b_str)
匿名管道讀寫操做¶
上面知識點忘了能夠複習一下：http://www.javashuo.com/article/p-tmcacaan-d.html
用到的函數：（這個就不須要使用dup2來重定向到終端了【有血緣關係的進程之間通訊，並不依賴於終端顯示】）
os.write(fd, str)寫入字符串到文件描述符 fd中. 返回實際寫入的字符串長度
os.read(fd, n)從文件描述符 fd 中讀取最多 n 個字節，返回包含讀取字節的字符串
若是文件描述符fd對應文件已達到結尾, 返回一個空字符串
舉個父子間通訊的例子（比C系列簡單太多）【下次講的通用Code會更簡單】
import os
def close_fd(*fd_tuple_args):
"""關閉fd，fd_tuple_args是可變參數"""
for item in fd_tuple_args:
os.close(item[0])
os.close(item[1])
def main():
# 管道是單向的，相互讀寫，那就建立兩個管道
fd_tuple1 = os.pipe() # 進程1寫，進程2讀
fd_tuple2 = os.pipe() # 進程2寫，進程1讀
i = 0
while i < 2:
pid = os.fork()
if pid == 0:
break
i += 1
# 子進程1
if i == 0:
print("[子進程]pid：%d，ppid：%d" % (os.getpid(), os.getppid()))
os.close(fd_tuple1[0]) # 進程1寫，則關閉下讀端
msg_str = "進程1說：兄弟，今天擼串嗎？"
os.write(fd_tuple1[1], msg_str.encode()) # 把字符串xxx轉換成bytes
# 不讀的我關閉掉：
os.close(fd_tuple2[1]) # 進程2寫，我不須要寫，關閉寫端
bts = os.read(fd_tuple2[0], 1024)
print("[子進程1]", bts.decode())
exit(0) # 退出後就不執行下面代碼塊語句了
# 子進程2
elif i == 1:
print("[子進程2]pid：%d，ppid：%d" % (os.getpid(), os.getppid()))
os.close(fd_tuple1[1]) # 進程2讀，則關閉下寫端
bts = os.read(fd_tuple1[0], 1024)
print("[子進程2]", bts.decode())
# 不讀的我關閉掉：
os.close(fd_tuple2[0]) # 進程2寫，關閉讀端
msg_str = "進程2說：能夠能夠～"
os.write(fd_tuple2[1], msg_str.encode()) # 把字符串xxx轉換成bytes
exit() # 不加參數默認是None
# 父進程
elif i == 2:
print("[父進程]pid：%d，ppid：%d" % (os.getpid(), os.getppid()))
# 父進程不讀不寫，就看看
close_fd(fd_tuple1, fd_tuple2)
# 收屍ing
while True:
try:
wpid, status = os.wait()
print("[父進程～收屍]子進程PID：%d 的狀態status：%d" % (wpid, status))
except OSError:
break
# 子進程都exit()退出了，不會執行這句話了
print("[父進程遺言]pid：%d,ppid：%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
輸出結果：
[父進程]pid：12002，ppid：27202 [子進程2]pid：12004，ppid：12002 [子進程]pid：12003，ppid：12002 [子進程2] 進程1說：兄弟，今天擼串嗎？ [子進程1] 進程2說：能夠能夠～ [父進程～收屍]子進程PID：12003 的狀態status：0 [父進程～收屍]子進程PID：12004 的狀態status：0 [父進程遺言]pid：12002,ppid：27202
非阻塞管道（簡寫法）¶
隊列的get，put方法默認也是阻塞的，若是想非阻塞能夠調用get_nowait和put_nowait來變成非阻塞，那pipe管道呢？
C系列通常使用fcntl來實現，Python進行了封裝，咱們能夠經過os.pipe2(os.O_NONBLOCK)來設置非阻塞管道
help(os.pipe2)
Help on built-in function pipe2 in module posix:
pipe2(flags, /)
Create a pipe with flags set atomically.
Returns a tuple of two file descriptors:
(read_fd, write_fd)
flags can be constructed by ORing together one or more of these values:
O_NONBLOCK, O_CLOEXEC.
舉個例子：
import os
import time
def main():
r_fd, w_fd = os.pipe2(os.O_NONBLOCK | os.O_CLOEXEC)
pid = os.fork()
if pid == 0:
print("子進程：pid=%d，ppid=%d" % (os.getpid(), os.getppid()))
time.sleep(0.5)
# 和父進程進行通訊
os.close(r_fd)
os.write(w_fd, "老爸，我出去玩了～".encode())
exit(0) # 子進程退出
elif pid > 0:
print("父進程：pid=%d，ppid=%d" % (os.getpid(), os.getppid()))
# 讀兒子的留言
os.close(w_fd)
b_msg = b""
while True:
try:
b_msg = os.read(r_fd, 1) # 沒有數據就出錯（通常都是等待一會，也能夠和信號聯合使用）
except OSError:
print("兒子怎麼沒有留言呢？")
print("父進程：作其餘事情...")
if len(b_msg) > 0:
break
time.sleep(0.1)
# 繼續讀剩下的消息
b_msg += os.read(r_fd, 1024)
print("兒子留言:", b_msg.decode())
wpid, status = os.wait()
print("幫兒子作掃尾工做：pid=%d，status=%d" % (wpid, status))
print("父進程遺言：pid=%d，status=%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
輸出：
父進程：pid=31430，ppid=27202 子進程：pid=31431，ppid=31430 兒子怎麼沒有留言呢？ 父進程：作其餘事情... 兒子怎麼沒有留言呢？ 父進程：作其餘事情... 兒子怎麼沒有留言呢？ 父進程：作其餘事情... 兒子怎麼沒有留言呢？ 父進程：作其餘事情... 兒子怎麼沒有留言呢？ 父進程：作其餘事情... 父進程：作其餘事情... 兒子留言: 老爸，我出去玩了～ 幫兒子作掃尾工做：pid=31431，status=0 父進程遺言：pid=31430，status=27202
擴展：
2.4.4.進程間通訊～FIFO有名管道¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/進程通訊/4.fifo
- 有名管道，除了血緣關係進程通訊，沒有血緣關係的進程也能夠通訊
- 在磁盤上有會存放一個文件類型爲
p，大小爲0的管道文件（僞文件，大小始終爲0） - 內核中有一個對應的緩衝區（數據就放在裏面）
- 半雙工通訊：同一時刻裏，信息只能有一個傳輸方向（相似於對講機）
- fifo要求讀寫雙方必須同時打開才能夠繼續進行讀寫操做，不然打開操做會堵塞直到對方也打開
- 若是讀端所有關閉，管道破裂，進程自動被終止（PIPE也是這樣的）
對2的驗證： 其實你用ll來查看，就是文件類型爲p的文件（大小始終爲0）
Linux底層提供了mkfifo函數，Python建立使用os.mkfifo()
畫個圖來看3：
知識普及：
help(os.open)
Help on built-in function open in module posix:
open(path, flags, mode=511, *, dir_fd=None)
Open a file for low level IO. Returns a file descriptor (integer).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
flags -- 該參數能夠是如下選項，多個使用 | 隔開：
- os.O_RDONLY: 以只讀的方式打開
- os.O_WRONLY: 以只寫的方式打開
- os.O_RDWR : 以讀寫的方式打開
- os.O_NONBLOCK: 打開時不阻塞
- os.O_APPEND: 以追加的方式打開
- os.O_CREAT: 建立並打開一個新文件
- os.O_TRUNC: 打開一個文件並截斷它的長度爲零（必須有寫權限）
- os.O_EXCL: 若是指定的文件存在，返回錯誤
- os.O_SHLOCK: 自動獲取共享鎖
- os.O_EXLOCK: 自動獲取獨立鎖
- os.O_DIRECT: 消除或減小緩存效果
- os.O_FSYNC : 同步寫入
- os.O_NOFOLLOW: 不追蹤軟連接
不少人直接使用了Open方法open(fifo_path, "r")和open(fifo_path, "w")貌似也是能夠的，可是不推薦
咱們使用官方推薦的方法：
無血緣關係通訊¶
fifo操做很是簡單，和文件IO操做幾乎同樣，看個無血緣關係進程通訊的例子：
進程1源碼：r_fifo.py
import os
def main():
file_name = "fifo_file"
if not os.path.exists(file_name):
os.mkfifo(file_name)
fd = os.open(file_name, os.O_RDONLY) # 只讀（阻塞）
while True:
b_msg = os.read(fd, 1024)
if len(b_msg) > 0:
print(b_msg.decode())
if __name__ == '__main__':
main()
進程2源碼：w_fifo.py
import os
import time
def main():
file_name = "fifo_file"
if not os.path.exists(file_name):
os.mkfifo(file_name)
fd = os.open(file_name, os.O_WRONLY) # 只寫
while True:
time.sleep(1) # 模擬一下實際生產環境下的 讀快寫慢
try:
os.write(fd, "我是說話有魔性，喝水會長胖的小明同窗".encode()) # 寫入bytes
except BrokenPipeError:
print("若是讀端所有關閉，管道破裂，進程自動被終止")
break
if __name__ == '__main__':
main()
作個讀端的測試：
讀寫雙測：（fifo文件大小始終爲0，只是僞文件而已）
擴展一下，若是你經過終端讀寫呢？（同上）
再來個讀寫的案例
3.rw_fifo1.py
import os
def main():
file_name = "fifo_temp"
if not os.path.exists(file_name):
os.mkfifo(file_name)
fd = os.open(file_name, os.O_RDWR) # 你輸入os.O_rw就會有這個選項了，不用硬記
msg = os.read(fd, 1024).decode() # 阻塞的方式，不用擔憂
print("[進程2]%s" % msg)
os.write(fd, "小明啊，你忘記你長几斤肉了?".encode())
if __name__ == '__main__':
main()
rw_fifo2.py
import os
import time
def main():
file_name = "fifo_temp"
if not os.path.exists(file_name):
os.mkfifo(file_name)
fd = os.open(file_name, os.O_RDWR) # 你輸入os.O_rw就會有這個選項了，不用硬記
os.write(fd, "小潘，擼串去不?".encode())
time.sleep(3) # 防止本身寫的被本身讀了
msg = os.read(fd, 1024).decode() # 阻塞的方式，不用擔憂
print("[進程1]]%s" % msg)
if __name__ == '__main__':
main()
有血緣關係通訊¶
來個父子間通訊：（代碼比較簡單，和上面差很少，看看便可）
import os
def main():
file_name = "fifo_test"
if not os.path.exists(file_name):
os.mkfifo(file_name)
fd = os.open(file_name, os.O_RDWR) # 讀寫方式打開文件描述符 （O_RDONLY | O_WRONLY）
pid = os.fork()
if pid == 0:
print("子進程：PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
os.write(fd, "子進程說：老爸，我想出去玩".encode()) # 寫
msg = os.read(fd, 1024).decode() # 讀
print("[子進程]%s" % msg)
elif pid > 0:
print("父進程：PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
msg = os.read(fd, 1024).decode() # 阻塞方式，不用擔憂
print("[父進程]%s" % msg)
os.write(fd, "父進程說：去吧乖兒子".encode())
# 給子進程收屍
wpid, status = os.wait()
print("父進程收屍：子進程PID=%d，PPID=%d" % (wpid, status))
print("進程遺言：PID=%d，PPID=%d" % (os.getpid(), os.getppid())) # 剩下的代碼段
if __name__ == '__main__':
main()
輸出：
父進程：PID:21498，PPID:20943 子進程：PID:21499，PPID:21498 [父進程]子進程說：老爸，我想出去玩 [子進程]父進程說：去吧乖兒子 進程遺言：PID=21499，PPID=21498 父進程收屍：子進程PID=21499，PPID=0 進程遺言：PID=21498，PPID=20943
2.4.5.進程間通訊～MMAP內存映射（經常使用）¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/進程通訊/5.mmap
好處：內存操做，比IO快
缺點：和文件同樣不會像管道同樣阻塞（讀的可能不全，須要本身考慮讀寫效率）
畫個簡單的圖示： PS：內存映射一個文件並不會致使整個文件被讀取到內存中:
- 文件並無被複制到內存緩存中，操做系統僅僅爲文件內容保留了一段虛擬內存。
- 當你訪問文件的不一樣區域時，這些區域的內容才根據須要被讀取並映射到內存區域中。
- 沒有訪問的部分仍是留在磁盤上
以Linux爲例，簡單解析一下幫助文檔：（加粗的是必填參數）
mmap.mmap（fileno,length[,flags=MAP_SHARED][,prot=PROT_WRITE|PROT_READ][,access=ACCESS_DEFAULT][,offset]）
- fileno：就是咱們常常說的
文件描述fd- 能夠經過
os.open()直接打開fd - 也能夠調用文件的
f.fileno()
- 能夠經過
- length：映射區大小，（通常寫0就OK了）
- 若是length爲0，則映射的最大長度將是調用時文件的當前大小
- 通常把
文件大小 os.path.getsize(path)傳進去就能夠了
- flags：映射區性質，默認是用共享
- MAP_SHARED 共享（數據會自動同步磁盤）
- MAP_PRIVATE 私有（不一樣步磁盤）
- prot：映射區權限，若是指定，就會提供內存保護（默認便可）
- PROT_READ 讀
- PROT_READ | PROT_WRITE 寫（必須有讀的權限）
- access：能夠指定訪問來代替flags和prot做爲可選的關鍵字參數【這個是Python爲了簡化而添加的】
- ACCESS_READ：只讀
- ACCESS_WRITE：讀和寫（會影響內存和文件）
- ACCESS_COPY：寫時複製內存（影響內存，但不會更新基礎文件）
- ACCESS_DEFAULT：延遲到prot（3.7才添加）
- offset，偏移量，默認是0（和文件一致）
In [1]:
# 這個夠明瞭了，\0轉換成二進制就是\x00
"\0".encode()
Out[1]:
In [2]:
# 老規矩，開始以前，擴充一個小知識點：(空字符串和'\0'區別)
a = "" # 空字符串 （Python裏面沒有char類型）
b = "\x00" # `\0` 的二進制寫法
c = "\0"
print(a)
print(b)
print(c)
print(len(a))
print(len(b))
print(len(c))
看個簡單的案例快速熟悉mmap模塊：(大文件處理這塊先不說，之後要是有機會講數據分析的時候會再提)
m.size() # 查看文件大小
m.seek(0) # 修改Postion位置
m.tell() # 返回 m 對應文件的Postion位置
m.read().translate(None, b"\x00") # 讀取全部內容並把\0刪除
m.closed # 查看mmap是否關閉
# 支持切片操做
m[0:10] # 取值
m[0:10] = b"1234567890" # 賦值
# 對自行模式大文件處理的同志，給個提示
m.readline().decode() # 讀一行，並轉換成str
m.size()==m.tell() # while循環退出條件
熟悉一下上面幾個方法：
import os
import mmap
def create_file(filename, size):
"""初始化一個文件，並把文件擴充到指定大小"""
with open(filename, "wb") as f:
f.seek(size - 1) # 改變流的位置
f.write(b"\x00") # 在末尾寫個`\0`
def main():
create_file("mmap_file", 4096) # 建立一個4k的文件
with mmap.mmap(os.open("mmap_file", os.O_RDWR), 0) as m: # 建立映射
print(m.size()) # 查看文件大小
m.resize(1024) # 從新設置文件大小
print(len(m)) # len也同樣查看文件大小
print(m.read().translate(None, b"\x00")) # 讀取全部內容並把\0刪除
print(m.readline().decode()) # 讀取一行，bytes轉成str
print(m.tell()) # 返回 m 對應文件的當前位置
m.seek(0) # 修改Postion位置
print(m.tell()) # 返回 m 對應文件的當前位置
print(m[0:10]) # 支持切片操做
print("postion_index:%d" % m.tell())
m[0:10] = b"1234567890" # 賦值
print("postion_index:%d" % m.tell())
print(m[0:10]) # 取值
print("postion_index:%d" % m.tell())
print(m[:].decode()) # 所有讀出來
print(m.closed) # 查看mmap是否關閉
if __name__ == '__main__':
main()
輸出：(測試了一下，切片操做【讀、寫】不會影響postion)
4096 1024 b'' 1024 0 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' postion_index:0 postion_index:0 b'1234567890' postion_index:0 1234567890 True
看下open打開的案例：
import os
import mmap
def main():
with open("temp", "wb") as f:
f.write("小明同窗最愛刷碗\n小潘同窗最愛打掃".encode())
# 打開磁盤二進制文件進行更新（讀寫）
with open("temp", "r+b") as f:
with mmap.mmap(f.fileno(), 0) as m:
print("postion_index:%d" % m.tell())
print(m.readline().decode().strip()) # 轉成str並去除兩端空格
print("postion_index:%d" % m.tell())
print(m[:].decode()) # 所有讀出來
print("postion_index:%d" % m.tell())
m.seek(0)
print("postion_index:%d" % m.tell())
if __name__ == '__main__':
main()
輸出：
postion_index:0 小明同窗最愛刷碗 postion_index:25 小明同窗最愛刷碗 小潘同窗最愛打掃 postion_index:25 postion_index:0
其餘方法能夠參考：這篇文章（Python3不少都和Python2不太相同，辯證去看吧）
注意一點：
經過MMap內存映射以後，進程間通訊並非對文件操做，而是在內存中。文件保持同步只是由於mmap的flags默認設置的是共享模式（MAP_SHARED）
PS：還記得以前講類方法和實例方法的時候嗎？Python中類方法能夠直接被對象便捷調用，這邊mmap實例對象中的方法，其實不少都是類方法 步入正軌：
來看一個有血緣關係的通訊案例：（通常用匿名）
import os
import time
import mmap
def create_file(file_name, size):
with open(file_name, "wb") as f:
f.seek(size - 1)
f.write(b"\0x00")
def main():
file_name = "temp.bin"
# mmap映射的時候不能映射空文件，因此咱們本身建立一個
create_file(file_name, 1024)
fd = os.open(file_name, os.O_RDWR)
with mmap.mmap(fd, 0) as m: # m.resize(1024) # 大小能夠本身調整的
pid = os.fork()
if pid == 0:
print("[子進程]PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
m.write("子進程說：老爸，我想出去玩了～\n".encode())
time.sleep(3)
print(m.readline().decode().strip())
exit(0)
elif pid > 0:
print("[父進程]PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
time.sleep(1) # 和文件同樣，非堵塞
print(m.readline().decode().strip())
m.write("父進程說：去吧去吧\n".encode())
wpid, status = os.wait()
print("[父進程]收屍：PID:%d，Status:%d" % (wpid, status))
exit(0)
if __name__ == '__main__':
main()
輸出：
[父進程]PID:6843，PPID:3274 [子進程]PID:6844，PPID:6843 子進程說：老爸，我想出去玩了～ 父進程說：去吧去吧 [父進程]收屍：PID:6844，Status:0
有血緣關係使用MMAP通訊¶
父進程建立了一份mmap對象，fork產生子進程的時候至關於copy了一份指向，因此能夠進行直接通訊（聯想fd的copy）
import os
import time
import mmap
def main():
# 不記錄文件中，直接內存中讀寫（這個地方len就不能爲0了，本身指定一個大小eg：4k）
with mmap.mmap(-1, 4096) as m:
pid = os.fork()
if pid == 0:
print("[子進程]PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
m.write("[子進程]老爸我出去嗨了～\n".encode())
time.sleep(2)
msg = m.readline().decode().strip()
print(msg)
exit(0)
elif pid > 0:
print("[父進程]PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
time.sleep(1)
msg = m.readline().decode().strip()
print(msg)
m.write("[父進程]去吧，皮卡丘～".encode())
wpid, status = os.wait()
print("[父進程]收屍：PID:%d，Status:%d" % (wpid, status))
exit(0)
if __name__ == '__main__':
main()
輸出：
[父進程]PID:8115，PPID:3274 [子進程]PID:8116，PPID:8115 [子進程]老爸我出去嗨了～ [父進程]去吧，皮卡丘～ [父進程]收屍：PID:8116，Status:0
無血緣關係使用MMAP通訊¶
由於不一樣進程以前沒有關聯，必須以文件爲媒介（文件描述符fd）
進程1：
import os
import time
import mmap
def create_file(file_name, size):
with open(file_name, "wb") as f:
f.seek(size - 1)
f.write(b"\0x00")
def main():
file_name = "temp.bin"
if not os.path.exists(file_name):
# mmap映射的時候不能映射空文件，因此咱們本身建立一個
create_file(file_name, 1024)
fd = os.open(file_name, os.O_RDWR)
with mmap.mmap(fd, 0) as m: # m.resize(1024) # 大小能夠本身調整的
print("[進程1]PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
m.write("進程1說：小明放學去擼串嗎？\n".encode())
time.sleep(3)
print(m.readline().decode().strip())
exit(0)
if __name__ == '__main__':
main()
進程2：
import os
import time
import mmap
def create_file(file_name, size):
with open(file_name, "wb") as f:
f.seek(size - 1)
f.write(b"\0x00")
def main():
file_name = "temp.bin"
if not os.path.exists(file_name):
# mmap映射的時候不能映射空文件，因此咱們本身建立一個
create_file(file_name, 1024)
fd = os.open(file_name, os.O_RDWR)
with mmap.mmap(fd, 0) as m: # m.resize(1024) # 大小能夠本身調整的
print("[進程2]PID:%d，PPID:%d" % (os.getpid(), os.getppid()))
time.sleep(1)
print(m.readline().decode().strip())
m.write("進程2說：爲毛不去？\n".encode())
exit(0)
if __name__ == '__main__':
main()
輸出圖示：
2.4.6.進程間通訊～Signal信號¶
代碼實例：https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/進程通訊/6.signal
信號：它是一種異步的通知機制，用來提醒進程一個事件已經發生。當一個信號發送給一個進程，操做系統中斷了進程正常的控制流程，此時，任何非原子操做都將被中斷。若是進程定義了信號的處理函數，那麼它將被執行，不然就執行默認的處理函數。
通常信號不太用於進程間通訊，經常使用就是發個信號把xxx進程乾死。
先來個例子，等會講理論：
Python裏面通常用os.kill(pid,signalnum)來發信號：eg：kill 9 pid
import os
import time
import signal
def main():
pid = os.fork()
if pid == 0:
print("[子進程]PID=%d,PPID=%d" % (os.getpid(), os.getppid()))
while True:
print("[子進程]孩子老卵，怎麼滴吧～")
time.sleep(1)
elif pid > 0:
print("[父進程]PID=%d,PPID=%d" % (os.getpid(), os.getppid()))
time.sleep(3)
print("父進程耐心有限，準備殺了兒子")
# sigkill 至關於kill 9 pid
os.kill(pid, signal.SIGKILL) # 發信號
# 收屍
wpid, status = os.wait()
print("父進程收屍：子進程PID=%d,Status=%d" % (wpid, status))
if __name__ == '__main__':
main()
輸出：
[父進程]PID=21841,PPID=5559 [子進程]PID=21842,PPID=21841 [子進程]孩子老卵，怎麼滴吧～ [子進程]孩子老卵，怎麼滴吧～ [子進程]孩子老卵，怎麼滴吧～ 父進程耐心有限，準備殺了兒子 父進程收屍：子進程PID=21842,Status=9
擴展一下：
signal.pthread_kill(thread_id,signal.SIGKILL)) # 殺死線程os.abort() # 給本身發異常終止信號
理論開始¶
這邊開始說說理論：
信號狀態：
- 產生狀態
- 未決狀態（信號產生後沒有被處理）
- 遞達狀態（信號已經傳達到進程中）
產生、傳遞等都是經過內核進行的，結合上面的例子畫個圖理解下：
未決信號集：沒有被當前進程處理的信號集合（能夠經過signal.sigpending()獲取set集合）
阻塞信號集：要屏蔽的信號（不能被用戶操做）
回顧一下上面說kill 9 pid原理的知識：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
說下經常使用的幾個信號：
- 9號信號（
sigkill）是kill 9 - 2號信號（
sigint）是Ctrl+C終止進程 - 3號信號（
sigquit）是Ctrl+\終止進程
信號捕捉¶
如今說說信號捕捉signal.signal(signalnum, handler)
handler處理函數，除了自定義信號處理函數外也可使用系統提供的兩種方式：
SIG_IGN（忽略該信號）SIG_DFL（系統默認操做）
注意一點：SIGSTOP 和 SIGKILL 信號是不能被捕獲、忽略和阻塞的（這個是系統預留的，若是連預留都沒有能夠想象確定木馬橫向）
PS:信號的優先級通常都是比較高的,每每進程收到信號後都會停下手上的事情先處理信號（死循環也同樣歇菜）
來看一個例子:(處理singint，忽略sigquit)
import os
import time
import signal
def print_info(signalnum, frame):
print("信號:%d準備弄我,我是小強我怕誰?(%s)" % (signalnum, frame))
def main():
signal.signal(signal.SIGINT, print_info) # 處理Ctrl+C的終止命令(singint)
signal.signal(signal.SIGQUIT, signal.SIG_IGN) # 忽略Ctrl+\的終止命令(sigquit)
while True:
print("[PID:%d]我很堅強,不退出,等着信號來遞達~" % os.getpid())
time.sleep(3) # 你要保證進程不會退出才能處理信號,不用擔憂影響信號（優先級高）
if __name__ == '__main__':
main()
輸出圖示:（我休息3s，在3s內給程序發送了sigint信號（Ctrl+C）就立馬處理了）
擴展：
- 若是你只是等一個信號就退出，可使用：
signal.pause()，沒必要使用死循環來輪詢了 os.killpg(pgid, sid)進程組結束signal.siginterrupt(signal.SIGALRM, False)防止系統調用被信號打斷所設立（其實通常也不太用，出問題才用）
通俗的講就是，要是系統和你發同樣的信號可能也就被處理了，加上這句就ok了，eg：
舉個例子，有時候有些惡意程序蓄意破壞或者被所謂的安全軟件誤殺好比系統函數kill(-1)【有權限的都殺了】
import signal
def print_info(signalnum, frame):
print("死前留言：我被信號%d弄死了，記得替我報仇啊！" % signalnum)
def main():
signal.signal(signal.SIGINT, print_info) # 處理Ctrl+C的終止命令(singint)
signal.signal(signal.SIGQUIT, print_info) # 處理Ctrl+\的終止命令(singquit)
signal.siginterrupt(signal.SIGINT, False)
signal.siginterrupt(signal.SIGQUIT, False)
signal.pause() # 設置一個進程到休眠狀態直到接收一個信號
if __name__ == '__main__':
main()
輸出：
dnt@MZY-PC:~/桌面/work/BaseCode/python/5.concurrent/Linux/進程通訊/6.signal python3 1.os_kill2.py ^C死前留言：我被信號2弄死了，記得替我報仇啊！ dnt@MZY-PC:~/桌面/work/BaseCode/python/5.concurrent/Linux/進程通訊/6.signal python3 1.os_kill2.py ^\死前留言：我被信號3弄死了，記得替我報仇啊！ dnt@MZY-PC:~/桌面/work/BaseCode/python/5.concurrent/Linux/進程通訊/6.signal
定時器alarm（執行一次）¶
再說兩個定時器就進下一個話題把，這個主要就是信號捕捉用得比較多，而後就是通常都是守護進程發信號
先驗證一個概念：alarm鬧鐘不能被fork後的子進程繼承
import os
import time
import signal
def main():
# 不受進程影響，每一個進程只能有一個定時器，再設置只是重置
signal.alarm(3) # 設置終止時間（3s），而後終止進程（sigaltirm）
pid = os.fork()
if pid == 0:
print("[子進程]PID=%d,PPID=%d" % (os.getpid(), os.getppid()))
for i in range(5):
print("[子進程]孩子老卵，怎麼滴吧～")
time.sleep(1)
elif pid > 0:
print("[父進程]PID=%d,PPID=%d" % (os.getpid(), os.getppid()))
print("[遺言]PID=%d,PPID=%d" % (os.getpid(), os.getppid()))
if __name__ == '__main__':
main()
輸出
[父進程]PID=9687,PPID=9063 [遺言]PID=9687,PPID=9063 [子進程]PID=9688,PPID=9687 [子進程]孩子老卵，怎麼滴吧～ [子進程]孩子老卵，怎麼滴吧～ [子進程]孩子老卵，怎麼滴吧～ [子進程]孩子老卵，怎麼滴吧～ [子進程]孩子老卵，怎麼滴吧～ [遺言]PID=9688,PPID=1060
這個你能夠本身驗證：不受進程影響，每一個進程只能有一個定時器，再設置只是重置
普及一個小技巧¶
其實好好看逆天的問題都會發現各類小技巧的，全部小技巧自我總結一下就會產生質變了
import signal
def main():
signal.alarm(1) # 設置終止時間（3s），而後終止進程（sigaltirm）
i = 0
while True:
print(i)
i += 1 # 別忘記，Python裏面沒有++哦～
if __name__ == '__main__':
main()
運行一下：time python3 xxx.py 運行一下：time python3 xxx.py > temp
簡單說下三個參數：
real總共運行時間（real=user+sys+損耗時間）user（用戶代碼真正運行時間）sys（內核運行時間）【內核不運行，你係統也不正常了】
其實就是減小了IO操做，性能方面就相差幾倍！我這邊只是一臺老電腦，要是真在服務器下性能相差可能讓你嚇一跳
如今知道爲何要realase發佈而不用debug直接部署了吧（線上項目非必要狀況，通常都會刪除全部日記輸出的）
定時器setitimer（週期執行）¶
signal.setitimer(which, seconds, interval=0.0) which參數說明：
- signal.TIMER_REAL：按實際時間計時，計時到達將給進程發送SIGALRM信號
- signal.ITIMER_VIRTUAL：僅當進程執行時才進行計時。計時到達將發送SIGVTALRM信號給進程。
- signal.ITIMER_PROF：當進程執行時和系統爲該進程執行動做時都計時。與ITIMER_VIRTUAL是一對，該定時器常常用來統計進程在用戶態和內核態花費的時間。計時到達將發送SIGPROF信號給進程。
這個通常在守護進程中常常用，看個簡單案例：
import time
import signal
def say_hai(signalnum, frame):
print("我會週期性執行哦～")
def main():
# 捕捉信號（在前面最好，否則容易漏捕獲）
signal.signal(signal.SIGALRM, say_hai)
# 設置定時器，第一次1s後執行，之後都3s執行一次
signal.setitimer(signal.ITIMER_REAL, 1, 3)
# print(signal.getitimer(signal.ITIMER_REAL))
while True:
print("我在作其餘事情")
time.sleep(1)
if __name__ == '__main__':
main()
輸出：
我在作其餘事情 我會週期性執行哦～ 我在作其餘事情 我在作其餘事情 我在作其餘事情 我會週期性執行哦～ 我在作其餘事情 我在作其餘事情 我在作其餘事情 我會週期性執行哦～ 我在作其餘事情 我在作其餘事情 我在作其餘事情 ...
2.4.7.進程守護¶
實例代碼："https://github.com/lotapp/BaseCode/tree/master/python/5.concurrent/Linux/進程守護
守護進程應用場景不少，好比程序上線後有個bug被不定時的觸發，每次都致使系統爆卡或者退出，而程序員修復bug須要時間，可是線上項目又不能掛，這時候就可使用一個心跳檢測的守護進程（查錯也可使用守護進程）【爲惡就不說了】
正式開始前，先來個僞案例：
模擬一個漏洞百出的程序
import os
import time
def main():
print("[PID:%d]進程運行中..." % os.getpid())
time.sleep(5)
os.abort() # 給本身發異常終止信號
if __name__ == '__main__':
main()
寫個簡單版本的守護進程：
import os
import time
import signal
def write_log(msg):
pass
def is_running(p_name):
"""是否在運行"""
try:
# grep -v grep 不顯示grep自己，wc -l是計數用的
result = os.popen("ps ax | grep %s | grep -v grep" % p_name).readlines()
if len(result) > 0:
return True
else:
return False
except Exception as ex:
write_log(ex)
return False
def is_restart(p_script):
"""重啓程序"""
try:
if os.system(p_script) == 0:
return True
else:
return False
except Exception as ex:
write_log(ex)
return False
def heartbeat(signalnum, frame):
"""心跳檢查"""
p_name = "test.py"
p_script = "python3 ./test.py"
if not is_running(p_name):
print("程序(%s)已掛，準備重啓" % p_name)
if not is_restart(p_script):
is_restart(p_script) # 再給一次機會
def main():
# 信號處理
signal.signal(signal.SIGALRM, heartbeat)
# 第一次1s後檢查，之後每5s檢查一次
signal.setitimer(signal.ITIMER_REAL, 1, 5)
while True:
time.sleep(5) # 不用擔憂影響signal（優先級別高）
if __name__ == '__main__':
main()
輸出：
程序(test.py)已掛，準備重啓 [PID:7270]進程運行中... Aborted (core dumped) 程序(test.py)已掛，準備重啓 [PID:7278]進程運行中... Aborted (core dumped) [PID:7284]進程運行中... .....
正規流程的守護進程¶
寫了個僞牌子的，如今說說正規的，看看概念的東西：
特色：
- 後臺服務進程
- 脫離於控制終端（setpid）
- 週期性的執行某個任務|等待某個事件發生（setitimer）
- 不受用戶登陸註銷影響（關機影響，不過你能夠添加啓動項）
- 通常使用以d結尾的服務名稱（約定俗成）
講正式流程前先複習一下上面說的進程組和會話
- 進程組：每個進程都屬於一個「進程組」，當一個進程被建立的時候，它默認是其父進程所在組的成員（大家一家）
- 會 話：幾個進程組又構成一個會話（大家小區）
須要擴充幾點：
-
進程組：
- 組長：第一個進程
- 組長ID==進程組ID
- 組長掛了不影響進程組
-
會話：
- 組長不能建立會話（你都有官了，不留點門路給後人？）
- 建立會話的進程成爲新進程組的組長（新進程組裏面就它一個嘛）
- 建立出新會話會丟棄原有的控制終端（到了新環境裏面，人脈得從新創建）
稍微驗證一下，而後步入正題：
import os
import time
def main():
pid = os.fork()
if pid == 0:
for i in range(7):
print("子進程：PID=%d,PPID=%d,PGrpID=%d" % (os.getpid(), os.getppid(), os.getpgrp()))
time.sleep(i)
elif pid > 0:
print("父進程：PID=%d,PPID=%d,PGrpID=%d" % (os.getpid(), os.getppid(), os.getpgrp()))
time.sleep(4)
print("遺言：PID=%d,PPID=%d,PGrpID=%d" % (os.getpid(), os.getppid(), os.getpgrp()))
if __name__ == '__main__':
main()
驗證結果：父進程ID==進程組ID，父進程掛了進程組依舊在，順便驗證了下ps -ajx的參數
先看看這個SessionID是啥：
import os
import time
def main():
print("進程：PID=%d,PPID=%d,PGrpID=%d" % (os.getpid(), os.getppid(), os.getpgrp()))
print(os.getsid(os.getpid()))
for i in range(1, 5):
time.sleep(i)
print("over")
if __name__ == '__main__':
main()
ps ajx的參數如今全知道了：PPID PID PGID SID (你不加grep就能看到的)
驗證一下SessionID的事情：
In [1]:
# 驗證一下父進程不能建立會話ID
import os
def main():
pid = os.getpid()
print("進程：PPID=%d,PID=%d,GID=%d,SID=%d" % (pid, os.getppid(), os.getpgrp(),os.getsid(pid)))
os.setsid() # 父進程無法設置爲會話ID的驗證
if __name__ == '__main__':
main()
步入正軌：
建立守護進程的步驟：
- fork子進程，父進程退出（子進程變成了孤兒）
- 子進程建立新會話（建立出新會話會丟棄原有的控制終端）
- 改變當前工做目錄【爲了減小bug】（eg：你在某個文件夾下運行，這個文件夾被刪了，多少會點受影響）
- 重置文件掩碼（繼承了父進程的文件掩碼，經過
umask(0)重置一下，這樣能夠獲取777權限） - 關閉文件描述符（既然用不到了，就關了）
- 本身的邏輯代碼
先簡單弄個例子實現上面步驟：
import os
import time
from sys import stdin, stdout, stderr
def main():
# 【必須】1. fork子進程，父進程退出（子進程變成了孤兒）
pid = os.fork()
if pid > 0:
exit(0)
# 【必須】2. 子進程建立新會話（建立出新會話會丟棄原有的控制終端）
os.setsid()
# 3. 改變當前工做目錄【爲了減小bug】# 改爲不會被刪掉的目錄，好比/
os.chdir("/home/dnt") # 我這邊由於是用戶建立的守護進程，就放它下面，用戶刪了，它也不必存在了
# 4. 重置文件掩碼（獲取777權限）
os.umask(0)
# 5. 關閉文件描述符（若是寫日誌也能夠重定向一下）
os.close(stdin.fileno())
os.close(stdout.fileno())
os.close(stderr.fileno())
# 【必須】6. 本身的邏輯代碼
while True:
time.sleep(1)
if __name__ == '__main__':
main()
運行效果：（直接後臺走起了）
基礎回顧¶
若是對Linux基礎不熟，能夠看看幾年前說的LinuxBase：
Linux基礎命令：http://www.cnblogs.com/dunitian/p/4822807.html
Linux系列其餘文章：http://www.javashuo.com/article/p-dojeygnv-gw.html
若是對部署運行系列不是很熟，能夠看以前寫的小demo：
用Python三、NetCore、Shell分別開發一個Ubuntu版的定時提醒（附NetCore跨平臺兩種發佈方式）：http://www.javashuo.com/article/p-wsvejssb-q.html
若是對OOP不是很熟悉能夠查看以前寫的OOP文章：
Python3 與 C# 面向對象之～封裝http://www.javashuo.com/article/p-purcxavn-d.html
Python3 與 C# 面向對象之～繼承與多態http://www.javashuo.com/article/p-ticxscaz-cv.html
Python3 與 C# 面向對象之～異常相關http://www.javashuo.com/article/p-ronmnwhu-q.html
若是基礎不牢固，能夠看以前寫的PythonBase：
Python3 與 C# 基礎語法對比（Function專欄）http://www.javashuo.com/article/p-obgfrmjz-g.html
Python3 與 C# 擴展之～模塊專欄http://www.javashuo.com/article/p-wtdazkqm-db.html
Python3 與 C# 擴展之～基礎衍生http://www.javashuo.com/article/p-tmcacaan-d.html
Python3 與 C# 擴展之～基礎拓展http://www.javashuo.com/article/p-wtppcuyx-g.html
如今正兒八經的來個簡化版的守護進程：（你能夠根據需求多加點信號處理）
import os
import time
import signal
from sys import stdin, stdout, stderr
class Daemon(object):
def __init__(self, p_name, p_script):
self.p_name = p_name
self.p_script = p_script
@staticmethod
def write_log(msg):
# 追加方式寫
with open("info.log", "a+") as f:
f.write(msg)
f.write("\n")
def is_running(self, p_name):
"""是否在運行"""
try:
# grep -v grep 不顯示grep自己，wc -l是計數用的
result = os.popen(
"ps ax | grep %s | grep -v grep" % p_name).readlines()
if len(result) > 0:
return True
else:
return False
except Exception as ex:
self.write_log(ex)
return False
def is_restart(self, p_script):
"""重啓程序"""
try:
if os.system(p_script) == 0:
return True
else:
return False
except Exception as ex:
self.write_log(ex)
return False
def heartbeat(self, signalnum, frame):
"""心跳檢查"""
if not self.is_running(self.p_name):
self.write_log("[%s]程序(%s)已掛，準備重啓" % (time.strftime("%Y-%m-%d%X"),
self.p_name))
if not self.is_restart(self.p_script):
self.is_restart(self.p_script) # 再給一次機會
def run(self):
"""運行守護進程"""
pid = os.fork()
if pid > 0:
exit(0)
os.setsid() # 子進程建立新會話
os.chdir("/home/dnt") # 改變當前工做目錄
os.umask(0) # 獲取777權限
# 5. 關閉文件描述符
os.close(stdin.fileno())
os.close(stdout.fileno())
os.close(stderr.fileno())
# 【必須】6. 本身的邏輯代碼
# 捕捉設置的定時器
signal.signal(signal.SIGALRM, self.heartbeat)
# 第一次2s後執行，之後5s執行一次
signal.setitimer(signal.ITIMER_REAL, 2, 5)
self.write_log("[%s]daeman running" % time.strftime("%Y-%m-%d%X"))
self.write_log("p_name:%s，p_script:%s" % (self.p_name, self.p_script))
while True:
time.sleep(5) # 不用擔憂影響signal（優先級別高）
def main():
try:
pro = Daemon("test.py", "python3 ~/demo/test.py")
pro.run()
except Exception as ex:
Daemon.write_log(ex)
if __name__ == '__main__':
main()
運行效果：(關閉文件描述符後就不要printf了)
擴展說明，若是你要文件描述符重定向的話能夠這麼寫：
with open("in.log", "a+") as f:
os.dup2(f.fileno(), sys.stdin.fileno())
with open("out.log", "a+") as f:
os.dup2(f.fileno(), sys.stdout.fileno())
with open("err.log", "a+") as f:
os.dup2(f.fileno(), sys.stderr.fileno())
以後你printf就自動到指定的文件了
擴展說明：¶
Socket，在講基礎最後一個系列～網絡編程的時候會講，不急，並且進程間通訊不須要這麼‘重量級’的
線程相關打算和代碼一塊兒講，有機會也能夠單獨拉出來講一個結尾篇
業餘拓展：
Other：
Linux下0、一、2號進程 https://blog.csdn.net/gatieme/article/details/51484562 https://blog.csdn.net/gatieme/article/details/51532804 https://blog.csdn.net/gatieme/article/details/51566690 Linux 的啓動流程 http://www.ruanyifeng.com/blog/2013/08/linux_boot_process.html http://www.ruanyifeng.com/blog/2016/03/systemd-tutorial-commands.html http://www.ruanyifeng.com/blog/2016/03/systemd-tutorial-part-two.html 孤兒進程與殭屍進程 https://www.cnblogs.com/Anker/p/3271773.html https://blog.csdn.net/believe_s/article/details/77040494 Python2 OS模塊之進程管理 https://www.cnblogs.com/now-fighting/p/3534185.html 緩衝區的我的理解 https://blog.csdn.net/lina_acm/article/details/51865543 深刻Python多進程編程基礎 https://zhuanlan.zhihu.com/p/37370577 https://zhuanlan.zhihu.com/p/37370601 python多進程實現進程間通訊實例 https://www.jb51.net/article/129016.htm PIPE2參考： https://bugs.python.org/file22147/posix_pipe2.diff https://stackoverflow.com/questions/30087506/event-driven-system-call-in-python https://stackoverflow.com/questions/5308080/python-socket-accept-nonblocking/5308168 FIFO參考： https://blog.csdn.net/an_tang/article/details/68951819 https://blog.csdn.net/firefoxbug/article/details/8137762 Python之mmap內存映射模塊（大文本處理）說明 https://www.cnblogs.com/zhoujinyi/p/6062907.html python 基於mmap模塊的jsonmmap實現本地多進程內存共享 https://www.cnblogs.com/dacainiao/p/5914114.html 若是把一個事務可看做是一個程序,它要麼完整的被執行,要麼徹底不執行。這種特性就叫原子性。 https://blog.csdn.net/Android_Mrchen/article/details/77866490 事務四大特徵：原子性，一致性，隔離性和持久性 https://blog.csdn.net/u014079773/article/details/52808193 python 、mmap 實現內存數據共享 https://www.jianshu.com/p/c3afc0f02560 http://www.cnblogs.com/zhoujinyi/p/6062907.html https://blog.csdn.net/zhaohongyan6/article/details/71158522 Python信號相關： https://my.oschina.net/guol/blog/136036 Linux--進程組、會話、守護進程 https://www.cnblogs.com/forstudy/archive/2012/04/03/2427683.html
相關文章
- 1. Python3 與 C# 併發編程之～ Net篇
- 2. Python3 與 C# 併發編程之～ 進程篇
- 3. Python3 與 C# 併發編程之～ 協程篇
- 4. 併發編程之進程與線程
- 5. python之併發編程進階篇9
- 6. Python3併發編程之線程池/進程池--concurrent.futures模塊
- 7. Java 併發編程之美：併發編程高級篇之三
- 8. python3之線程與進程
- 9. （一）併發編程：進程與線程
- 10. 併發編程(進程與線程)
- 更多相關文章...
- • Rust 併發編程 - RUST 教程
- • C# 多線程 - C#教程
- • Java 8 Stream 教程
- • Github 簡明教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
