⑴ python 怎麼設置守護進程
thread[i].join()
用join（）方法去設置守護線程。
不過此方法只在threading中才有。
⑵ 關於python多線程的一些問題。
創建的子線程默認是非守護的。
非守護：當主線程結束時，子線程繼續運行，二者互不影響。
子線程是守護線程：當主線程結束時，子線程也結束（不管子線程工作有沒有完成）。
join作用是線程同步，是讓主線程等待子線程結束才結束（主線程完成工作了也不結束，阻塞等待，等子線程完成其工作才一起結束）。
相信此時你已經懂你的兩個問題了。
沒加join的時候主線程結束了，所以命令提示符>>>就出來了，可是子線程還沒結束，過了3/5秒後列印了字元串。加了join後主線程等兩個子線程都結束才一起結束，所以最後才出來>>>。
理解確實有點偏差。守護是指子線程守護著主線程，你死我也死，謂之守護。
⑶ Python之全局解釋器鎖GIL
全局解釋器鎖GIL(CPython)
Python代碼的執行由Python虛擬機(也叫解釋器主循環)來控制。CPython在執行多線程的時候並不是線程安全的，所以為了程序的穩定性，加一把全局解釋鎖，確保任何時候都只有一個Python線程執行。雖然 Python 解釋器中可以「運行」多個線程，但在同一時刻只有一個線程在解釋器中運行。
我們所說的Python全局解釋鎖(GIL)簡單來說就是一個互斥體(或者說鎖)，這樣的機制只允許一個線程來控制Python解釋器。GIL對執行單線程任務的程序員們來說並沒什麼顯著影響，但是它成為了計算密集型(CPU-bound)和多線程任務的性能瓶頸。
相關推薦：《Python視頻教程》
在多線程環境中，Python 虛擬機按以下方式執行：
a、設置 GIL；
b、切換到一個線程去運行；
c、運行指定數量的位元組碼指令或者線程主動讓出控制(可以調用 time.sleep(0))；
d、把線程設置為睡眠狀態；
e、解鎖 GIL；
f、再次重復以上所有步驟。
在調用外部代碼(如 C/C++擴展函數)的時候，GIL將會被鎖定，直到這個函數結束為止(由於在這期間沒有Python的位元組碼被運行，所以不會做線程切換)編寫擴展的程序員可以主動解鎖GIL。
Python多線程模塊的選擇：
Python提供了幾個用於多線程編程的模塊，包括thread、threading和Queue等。thread和threading模塊允許程序員創建和管理線程。thread模塊提供了基本的線程和鎖的支持，threading提供了更高級別、功能更強的線程管理的功能。Queue模塊允許用戶創建一個可以用於多個線程之間共享數據的隊列數據結構。
避免使用thread模塊，因為更高級別的threading模塊更為先進，對線程的支持更為完善，而且使用thread模塊里的屬性有可能會與threading出現沖突；其次低級別的thread模塊的同步原語很少(實際上只有一個)，而threading模塊則有很多；再者，thread模塊中當主線程結束時，所有的線程都會被強制結束掉，沒有警告也不會有正常的清除工作，至少threading模塊能確保重要的子線程退出後進程才退出。
thread模塊不支持守護線程，當主線程退出時，所有的子線程不論它們是否還在工作，都會被強行退出。而threading模塊支持守護線程，守護線程一般是一個等待客戶請求的伺服器，如果沒有客戶提出請求它就在那等著，如果設定一個線程為守護線程，就表示這個線程是不重要的，在進程退出的時候，不用等待這個線程退出。
⑷ python線程用什麼模塊好
在Python中可使用的多線程模塊主要有兩個，thread和threading模塊。thread模塊提供了基本的線程和鎖的支持，建議新手不要使用。threading模塊允許創建和管理線程，提供了更多的同步原語。
thread模塊函數：
start_new_thread(function, args[, kwargs])：啟動新的線程以執行function，返回線程標識。
allocate_lock()：返回LockType對象。
exit()：拋出SystemExit異常，如果沒有被捕獲，線程靜默退出。
LockType類型鎖對象的方法：
acquire([waitflag])：無參數，無條件獲得鎖，如果鎖已經被其他線程獲取，則等待鎖被釋放。如果使用整型參數，參數為0，如果鎖可獲取，則獲取且返回True，否則返回False；參數為非0，與無參數相同。
locked()：返回鎖的狀態，如果已經被獲取，則返回True，否則返回False。
release()：釋放鎖。只有已經被獲取的鎖才能被釋放，不限於同一個線程。
threading模塊提供了更好的線程間的同步機制。threading模塊下有如下對象：
Thread
Lock
RLock
Condition
Event
Semaphore
BoundedSemaphore
Timer
threading模塊內還有如下的函數：
active_count()
activeCount()：返回當前alive的線程數量
Condition()：返回新的條件變數對象
current_thread()
currentThread()：返回當前線程對象
enumerate()：返回當前活動的線程，不包括已經結束和未開始的線程，包括主線程及守護線程。
settrace(func)：為所有線程設置一個跟蹤函數。
setprofile(func)：為所有純種設置一個profile函數。
更多Python知識請關注Python自學網
⑸ Python主線程結束為什麼守護線程還在運行
法很多。通常的法是，子線程出異常後，主進程檢查到它的狀態不正常，然後自己主動將其餘線程退出，最後自己再退出。這是穩妥的法。另外的法是，某一個子線程專用於監控狀態。它發現狀態不對時，直接強制進程退出。法1，發消息給主進程，讓主進程退出。法2：用kill,pskill等方法，直接按進程PID殺進程。
⑹ Python面試題，線程與進程的區別，Python中如何創建多線程
進程和線程這兩個概念屬於操作系統，我們經常聽說，但是可能很少有人會細究它們的含義。對於工程師而言，兩者的定義和區別還是很有必要了解清楚的。
首先說進程，進程可以看成是 CPU執行的具體的任務 。在操作系統當中，由於CPU的運行速度非常快，要比計算機當中的其他設備要快得多。比如內存、磁碟等等，所以如果CPU一次只執行一個任務，那麼會導致CPU大量時間在等待這些設備，這樣操作效率很低。為了提升計算機的運行效率，把機器的技能盡可能壓榨出來，CPU是輪詢工作的。也就是說 它一次只執行一個任務，執行一小段碎片時間之後立即切換 ，去執行其他任務。
所以在早期的單核機器的時候，看起來電腦也是並發工作的。我們可以一邊聽歌一邊上網，也不會覺得卡頓。但實際上，這是CPU輪詢的結果。在這個例子當中，聽歌的軟體和上網的軟體對於CPU而言都是 獨立的進程 。我們可以把進程簡單地理解成運行的應用，比如在安卓手機裡面，一個app啟動的時候就會對應系統中的一個進程。當然這種說法不完全准確， 一個應用也是可以啟動多個進程的 。
進程是對應CPU而言的，線程則更多針對的是程序。即使是CPU在執行當前進程的時候，程序運行的任務其實也是有分工的。舉個例子，比如聽歌軟體當中，我們需要顯示歌詞的字幕，需要播放聲音，需要監聽用戶的行為，比如是否發生了切歌、調節音量等等。所以，我們需要 進一步拆分CPU的工作 ，讓它在執行當前進程的時候，繼續通過輪詢的方式來同時做多件事情。
進程中的任務就是線程，所以從這點上來說， 進程和線程是包含關系 。一個進程當中可以包含多個線程，對於CPU而言，不能直接執行線程，一個線程一定屬於一個進程。所以我們知道，CPU進程切換切換的是執行的應用程序或者是軟體，而進程內部的線程切換，切換的是軟體當中具體的執行任務。
關於進程和線程有一個經典的模型可以說明它們之間的關系，假設CPU是一家工廠，工廠當中有多個車間。不同的車間對應不同的生產任務，有的車間生產汽車輪胎，有的車間生產汽車骨架。但是工廠的電力是有限的，同時只能滿足一個廠房的使用。
為了讓大家的進度協調，所以工廠需要輪流提供各個車間的供電。 這里的車間對應的就是進程 。
一個車間雖然只生產一種產品，但是其中的工序卻不止一個。一個車間可能會有好幾條流水線，具體的生產任務其實是流水線完成的，每一條流水線對應一個具體執行的任務。但是同樣的， 車間同一時刻也只能執行一條流水線 ，所以我們需要車間在這些流水線之間切換供電，讓各個流水線生產進度統一。
這里車間里的 流水線自然對應的就是線程的概念 ，這個模型很好地詮釋了CPU、進程和線程之間的關系。實際的原理也的確如此，不過CPU中的情況要比現實中的車間復雜得多。因為對於進程和CPU來說，它們面臨的局面都是實時變化的。車間當中的流水線是x個，下一刻可能就成了y個。
了解完了線程和進程的概念之後，對於理解電腦的配置也有幫助。比如我們買電腦，經常會碰到一個術語，就是這個電腦的CPU是某某核某某線程的。比如我當年買的第一台筆記本是4核8線程的，這其實是在說這台電腦的CPU有 4個計算核心 ，但是使用了超線程技術，使得可以把一個物理核心模擬成兩個邏輯核心。相當於我們可以用4個核心同時執行8個線程，相當於8個核心同時執行，但其實有4個核心是模擬出來的虛擬核心。
有一個問題是 為什麼是4核8線程而不是4核8進程呢 ？因為CPU並不會直接執行進程，而是執行的是進程當中的某一個線程。就好像車間並不能直接生產零件，只有流水線才能生產零件。車間負責的更多是資源的調配，所以教科書里有一句非常經典的話來詮釋： 進程是資源分配的最小單元，線程是CPU調度的最小單元 。
啟動線程Python當中為我們提供了完善的threading庫，通過它，我們可以非常方便地創建線程來執行多線程。
首先，我們引入threading中的Thread，這是一個線程的類，我們可以通過創建一個線程的實例來執行多線程。
from threading import Thread t = Thread(target=func, name='therad', args=(x, y)) t.start()簡單解釋一下它的用法，我們傳入了三個參數，分別是 target，name和args ，從名字上我們就可以猜測出它們的含義。首先是target，它傳入的是一個方法，也就是我們希望多線程執行的方法。name是我們為這個新創建的線程起的名字，這個參數可以省略，如果省略的話，系統會為它起一個系統名。當我們執行Python的時候啟動的線程名叫MainThread，通過線程的名字我們可以做區分。args是會傳遞給target這個函數的參數。
我們來舉個經典的例子：
import time, threading # 新線程執行的代碼: def loop(n): print('thread %s is running...' % threading.current_thread().name) for i in range(n): print('thread %s >>> %s' % (threading.current_thread().name, i)) time.sleep(5) print('thread %s ended.' % threading.current_thread().name) print('thread %s is running...' % threading.current_thread().name) t = threading.Thread(target=loop, name='LoopThread', args=(10, )) t.start() print('thread %s ended.' % threading.current_thread().name)我們創建了一個非常簡單的loop函數，用來執行一個循環來列印數字，我們每次列印一個數字之後這個線程會睡眠5秒鍾，所以我們看到的結果應該是每過5秒鍾屏幕上多出一行數字。
我們在Jupyter里執行一下：
表面上看這個結果沒毛病，但是其實有一個問題，什麼問題呢？ 輸出的順序不太對 ，為什麼我們在列印了第一個數字0之後，主線程就結束了呢？另外一個問題是，既然主線程已經結束了， 為什麼Python進程沒有結束 ， 還在向外列印結果呢？
因為線程之間是獨立的，對於主線程而言，它在執行了t.start()之後，並 不會停留，而是會一直往下執行一直到結束 。如果我們不希望主線程在這個時候結束，而是阻塞等待子線程運行結束之後再繼續運行，我們可以在代碼當中加上t.join()這一行來實現這點。
t.start() t.join() print('thread %s ended.' % threading.current_thread().name)join操作可以讓主線程在join處掛起等待，直到子線程執行結束之後，再繼續往下執行。我們加上了join之後的運行結果是這樣的：
這個就是我們預期的樣子了，等待子線程執行結束之後再繼續。
我們再來看第二個問題，為什麼主線程結束的時候，子線程還在繼續運行，Python進程沒有退出呢？這是因為默認情況下我們創建的都是用戶級線程，對於進程而言， 會等待所有用戶級線程執行結束之後才退出 。這里就有了一個問題，那假如我們創建了一個線程嘗試從一個介面當中獲取數據，由於介面一直沒有返回，當前進程豈不是會永遠等待下去？
這顯然是不合理的，所以為了解決這個問題，我們可以把創建出來的線程設置成 守護線程 。
守護線程守護線程即daemon線程，它的英文直譯其實是後台駐留程序，所以我們也可以理解成 後台線程 ，這樣更方便理解。daemon線程和用戶線程級別不同，進程不會主動等待daemon線程的執行， 當所有用戶級線程執行結束之後即會退出。進程退出時會kill掉所有守護線程 。
我們傳入daemon=True參數來將創建出來的線程設置成後台線程：
t = threading.Thread(target=loop, name='LoopThread', args=(10, ), daemon=True)這樣我們再執行看到的結果就是這樣了：
這里有一點需要注意，如果你 在jupyter當中運行是看不到這樣的結果的 。因為jupyter自身是一個進程，對於jupyter當中的cell而言，它一直是有用戶級線程存活的，所以進程不會退出。所以想要看到這樣的效果，只能通過命令行執行Python文件。
如果我們想要等待這個子線程結束，就必須通過join方法。另外，為了預防子線程鎖死一直無法退出的情況， 我們還可以 在joih當中設置timeout ，即最長等待時間，當等待時間到達之後，將不再等待。
比如我在join當中設置的timeout等於5時，屏幕上就只會輸出5個數字。
另外，如果沒有設置成後台線程的話，設置timeout雖然也有用，但是 進程仍然會等待所有子線程結束 。所以屏幕上的輸出結果會是這樣的：
雖然主線程繼續往下執行並且結束了，但是子線程仍然一直運行，直到子線程也運行結束。
關於join設置timeout這里有一個坑，如果我們只有一個線程要等待還好，如果有多個線程，我們用一個循環將它們設置等待的話。那麼 主線程一共會等待N * timeout的時間 ，這里的N是線程的數量。因為每個線程計算是否超時的開始時間是上一個線程超時結束的時間，它會等待所有線程都超時，才會一起終止它們。
比如我這樣創建3個線程：
ths = [] for i in range(3): t = threading.Thread(target=loop, name='LoopThread' + str(i), args=(10, ), daemon=True) ths.append(t) for t in ths: t.start() for t in ths: t.join(2)最後屏幕上輸出的結果是這樣的：
所有線程都存活了6秒。
總結在今天的文章當中，我們一起簡單了解了 操作系統當中線程和進程的概念 ，以及Python當中如何創建一個線程，以及關於創建線程之後的相關使用。
多線程在許多語言當中都是至關重要的，許多場景下必定會使用到多線程。比如 web後端，比如爬蟲，再比如游戲開發 以及其他所有需要涉及開發ui界面的領域。因為凡是涉及到ui，必然會需要一個線程單獨渲染頁面，另外的線程負責准備數據和執行邏輯。因此，多線程是專業程序員繞不開的一個話題，也是一定要掌握的內容之一。
⑺ Python多線程的一些問題
python提供了兩個模塊來實現多線程thread 和threading ，thread 有一些缺點，在threading 得到了彌補，為了不浪費你和時間，所以我們直接學習threading 就可以了。
繼續對上面的例子進行改造，引入threadring來同時播放音樂和視頻：
#coding=utf-8import threadingfrom time import ctime,sleepdef music(func): for i in range(2): print "I was listening to %s. %s" %(func,ctime())
sleep(1)def move(func): for i in range(2): print "I was at the %s! %s" %(func,ctime())
sleep(5)
threads = []
t1 = threading.Thread(target=music,args=(u'愛情買賣',))
threads.append(t1)
t2 = threading.Thread(target=move,args=(u'阿凡達',))
threads.append(t2)if __name__ == '__main__': for t in threads:
t.setDaemon(True)
t.start() print "all over %s" %ctime()
import threading
首先導入threading 模塊，這是使用多線程的前提。
threads = []
t1 = threading.Thread(target=music,args=(u'愛情買賣',))
threads.append(t1)
創建了threads數組，創建線程t1,使用threading.Thread()方法，在這個方法中調用music方法target=music，args方法對music進行傳參。 把創建好的線程t1裝到threads數組中。
接著以同樣的方式創建線程t2，並把t2也裝到threads數組。
for t in threads:
t.setDaemon(True)
t.start()
最後通過for循環遍歷數組。（數組被裝載了t1和t2兩個線程）
setDaemon()
setDaemon(True)將線程聲明為守護線程，必須在start() 方法調用之前設置，如果不設置為守護線程程序會被無限掛起。子線程啟動後，父線程也繼續執行下去，當父線程執行完最後一條語句print "all over %s" %ctime()後，沒有等待子線程，直接就退出了，同時子線程也一同結束。
start()
開始線程活動。
運行結果：
>>> ========================= RESTART ================================
>>> I was listening to 愛情買賣. Thu Apr 17 12:51:45 2014 I was at the 阿凡達! Thu Apr 17 12:51:45 2014 all over Thu Apr 17 12:51:45 2014
從執行結果來看，子線程（muisc 、move ）和主線程（print "all over %s" %ctime()）都是同一時間啟動，但由於主線程執行完結束，所以導致子線程也終止。
繼續調整程序：
...if __name__ == '__main__': for t in threads:
t.setDaemon(True)
t.start()
t.join() print "all over %s" %ctime()
我們只對上面的程序加了個join()方法，用於等待線程終止。join（）的作用是，在子線程完成運行之前，這個子線程的父線程將一直被阻塞。
注意: join()方法的位置是在for循環外的，也就是說必須等待for循環里的兩個進程都結束後，才去執行主進程。
運行結果：
>>> ========================= RESTART ================================
>>> I was listening to 愛情買賣. Thu Apr 17 13:04:11 2014 I was at the 阿凡達! Thu Apr 17 13:04:11 2014I was listening to 愛情買賣. Thu Apr 17 13:04:12 2014I was at the 阿凡達! Thu Apr 17 13:04:16 2014all over Thu Apr 17 13:04:21 2014
從執行結果可看到，music 和move 是同時啟動的。
開始時間4分11秒，直到調用主進程為4分22秒，總耗時為10秒。從單線程時減少了2秒，我們可以把music的sleep()的時間調整為4秒。
...def music(func): for i in range(2): print "I was listening to %s. %s" %(func,ctime())
sleep(4)
...
子線程啟動11分27秒，主線程運行11分37秒。
雖然music每首歌曲從1秒延長到了4 ，但通多程線的方式運行腳本，總的時間沒變化。