python子進程

A. 關於python子進程之間的數據交換，使用multiprocessing庫。

跟GET/POST方式接受表單數據沒什麼區別。請仔細查看所使用的web框架的文檔。

B. python可以多進程嗎

想要充分利用多核CPU資源，Python中大部分情況下都需要使用多進程，Python中提供了multiprocessing這個包實現多進程。multiprocessing支持子進程、進程間的同步與通信，提供了Process、Queue、Pipe、Lock等組件。

開辟子進程
multiprocessing中提供了Process類來生成進程實例

Process([group [, target [, name [, args [, kwargs]]]]])
group分組，實際上不使用
target表示調用對象，你可以傳入方法的名字
args表示給調用對象以元組的形式提供參數，比如target是函數a，他有兩個參數m，n，那麼該參數為args=(m, n)即可
kwargs表示調用對象的字典
name是別名，相當於給這個進程取一個名字
先來個小例子：

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #獲取當前進程號和正在運行是的時間
time.sleep(wTime) #等待（休眠）
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,)) #申請子進程
p.start() #運行進程
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
運行結果：

Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017

根據運行結果可知，父進程運行結束後子進程仍然還在運行，這可能造成僵屍（ zombie）進程。

通常情況下，當子進程終結時，它會通知父進程，清空自己所佔據的內存，並在內核里留下自己的退出信息。父進程在得知子進程終結時，會從內核中取出子進程的退出信息。但是，如果父進程早於子進程終結，這可能造成子進程的退出信息滯留在內核中，子進程成為僵屍（zombie）進程。當大量僵屍進程積累時，內存空間會被擠占。

有什麼辦法可以避免僵屍進程呢？
這里介紹進程的一個屬性 deamon，當其值為TRUE時，其父進程結束，該進程也直接終止運行（即使還沒運行完）。
所以給上面的程序加上p.deamon = true，看看效果。

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
time.sleep(wTime)
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,))
p.daemon = True #加入daemon
p.start()
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
執行結果：

Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017

這是問題又來了，子進程並沒有執行完，這不是所期望的結果。有沒辦法將子進程執行完後才讓父進程結束呢？
這里引入p.join()方法，它使子進程執行結束後，父進程才執行之後的代碼

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
time.sleep(wTime)
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,))
p.daemon = True
p.start()
p.join() #加入join方法
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
執行結果：

subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017

這樣所有的進程就能順利的執行了。

C. Python中進程與線程的區別是什麼

Num01–>線程

線程是操作系統中能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。

一個線程指的是進程中一個單一順序的控制流。

一個進程中可以並發多條線程，每條線程並行執行不同的任務。

Num02–>進程

進程就是一個程序在一個數據集上的一次動態執行過程。

進程有以下三部分組成：

1，程序：我們編寫的程序用來描述進程要完成哪些功能以及如何完成。
2，數據集：數據集則是程序在執行過程中需要的資源，比如圖片、音視頻、文件等。
3，進程式控制制塊：進程式控制制塊是用來記錄進程的外部特徵，描述進程的執行變化過程，系統可以用它來控制和管理進程，它是系統感知進程存在的唯一標記。

Num03–>進程和線程的區別：

1、運行方式不同：

進程不能單獨執行，它只是資源的集合。

進程要操作CPU，必須要先創建一個線程。

所有在同一個進程里的線程，是同享同一塊進程所佔的內存空間。

2，關系

進程中第一個線程是主線程，主線程可以創建其他線程；其他線程也可以創建線程；線程之間是平等的。

進程有父進程和子進程，獨立的內存空間，唯一的標識符：pid。

3，速度

啟動線程比啟動進程快。

運行線程和運行進程速度上是一樣的，沒有可比性。

線程共享內存空間，進程的內存是獨立的。

4，創建

父進程生成子進程，相當於復制一份內存空間，進程之間不能直接訪問

創建新線程很簡單，創建新進程需要對父進程進行一次復制。

一個線程可以控制和操作同級線程里的其他線程，但是進程只能操作子進程。

