A. 一文帶你讀懂python中的進程
進程
進程（Process）是計算機中的程序關於某數據集合上的一次運行，即正在運行的程序，是系統進行資源分配和調度的基本單位，進程是對正在運行程序的一個抽象，在早期面向進程設計的計算機結構中，進程是程序的基本執行實體，在當代面向線程設計的計算機結構中，進程是線程的容器，線程是執行的實體。進程的概念起源於操作系統，是操作系統最核心的概念，操作系統的其他所有內容都是圍繞進程的概念展開的。
在早期計算機中可以利用的cpu只有一個，為了充分利用CPU性能，提高用戶操作體驗，出現了多道技術。將一個單獨的cpu虛擬成多個cpu（多道技術：時間多路復用和空間多路復用+硬體上支持隔離），即使在一個單核CPU也能保證支持（偽）並發的能力。如果沒有進程的抽象，現代計算機將不復存在。
狹義定義：進程是正在運行的程序的實例（an instance of a computer program that is being executed）。
廣義定義：進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動。它是操作系統動態執行的基本單元，在傳統的操作系統中，進程既是基本的分配單元，也是基本的執行單元。
操作系統的作用：
隱藏復雜的硬體介面，提供良好的抽象介面。
管理、調度進程，使多個進程對硬體的競爭變得有序。
多道技術：針對早期單核CPU，實現多個程序的並發執行，現在的主機一般是多核，每個核都會利用多道技術，如有4個cpu，運行於cpu1的某個程序遇到io阻塞，會等到io結束再重新調度，重新調度是可能會被調度到4個cpu中的任意一個，具體由操作系統調度演算法決定。
多道技術的主要特性如下：
（1）空間上的復用：內存中可以同時有多道程序。
（2）物理隔離：多個程序在內存中都有各自獨立的內存空間，互不影響。
（3）時間上的復用：多個程序在操作系統的調度演算法下，在不同的時間段內分別佔有CPU資源。
需要注意的是如果一個進程長時間佔用CPU資源，操作系統會強制將CPU資源分配給其它在就緒隊列中的程序，避免一個程序長時間佔有CPU資源，導致其它程序無法運行。
相關推薦：《Python視頻教程》
關於進程的一些概念：
第一，進程是一個實體。每一個進程都有它自己的地址空間，一般情況下，包括文本區域（text region）、數據區域（data region）和堆棧（stack region）。文本區域存儲處理器執行的代碼，數據區域存儲變數和進程執行期間使用的動態分配的內存，堆棧區域存儲著活動過程調用的指令和本地變數。
第二，進程是一個「執行中的程序」。程序是一個沒有生命的實體，只有處理器賦予程序生命時（操作系統將程序載入到內存），它才能成為一個活動的實體，我們稱其為進程。
進程是操作系統中最基本、重要的概念。是多道程序系統出現後，為了刻畫系統內部出現的動態情況，描述系統內部各道程序的活動規律引進的一個概念，所有多道程序設計操作系統都建立在進程的基礎上。
進程的特性：
動態性：進程的實質是程序在多道程序系統中的一次執行過程，進程是動態產生，動態消亡的。
並發性：任何進程都可以同其他進程一起並發執行
獨立性：進程是一個能獨立運行的基本單位，同時也是系統分配資源和調度的獨立單位；
非同步性：由於進程間的相互制約，使進程具有執行的間斷性，即進程按各自獨立的、不可預知的速度向前推進
結構特徵：進程由程序、數據和進程式控制制塊三部分組成。
多個不同的進程可以包含相同的程序，一個程序在不同的數據集里就構成不同的進程，能得到不同的結果，但是執行過程中，程序不能發生改變。
進程與程序的區別：
程序是指令和數據的有序集合，是對指令、數據及其組織形式的描述，其本身沒有任何運行的含義，是一個靜態的概念。而進程是程序在處理機上的一次執行過程，它是一個動態的概念。
程序可以作為一種軟體資料長期存在，而進程是有一定生命期的。程序是永久的，進程是暫時的。
進程的調度：
要想多個進程交替運行，操作系統必須對這些進程進行調度，這個調度也不是隨機進行的，而是需要遵循一定的法則，由此就有了進程的調度演算法。
1、先來先服務演算法
先來先服務（FCFS）調度演算法是一種最簡單的調度演算法，該演算法既可用於作業調度，也可用於進程調度。FCFS演算法比較有利於長作業（進程），而不利於短作業（進程）。由此可知，本演算法適合於CPU繁忙型作業，而不利於I/O繁忙型的作業（進程）。
2、短作業優先調度演算法
短作業（進程）優先調度演算法（SJ/PF）是指對短作業或短進程優先調度的演算法，該演算法既可用於作業調度，也可用於進程調度。但其對長作業不利；不能保證緊迫性作業（進程）被及時處理；作業的長短只是被估算出來的。
3、時間片輪轉法
時間片輪轉(Round Robin，RR)法的基本思路是讓每個進程在就緒隊列中的等待時間與享受服務的時間成比例。在時間片輪轉法中，需要將CPU的處理時間分成固定大小的時間片，例如，幾十毫秒至幾百毫秒。如果一個進程在被調度選中之後用完了系統規定的時間片，但又未完成要求的任務，則它自行釋放自己所佔有的CPU而排到就緒隊列的末尾，等待下一次調度。同時，進程調度程序又去調度當前就緒隊列中的第一個進程。
顯然，輪轉法只能用來調度分配一些可以搶占的資源。這些可以搶占的資源可以隨時被剝奪，而且可以將它們再分配給別的進程。CPU是可搶占資源的一種。但列印機等資源是不可搶占的。由於作業調度是對除了CPU之外的所有系統硬體資源的分配，其中包含有不可搶占資源，所以作業調度不使用輪轉法。
在輪轉法中，時間片長度的選取非常重要。首先，時間片長度的選擇會直接影響到系統的開銷和響應時間。如果時間片長度過短，則調度程序搶占處理機的次數增多。這將使進程上下文切換次數也大大增加，從而加重系統開銷。反過來，如果時間片長度選擇過長，例如，一個時間片能保證就緒隊列中所需執行時間最長的進程能執行完畢，則輪轉法變成了先來先服務法。時間片長度的選擇是根據系統對響應時間的要求和就緒隊列中所允許最大的進程數來確定的。
在輪轉法中，加入到就緒隊列的進程有3種情況：
（1）一種是分給它的時間片用完，但進程還未完成，回到就緒隊列的末尾等待下次調度去繼續執行。
（2）另一種情況是分給該進程的時間片並未用完，只是因為請求I/O或由於進程的互斥與同步關系而被阻塞。當阻塞解除之後再回到就緒隊列。
（3）第三種情況就是新創建進程進入就緒隊列。
如果對這些進程區別對待，給予不同的優先順序和時間片從直觀上看，可以進一步改善系統服務質量和效率。例如，我們可把就緒隊列按照進程到達就緒隊列的類型和進程被阻塞時的阻塞原因分成不同的就緒隊列，每個隊列按FCFS原則排列，各隊列之間的進程享有不同的優先順序，但同一隊列內優先順序相同。這樣，當一個進程在執行完它的時間片之後，或從睡眠中被喚醒以及被創建之後，將進入不同的就緒隊列。
多級反饋隊列：
前面介紹的各種用作進程調度的演算法都有一定的局限性。如短進程優先的調度演算法，僅照顧了短進程而忽略了長進程，而且如果並未指明進程的長度，則短進程優先和基於進程長度的搶占式調度演算法都將無法使用。
而多級反饋隊列調度演算法則不必事先知道各種進程所需的執行時間，而且還可以滿足各種類型進程的需要，因而它是目前被公認的一種較好的進程調度演算法。在採用多級反饋隊列調度演算法的系統中，調度演算法的實施過程如下所述。
(1) 應設置多個就緒隊列，並為各個隊列賦予不同的優先順序。第一個隊列的優先順序最高，第二個隊列次之，其餘各隊列的優先權逐個降低。該演算法賦予各個隊列中進程執行時間片的大小也各不相同，在優先權愈高的隊列中，為每個進程所規定的執行時間片就愈小。例如，第二個隊列的時間片要比第一個隊列的時間片長一倍，……，第i+1個隊列的時間片要比第i個隊列的時間片長一倍。
(2) 當一個新進程進入內存後，首先將它放入第一隊列的末尾，按FCFS原則排隊等待調度。當輪到該進程執行時，如它能在該時間片內完成，便可准備撤離系統；如果它在一個時間片結束時尚未完成，調度程序便將該進程轉入第二隊列的末尾，再同樣地按FCFS原則等待調度執行；如果它在第二隊列中運行一個時間片後仍未完成，再依次將它放入第三隊列，……，如此下去，當一個長作業(進程)從第一隊列依次降到第n隊列後，在第n 隊列便採取按時間片輪轉的方式運行。
(3) 僅當第一隊列空閑時，調度程序才調度第二隊列中的進程運行；僅當第1～(i-1)隊列均空時，才會調度第i隊列中的進程運行。如果處理機正在第i隊列中為某進程服務時，又有新進程進入優先權較高的隊列(第1～(i-1)中的任何一個隊列)，則此時新進程將搶占正在運行進程的處理機，即由調度程序把正在運行的進程放回到第i隊列的末尾，把處理機分配給新到的高優先權進程。
B. Python 進程，線程，協程，鎖機制，你知多少
1.線程和進程：
線程是屬於進程的，線程運行在進程空間內，同一進程所產生的線程共享同一內存空間，當進程退出時該進程所產生的線程都會被強制退出並清除。線程可與屬於同一進程的其它線程共享進程所擁有的全部資源，但是其本身基本上不擁有系統資源，只擁有一點在運行中必不可少的信息(如程序計數器、一組寄存器和棧)。
2.線程、進程與協程：
線程和進程的操作是由程序觸發系統介面，最後的執行者是系統；協程的操作則是程序員
協程存在的意義：對於多線程應用，CPU通過切片的方式來切換線程間的執行，線程切換時需要耗時（保持狀態，下次繼續）。協程，則只使用一個線程，在一個線程中規定某個代碼塊執行順序。
協程的適用場景： 當程序中存在大量不需要CPU的操作時（IO），適用於協程；
C. python 進程池當一個進程報錯時，別的進程有影響嗎
Python提供了非常好用的多進程包multiprocessing，你只需要定義一個函數，Python會替你完成其他所有事情。
藉助這個包，可以輕松完成從單進程到並發執行的轉換。
1、新建單一進程
如果我們新建少量進程，可以如下：
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if __name__ == "__main__":
p = multiprocessing.Process(target=func, args=("hello", ))
p.start()
p.join()
print "Sub-process done."12345678910111213
2、使用進程池
是的，你沒有看錯，不是線程池。它可以讓你跑滿多核CPU，而且使用方法非常簡單。
注意要用apply_async，如果落下async，就變成阻塞版本了。
processes=4是最多並發進程數量。
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if __name__ == "__main__":
pool = multiprocessing.Pool(processes=4)
for i in xrange(10):
msg = "hello %d" %(i)
pool.apply_async(func, (msg, ))
pool.close()
pool.join()
print "Sub-process(es) done."12345678910111213141516
3、使用Pool，並需要關注結果
更多的時候，我們不僅需要多進程執行，還需要關注每個進程的執行結果，如下：
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
return "done " + msg
if __name__ == "__main__":
pool = multiprocessing.Pool(processes=4)
result = []
for i in xrange(10):
msg = "hello %d" %(i)
result.append(pool.apply_async(func, (msg, )))
pool.close()
pool.join()
for res in result:
print res.get()
print "Sub-process(es) done."
2014.12.25更新
根據網友評論中的反饋，在Windows下運行有可能崩潰(開啟了一大堆新窗口、進程)，可以通過如下調用來解決：
multiprocessing.freeze_support()1
附錄（自己的腳本）：
#!/usr/bin/python
import threading
import subprocess
import datetime
import multiprocessing
def dd_test(round, th):
test_file_arg = 'of=/zbkc/test_mds_crash/1m_%s_%s_{}' %(round, th)
command = "seq 100 | xargs -i dd if=/dev/zero %s bs=1M count=1" %test_file_arg
print command
subprocess.call(command,shell=True,stdout=open('/dev/null','w'),stderr=subprocess.STDOUT)
def mds_stat(round):
p = subprocess.Popen("zbkc mds stat", shell = True, stdout = subprocess.PIPE)
out = p.stdout.readlines()
if out[0].find('active') != -1:
command = "echo '0205pm %s round mds status OK, %s' >> /round_record" %(round, datetime.datetime.now())
command_2 = "time (ls /zbkc/test_mds_crash/) 2>>/round_record"
command_3 = "ls /zbkc/test_mds_crash | wc -l >> /round_record"
subprocess.call(command,shell=True)
subprocess.call(command_2,shell=True)
subprocess.call(command_3,shell=True)
return 1
else:
command = "echo '0205 %s round mds status abnormal, %s, %s' >> /round_record" %(round, out[0], datetime.datetime.now())
subprocess.call(command,shell=True)
return 0
#threads = []
for round in range(1, 1600):
pool = multiprocessing.Pool(processes = 10) #使用進程池
for th in range(10):
# th_name = "thread-" + str(th)
# threads.append(th_name) #添加線程到線程列表
# threading.Thread(target = dd_test, args = (round, th), name = th_name).start() #創建多線程任務
pool.apply_async(dd_test, (round, th))
pool.close()
pool.join()
#等待線程完成
# for t in threads:
# t.join()
if mds_stat(round) == 0:
subprocess.call("zbkc -s",shell=True)
break
D. Python中進程和線程的區別詳解
什麼是進程（Process）：普通的解釋就是，進程是程序的一次執行，而什麼是線程（Thread），線程可以理解為進程中的執行的一段程序片段。在一個多任務環境中下面的概念可以幫助我們理解兩者間的差別：進程間是獨立的，這表現在內存空間，上下文環境；線程運行在進程空間內。 一般來講（不使用特殊技術）進程是無法突破進程邊界存取其他進程內的存儲空間；而線程由於處於進程空間內，所以同一進程所產生的線程共享同一內存空間。同一進程中的兩段代碼不能夠同時執行，除非引入線程。線程是屬於進程的，當進程退出時該進程所產生的線程都會被強制退出並清除。線程佔用的資源要少於進程所佔用的資源。進程和線程都可以有優先順序。在線程系統中進程也是一個線程。可以將進程理解為一個程序的第一個線程。
線程是指進程內的一個執行單元,也是進程內的可調度實體.與進程的區別:(1)地址空間:進程內的一個執行單元;進程至少有一個線程;它們共享進程的地址空間;而進程有自己獨立的地址空間;(2)進程是資源分配和擁有的單位,同一個進程內的線程共享進程的資源(3)線程是處理器調度的基本單位,但進程不是.(4)二者均可並發執行.
E. python多進程pipe在windows中能用嗎
Python提供了非常好用的多進程包multiprocessing，你只需要定義一個函數，Python會替你完成其他所有事情。藉助這個包，可以輕松完成從單進程到並發執行的轉換。
1、新建單一進程
如果我們新建少量進程，可以如下：
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if __name__ == "__main__":
p = multiprocessing.Process(target=func, args=("hello", ))
p.start()
p.join()
print "Sub-process done."12345678910111213
F. 小白都看懂了，Python 中的線程和進程精講，建議收藏
目錄
眾所周知，CPU是計算機的核心，它承擔了所有的計算任務。而操作系統是計算機的管理者，是一個大管家，它負責任務的調度，資源的分配和管理，統領整個計算機硬體。應用程序是具有某種功能的程序，程序運行與操作系統之上
在很早的時候計算機並沒有線程這個概念，但是隨著時代的發展，只用進程來處理程序出現很多的不足。如當一個進程堵塞時，整個程序會停止在堵塞處，並且如果頻繁的切換進程，會浪費系統資源。所以線程出現了
線程是能擁有資源和獨立運行的最小單位，也是程序執行的最小單位。一個進程可以擁有多個線程，而且屬於同一個進程的多個線程間會共享該進行的資源
① 200 多本 Python 電子書（和經典的書籍）應該有
② Python標准庫資料（最全中文版）
③ 項目源碼（四五十個有趣且可靠的練手項目及源碼）
④ Python基礎入門、爬蟲、網路開發、大數據分析方面的視頻（適合小白學習）
⑤ Python學習路線圖（告別不入流的學習）
私信我01即可獲取大量Python學習資源
進程時一個具有一定功能的程序在一個數據集上的一次動態執行過程。進程由程序，數據集合和進程式控制制塊三部分組成。程序用於描述進程要完成的功能，是控制進程執行的指令集；數據集合是程序在執行時需要的數據和工作區；程序控制塊（PCB）包含程序的描述信息和控制信息，是進程存在的唯一標志
在Python中，通過兩個標准庫 thread 和 Threading 提供對線程的支持, threading 對 thread 進行了封裝。 threading 模塊中提供了 Thread , Lock , RLOCK , Condition 等組件
在Python中線程和進程的使用就是通過 Thread 這個類。這個類在我們的 thread 和 threading 模塊中。我們一般通過 threading 導入
默認情況下，只要在解釋器中，如果沒有報錯，則說明線程可用
守護模式：
現在我們程序代碼中，有多個線程， 並且在這個幾個線程中都會去 操作同一部分內容，那麼如何實現這些數據的共享呢？
這時，可以使用 threading庫裡面的鎖對象 Lock 去保護
Lock 對象的acquire方法 是申請鎖
每個線程在操作共享數據對象之前，都應該申請獲取操作權，也就是調用該共享數據對象對應的鎖對象的acquire方法，如果線程A 執行了 acquire() 方法，別的線程B 已經申請到了這個鎖， 並且還沒有釋放，那麼 線程A的代碼就在此處 等待 線程B 釋放鎖，不去執行後面的代碼。
直到線程B 執行了鎖的 release 方法釋放了這個鎖， 線程A 才可以獲取這個鎖，就可以執行下面的代碼了
如：
到在使用多線程時，如果數據出現和自己預期不符的問題，就可以考慮是否是共享的數據被調用覆蓋的問題
使用 threading 庫裡面的鎖對象 Lock 去保護
Python中的多進程是通過multiprocessing包來實現的，和多線程的threading.Thread差不多，它可以利用multiprocessing.Process對象來創建一個進程對象。這個進程對象的方法和線程對象的方法差不多也有start(), run(), join()等方法，其中有一個方法不同Thread線程對象中的守護線程方法是setDeamon，而Process進程對象的守護進程是通過設置daemon屬性來完成的
守護模式：
其使用方法和線程的那個 Lock 使用方法類似
Manager的作用是提供多進程共享的全局變數，Manager()方法會返回一個對象，該對象控制著一個服務進程，該進程中保存的對象運行其他進程使用代理進行操作
語法：
線程池的基類是 concurrent.futures 模塊中的 Executor ， Executor 提供了兩個子類，即 ThreadPoolExecutor 和 ProcessPoolExecutor ，其中 ThreadPoolExecutor 用於創建線程池，而 ProcessPoolExecutor 用於創建進程池
如果使用線程池/進程池來管理並發編程，那麼只要將相應的 task 函數提交給線程池/進程池，剩下的事情就由線程池/進程池來搞定
Exectuor 提供了如下常用方法：
程序將 task 函數提交（submit）給線程池後，submit 方法會返回一個 Future 對象，Future 類主要用於獲取線程任務函數的返回值。由於線程任務會在新線程中以非同步方式執行，因此，線程執行的函數相當於一個「將來完成」的任務，所以 Python 使用 Future 來代表
Future 提供了如下方法：
使用線程池來執行線程任務的步驟如下：
最佳線程數目 = （（線程等待時間+線程CPU時間）/線程CPU時間 ）* CPU數目
也可以低於 CPU 核心數
使用線程池來執行線程任務的步驟如下：
關於進程的開啟代碼一定要放在 if __name__ == '__main__': 代碼之下，不能放到函數中或其他地方
開啟進程的技巧
開啟進程的數量最好低於最大 CPU 核心數
G. python怎麼實現一個進程
想要充分利用多核CPU資源，Python中大部分情況下都需要使用多進程，Python中提供了multiprocessing這個包實現多進程。multiprocessing支持子進程、進程間的同步與通信，提供了Process、Queue、Pipe、Lock等組件。
開辟子進程
multiprocessing中提供了Process類來生成進程實例
Process([group [, target [, name [, args [, kwargs]]]]])1
group分組，實際上不使用
target表示調用對象，你可以傳入方法的名字
args表示給調用對象以元組的形式提供參數，比如target是函數a，他有兩個參數m，n，那麼該參數為args=(m, n)即可
kwargs表示調用對象的字典
name是別名，相當於給這個進程取一個名字
先來個小例子：
運行結果：
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，看看效果。
執行結果：
Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017
這是問題又來了，子進程並沒有執行完，這不是所期望的結果。有沒辦法將子進程執行完後才讓父進程結束呢？
這里引入p.join()方法，它使子進程執行結束後，父進程才執行之後的代碼
執行結果：
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
這樣所有的進程就能順利的執行了。
將進程定義成類
通過繼承Process類，來自定義進程類，實現run方法。實例p通過調用p.start()時自動調用run方法。
如下：
執行結果和上一個例子相同。
創建多個進程
很多時候系統都需要創建多個進程以提高CPU的利用率，當數量較少時，可以手動生成一個個Process實例。當進程數量很多時，或許可以利用循環，但是這需要程序員手動管理系統中並發進程的數量，有時會很麻煩。這時進程池Pool就可以發揮其功效了。可以通過傳遞參數限制並發進程的數量，默認值為CPU的核數。
直接上例子：
執行結果：
開頭部分
Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)
末尾部分：
Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.
相關說明：
這里進程池對並發進程的限制數量為8個，而程序運行時會產生16個進程，進程池將自動管理系統內進程的並發數量，其餘進程將會在隊列中等待。限制並發數量是因為，系統中並發的進程不是越多越好，並發進程太多，可能使CPU大部分的時間用於進程調度，而不是執行有效的計算。
採用多進程並發技術時，就單個處理機而言，其對進程的執行是串列的。但具體某個時刻哪個進程獲得CPU資源而執行是不可預知的（如執行結果的開頭部分，各進程的執行順序不定），這就體現了進程的非同步性。
如果單個程序執行14次run_proc函數，那麼它會需要至少16秒,通過進程的並發，這里只需要2.49秒，可見並發的優勢。
H. 怎樣使用python查詢系統某一進程是否存在
python執行ps -ef | grep XXX XXX為你的進程，當有返回值的時候，說明你的進程存在，python檢查系統進程其實調用的也是linux的shell
I. 怎樣使用python查詢系統某一進程是否存在
#!/usr/bin/env python
import os
import signal
# Change this to your process name
processname = 'aterm'
for line in os.popen("ps xa"):
fields = line.split()
pid = fields[0]
process = fields[4]
if process.find(processname) > 0:
# Kill the Process. Change signal.SIGHUP to signal.SIGKILL if you like
os.kill(int(pid), signal.SIGHUP)
# Do something else here
print "Doing something else here"
# Restart the process
os.system(processname)
# Hop out of loop
break
J. 怎樣使用python查詢系統某一進程是否存在
只需要一小段python代碼，就可以解決用python查詢判斷系統進程是否存在的操作。具休是怎麼樣判斷進程是不是存在，看下邊的python代碼就會明白了。
正常我們在編寫python代碼時，要殺死一個進程之前，一定要做的事情就是要知道這個進程是不是存在，存在要怎麼樣操作、不存在又怎麼樣操作。如何查找一個進程是否存在，用Python代碼來判斷一下最好不過了。
如何用python代碼查找一個進程是否存在的源代碼如下：
?
12345678910111213141516171819
#-*- coding:utf-8 -*-#編碼聲明 import win32com.client#導入方法 def check_exsit(process_name): WMI = win32com.client.GetObject('winmgmts:') processCodeCov = WMI.ExecQuery('select * from Win32_Process where Name="%s"' % process_name) if len(processCodeCov) > 0:#判斷操作 www.iplaypy.com print '%s is exists' % process_name else: print '%s is not exists' % process_name if __name__ == '__main__': check_exsit('chrome.exe')