5，交互

同一個進程里的線程之間可以直接訪問。

兩個進程想通信必須通過一個中間代理來實現。

相關推薦：《Python視頻教程》

Num04–>幾個常見的概念

1，什麼的並發和並行？

並發：微觀上CPU輪流執行，宏觀上用戶看到同時執行。因為cpu切換任務非常快。

並行：是指系統真正具有同時處理多個任務（動作）的能力。

2，同步、非同步和輪詢的區別？

同步任務：B一直等著A，等A完成之後，B再執行任務。(打電話案例)

輪詢任務：B沒有一直等待A，B過一會來問一下A，過一會問下A

非同步任務：B不需要一直等著A, B先做其他事情，等A完成後A通知B。（發簡訊案例）

Num05–>進程和線程的優缺點比較

首先，要實現多任務，通常我們會設計Master-Worker模式，Master負責分配任務，Worker負責執行任務，因此，多任務環境下，通常是一個Master，多個Worker。

如果用多進程實現Master-Worker，主進程就是Master，其他進程就是Worker。

如果用多線程實現Master-Worker，主線程就是Master，其他線程就是Worker。

多進程模式最大的優點就是穩定性高，因為一個子進程崩潰了，不會影響主進程和其他子進程。（當然主進程掛了所有進程就全掛了，但是Master進程只負責分配任務，掛掉的概率低）著名的Apache最早就是採用多進程模式。

多進程模式的缺點是創建進程的代價大，在Unix/linux系統下，用fork調用還行，在Windows下創建進程開銷巨大。另外，操作系統能同時運行的進程數也是有限的，在內存和CPU的限制下，如果有幾千個進程同時運行，操作系統連調度都會成問題。

多線程模式通常比多進程快一點，但是也快不到哪去，而且，多線程模式致命的缺點就是任何一個線程掛掉都可能直接造成整個進程崩潰，因為所有線程共享進程的內存。在Windows上，如果一個線程執行的代碼出了問題，你經常可以看到這樣的提示：「該程序執行了非法操作，即將關閉」，其實往往是某個線程出了問題，但是操作系統會強制結束整個進程。

在Windows下，多線程的效率比多進程要高，所以微軟的IIS伺服器默認採用多線程模式。由於多線程存在穩定性的問題，IIS的穩定性就不如Apache。為了緩解這個問題，IIS和Apache現在又有多進程+多線程的混合模式，真是把問題越搞越復雜。

Num06–>計算密集型任務和IO密集型任務

是否採用多任務的第二個考慮是任務的類型。我們可以把任務分為計算密集型和IO密集型。

第一種：計算密集型任務的特點是要進行大量的計算，消耗CPU資源，比如計算圓周率、對視頻進行高清解碼等等，全靠CPU的運算能力。這種計算密集型任務雖然也可以用多任務完成，但是任務越多，花在任務切換的時間就越多，CPU執行任務的效率就越低，所以，要最高效地利用CPU，計算密集型任務同時進行的數量應當等於CPU的核心數。

計算密集型任務由於主要消耗CPU資源，因此，代碼運行效率至關重要。Python這樣的腳本語言運行效率很低，完全不適合計算密集型任務。對於計算密集型任務，最好用C語言編寫。

第二種：任務的類型是IO密集型，涉及到網路、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和內存的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。常見的大部分任務都是IO密集型任務，比如Web應用。

IO密集型任務執行期間，99%的時間都花在IO上，花在CPU上的時間很少，因此，用運行速度極快的C語言替換用Python這樣運行速度極低的腳本語言，完全無法提升運行效率。對於IO密集型任務，最合適的語言就是開發效率最高（代碼量最少）的語言，腳本語言是首選，C語言最差。

相關推薦：

Python中的進程是什麼

D. 如何在python腳本中新建一個守護子進程

函數實現
[html] view plain
#!/usr/bin/env python
#coding: utf-8
import sys, os

'''將當前進程fork為一個守護進程
注意：如果你的守護進程是由inetd啟動的，不要這樣做！inetd完成了
所有需要做的事情，包括重定向標准文件描述符，需要做的事情只有chdir()和umask()了
'''

def daemonize (stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
#重定向標准文件描述符（默認情況下定向到/dev/null）
try:
pid = os.fork()
#父進程(會話組頭領進程)退出，這意味著一個非會話組頭領進程永遠不能重新獲得控制終端。
if pid > 0:
sys.exit(0) #父進程退出
except OSError, e:
sys.stderr.write ("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror) )
sys.exit(1)

#從母體環境脫離
os.chdir("/") #chdir確認進程不保持任何目錄於使用狀態，否則不能umount一個文件系統。也可以改變到對於守護程序運行重要的文件所在目錄
os.umask(0) #調用umask(0)以便擁有對於寫的任何東西的完全控制，因為有時不知道繼承了什麼樣的umask。
os.setsid() #setsid調用成功後，進程成為新的會話組長和新的進程組長，並與原來的登錄會話和進程組脫離。

#執行第二次fork
try:
pid = os.fork()
if pid > 0:
sys.exit(0) #第二個父進程退出
except OSError, e:
sys.stderr.write ("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror) )
sys.exit(1)

#進程已經是守護進程了，重定向標准文件描述符

for f in sys.stdout, sys.stderr: f.flush()
si = open(stdin, 'r')
so = open(stdout, 'a+')
se = open(stderr, 'a+', 0)
os.p2(si.fileno(), sys.stdin.fileno()) #p2函數原子化關閉和復制文件描述符
os.p2(so.fileno(), sys.stdout.fileno())
os.p2(se.fileno(), sys.stderr.fileno())

#示例函數：每秒列印一個數字和時間戳
def main():
import time
sys.stdout.write('Daemon started with pid %d\n' % os.getpid())
sys.stdout.write('Daemon stdout output\n')
sys.stderr.write('Daemon stderr output\n')
c = 0
while True:
sys.stdout.write('%d: %s\n' %(c, time.ctime()))
sys.stdout.flush()
c = c+1
time.sleep(1)

if __name__ == "__main__":
daemonize('/dev/null','/tmp/daemon_stdout.log','/tmp/daemon_error.log')
main()
可以通過命令ps -ef | grep daemon.py查看後台運行的繼承，在/tmp/daemon_error.log會記錄錯誤運行日誌，在/tmp/daemon_stdout.log會記錄標准輸出日誌。

E. python子進程怎麼傳參

def sum（x,y）:
return x+y

def sub (x,y):
return x-y

def jieguo(x,y):
print(「和值：」，sum（x,y）)
Print("差值："，sub(x,y))
jieguo（45，22）
#sum函數，sub函數 分別是jieguo函數的子函數。
用return 就可以啦

F. python有什麼辦法可讓子進程正常結束主進程

os.system的返回值是運行結果，用p命名沒什麼意義，建議用Popen比較好控制，例如 import subprocessa = subprocess.Popen('dir',shell = True)然後就可以用a.kill()來殺進程

G. 如何將調試器附加到python子進程

從「調試」菜單中選擇「附加到進程」。（如果沒有打開任何項目，請從「工具」菜單中選擇「附加到進程」。）
在「附加到進程」對話框的「可用進程」列表中，找到要附加到的程序。
如果要調試的程序運行在另一台計算器上，必須首先選擇該遠程計算機。（有關更多信息，請參見
。）如果進程在其他用戶帳戶下運行，請選中「顯示來自所有用戶的進程」框。
如果已通過「遠程桌面連接」連接，請選中「顯示所有會話中的進程」框。
在「附加到」框中，確保要調試的代碼類型已列出，或「自動: 託管代碼」已顯示。否則：
單擊「選擇」。
在「選擇代碼類型」對話框中，單擊「調試以下代碼類型」，然後選擇要調試的類型。
單擊「確定」。
單擊「附加」按鈕。
打開「進程」對話框時，會自動顯示「可用進程」列表。對話框打開時進程仍能在後台中開始和停止，因此內容可能並非始終是最新內容。通過按「刷新」，可以隨時刷新列表以查看當前進程列表。
調試時可以附加到多個程序，但在任何給定時間，調試器中只有一個程序處於活動狀態。可以在「調試位置」工具欄中設置活動程序。有關更多信息，請參見
所有的「調試」菜單執行命令都會影響活動程序。可以通過「進程」對話框中斷任何已調試的程序。有關更多信息，請參見
注意為使調試器附加到用 Visual C++ 編寫的代碼，該代碼需要發出
DebuggableAttribute
。可通過鏈接
/ASSEMBLYDEBUG
鏈接器選項將它自動添加到代碼中。
注意如果試圖附加到不受信任的用戶帳戶擁有的進程，則會出現安全警告對話框確認。有關更多信息，請參見
安全警告：附加到不受信任的進程可能會有危險。
注意在某些情況下，在「終端服務」（「遠程桌面」）會話中進行調試時，「可用進程」列表不會顯示所有可用進程。在 Windows Server 2003 或更高版本上，如果您以受限用戶身份運行 Visual Studio，則「可用進程」列表不會顯示在會話 0 中運行的進程，會話 0 用於服務以及包括 w3wp.exe 在內的其他伺服器進程。您可以通過以下方法解決該問題：使用管理員帳戶運行 Visual Studio 或從伺服器控制台而不是「終端服務」會話運行 Visual Studio。如果這兩種解決方法都不奏效，第三種方法是通過從 Windows 命令行運行
vsjitdebugger.exe -pProcessId來附加到進程。您可以使用 tlist.exe 來確定進程 ID。

H. python，子進程Process()中的print()沒有列印結果，什麼原因

IDLE不能顯示子進程（調用Process的子進程）列印的信息。
解決辦法1：直接把.py文件拖入cmd命令窗口，用cmd命令窗口運行Python程序
解決辦法2：安裝PyCharm，在PyCharm中運行
以上兩種方法都不能列印進程池Pool調用apply_async方法執行的子進程的信息

I. python中怎麼判斷子進程和父進程

python執行ps -ef | grep XXX XXX為你的進程，當有返回值的時候，說明你的進程存在，python檢查系統進程其實調用的也是linux的shell

J. python fork子進程執行完需要怎麼處理

（代碼驗證） fork確實創建了一個子進程並完全復制父進程，但是子進程是從fork後面那個指令開始執行的。
對於原因也很合邏輯，如果子進程也從main開頭到尾執行所有指令，那它執行到fork指令時也必定會創建一個子子進程，如此下去這個小小的程序就可以創建無數多個進程可以把你的電腦搞癱瘓,所以fork作者肯定不會傻到這種程度fork和線程，進程的理解2011-10-11 10:09 本文分為三部分：1. 什麼是fork？2. fork用途？3. fork怎麼工作？ 1． 什麼是fork?Fork源於OS中多線程任務的需要。在傳統的Unix環境下，有兩個基本的操作用於創建和修改進程：函數fork( )用來創建一個新的進程，該進程幾乎是當前進程的一個完全拷貝；函數族exec( )用來啟動另外的進程以取代當前運行的進程。下面說一下進程和線程。進程的簡單理解就是：一個進程表示的就是一個可執行程序的一次執行過程中的一個狀態。一個進程，主要包含三個元素：一個可以執行的程序； --- 代碼段
和該進程相關聯的全部數據（包括變數，內存空間，緩沖區等等）； --- 數據段
程序的執行上下文（execution context）。 --- 堆棧段 "代碼段"，顧名思義，就是存放了程序代碼的數據，假如機器中有數個進程運行相同的一個程序，那麼它們就可以使用相同的代碼段。"堆棧段"存放的就是子程序的返回地址、子程序的參數以及程序的局部變數。而數據段則存放程序的全局變數，常數以及動態數據分配的數據空間（比如用malloc之類的函數取得的空間）。 一般的CPU都有上述三種段寄存器，以方便操作系統的運行