『壹』 為什麼python多線程這么慢
差不多是這樣子。多線程目前僅用於網路多線程採集， 以及性能測試。
其它的語言也有類似的情況，線程本身的特點導致線程的適用范圍是受限的。只有CPU過剩，而其它的任務很慢，此時用線程才是有益的，可以很好平衡等待時間，提高並發性能。
線程的問題主要是線程的安全穩定性。線程無法強制中止，同時線程與主進程共享內存，可能會影響主進程的內存管理。
在python里線程出問題，可能會導致主進程崩潰。 雖然python里的線程是操作系統的真實線程。
那麼怎麼解決呢？通過我們用進程方式。子進程崩潰後，會完全的釋放所有的內存和錯誤狀態。所以進程更安全。 另外通過進程，python可以很好的繞過GIL，這個全局鎖問題。
但是進程也是有局限的。不要建立超過CPU總核數的進程，否則效率也不高。
簡單的總結一下。
當我們想實現多任務處理時，首先要想到使用multiprocessing， 但是如果覺著進程太笨重，那麼就要考慮使用線程。 如果多任務處理中需要處理的太多了，可以考慮多進程，每個進程再採用多線程。如果還處理不要，就要使用輪詢模式，比如使用poll event, twisted等方式。如果是GUI方式，則要通過事件機制，或者是消息機制處理，GUI使用單線程。
所以在python里線程不要盲目用， 也不要濫用。 但是線程不安全是事實。如果僅僅是做幾個後台任務，則可以考慮使用守護線程做。如果需要做一些危險操作，可能會崩潰的，就用子進程去做。 如果需要高度穩定性，同時並發數又不高的服務。則強烈建議用多進程的multiprocessing模塊實現。
在linux或者是unix里，進程的使用代價沒有windows高。還是可以接受的。
『貳』 python多線程為什麼會暫停一下,再接著跑 跑一段時間，會暫停幾秒鍾，然後接著列印。
線程之間的輸出，需要在池中中轉，死循環的時間長了，出現滿棧的概率提高，外在表現就是卡一會兒
『叄』 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
『肆』 什麼是線程（多線程），Python多線程的好處
幾乎所有的操作系統都支持同時運行多個任務，一個任務通常就是一個程序，每一個運行中的程序就是一個進程。當一個程序運行時，內部可能包含多個順序執行流，每一個順序執行流就是一個線程。
線程和進程
幾乎所有的操作系統都支持進程的概念，所有運行中的任務通常對應一個進程（Process）。當一個程序進入內存運行時，即變成一個進程。進程是處於運行過程中的程序，並且具有一定的獨立功能。進程是系統進行資源分配和調度的一個獨立單位。
一般而言，進程包含如下三個特徵：
獨立性：進程是系統中獨立存在的實體，它可以擁有自己的獨立的資源，每一個進程都擁有自己的私有的地址空間。在沒有經過進程本身允許的情況下，一個用戶進程不可以直接訪問其他進程的地址空間。
動態性：進程與程序的區別在於，程序只是一個靜態的指令集合，而進程是一個正在系統中活動的指令集合。在進程中加入了時間的概念。進程具有自己的生命周期和各種不同的狀態，在程序中是沒有這些概念的。
並發性：多個進程可以在單個處理器上並發執行，多個進程之間不會互相影響。
並發（Concurrency）和並行（Parallel）是兩個概念，並行指在同一時刻有多條指令在多個處理器上同時執行；並發才旨在同一時刻只能有一條指令執行，但多個進程指令被快速輪換執行，使得在宏觀上具有多個進程同時執行的效果。
大部分操作系統都支持多進程並發執行，現代的操作系統幾乎都支持同時執行多個任務。例如，程序員一邊開著開發工具在寫程序，一邊開著參考手冊備查，同時還使用電腦播放音樂……除此之外，每台電腦運行時還有大量底層的支撐性程序在運行……這些進程看上去像是在同時工作。
但事實的真相是，對於一個 CPU 而言，在某個時間點它只能執行一個程序。也就是說，只能運行一個進程，CPU 不斷地在這些進程之間輪換執行。那麼，為什麼用戶感覺不到任何中斷呢？
這是因為相對人的感覺來說，CPU 的執行速度太快了（如果啟動的程序足夠多，則用戶依然可以感覺到程序的運行速度下降了）。所以，雖然 CPU 在多個進程之間輪換執行，但用戶感覺到好像有多個進程在同時執行。
現代的操作系統都支持多進程的並發執行，但在具體的實現細節上可能因為硬體和操作系統的不同而採用不同的策略。比較常用的策略有：
共用式的多任務操作策略，例如 Windows 3.1 和 Mac OS 9 操作系統採用這種策略；
搶占式的多任務操作策略，其效率更高，目前操作系統大多採用這種策略，例如 Windows NT、Windows 2000 以及 UNIX/Linux 等操作系統。
多線程則擴展了多進程的概念，使得同一個進程可以同時並發處理多個任務。線程（Thread）也被稱作輕量級進程（Lightweight Process），線程是進程的執行單元。就像進程在操作系統中的地位一樣，線程在程序中是獨立的、並發的執行流。
當進程被初始化後，主線程就被創建了。對於絕大多數的應用程序來說，通常僅要求有一個主線程，但也可以在進程內創建多個順序執行流，這些順序執行流就是線程，每一個線程都是獨立的。
線程是進程的組成部分，一個進程可以擁有多個線程，一個線程必須有一個父進程。線程可以擁有自己的堆棧、自己的程序計數器和自己的局部變數，但不擁有系統資源，它與父進程的其他線程共享該進程所擁有的全部資源。因為多個線程共享父進程里的全部資源，因此編程更加方便；但必須更加小心，因為需要確保線程不會妨礙同一進程中的其他線程。
線程可以完成一定的任務，可以與其他線程共享父進程中的共享變數及部分環境，相互之間協同未完成進程所要完成的任務。
線程是獨立運行的，它並不知道進程中是否還有其他線程存在。線程的運行是搶占式的，也就是說，當前運行的線程在任何時候都可能被掛起，以便另外一個線程可以運行。
一個線程可以創建和撤銷另一個線程，同一個進程中的多個線程之間可以並發運行。
從邏輯的角度來看，多線程存在於一個應用程序中，讓一個應用程序可以有多個執行部分同時執行，但操作系統無須將多個線程看作多個獨立的應用，對多線程實現調度和管理，以及資源分配。線程的調度和管理由進程本身負責完成。
簡而言之，一個程序運行後至少有一個進程，在一個進程中可以包含多個線程，但至少要包含一個主線程。
歸納起來可以這樣說，操作系統可以同時執行多個任務，每一個任務就是一個進程，進程可以同時執行多個任務，每一個任務就是一個線程。
多線程的好處
線程在程序中是獨立的、並發的執行流。與分隔的進程相比，進程中線程之間的隔離程度要小，它們共享內存、文件句柄和其他進程應有的狀態
因為線程的劃分尺度小於進程，使得多線程程序的並發性高。進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，從而極大地提高了程序的運行效率。
線程比進程具有更高的性能，這是由於同一個進程中的線程都有共性多個線程共享同一個進程的虛擬空間。線程共享的環境包括進程代碼段、進程的公有數據等，利用這些共享的數據，線程之間很容易實現通信。
操作系統在創建進程時，必須為該進程分配獨立的內存空間，並分配大量的相關資源，但創建線程則簡單得多。因此，使用多線程來實現並發比使用多進程的性能要高得多。
總結起來，使用多線程編程具有如下幾個優點：
進程之間不能共享內存，但線程之間共享內存非常容易。
操作系統在創建進程時，需要為該進程重新分配系統資源，但創建線程的代價則小得多。因此，使用多線程來實現多任務並發執行比使用多進程的效率高。
Python 語言內置了多線程功能支持，而不是單純地作為底層操作系統的調度方式，從而簡化了 Python 的多線程編程。
在實際應用中，多線程是非常有用的。比如一個瀏覽器必須能同時下載多張圖片；一個 Web 伺服器必須能同時響應多個用戶請求；圖形用戶界面（GUI）應用也需要啟動單獨的線程，從主機環境中收集用戶界面事件……總之，多線程在實際編程中的應用是非常廣泛的。
『伍』 python 線程池的使用
最近在做一個爬蟲相關的項目，單線程的整站爬蟲，耗時真的不是一般的巨大，運行一次也是心累，，，所以，要想實現整站爬蟲，多線程是不可避免的，那麼python多線程又應該怎樣實現呢？這里主要要幾個問題（關於python多線程的GIL問題就不再說了，網上太多了）。
一、 既然多線程可以縮短程序運行時間，那麼，是不是線程數量越多越好呢？
顯然，並不是，每一個線程的從生成到消亡也是需要時間和資源的，太多的線程會佔用過多的系統資源（內存開銷，cpu開銷），而且生成太多的線程時間也是可觀的，很可能會得不償失，這里給出一個最佳線程數量的計算方式：
最佳線程數的獲取：
1、通過用戶慢慢遞增來進行性能壓測，觀察QPS（即每秒的響應請求數，也即是最大吞吐能力。），響應時間
2、根據公式計算:伺服器端最佳線程數量=((線程等待時間+線程cpu時間)/線程cpu時間) * cpu數量
3、單用戶壓測，查看CPU的消耗，然後直接乘以百分比，再進行壓測，一般這個值的附近應該就是最佳線程數量。
二、為什麼要使用線程池？
對於任務數量不斷增加的程序，每有一個任務就生成一個線程，最終會導致線程數量的失控，例如，整站爬蟲，假設初始只有一個鏈接a，那麼，這個時候只啟動一個線程，運行之後，得到這個鏈接對應頁面上的b，c，d，，，等等新的鏈接，作為新任務，這個時候，就要為這些新的鏈接生成新的線程，線程數量暴漲。在之後的運行中，線程數量還會不停的增加，完全無法控制。所以，對於任務數量不端增加的程序，固定線程數量的線程池是必要的。
三、如何使用線程池
過去使用threadpool模塊，現在一般使用concurrent.futures模塊，這個模塊是python3中自帶的模塊，但是，python2.7以上版本也可以安裝使用，具體使用方式如下：
注意到：
concurrent.futures.ThreadPoolExecutor，在提交任務的時候，有兩種方式，一種是submit（）函數，另一種是map（）函數，兩者的主要區別在於：
『陸』 python 怎麼實現多線程的
線程也就是輕量級的進程，多線程允許一次執行多個線程，Python是多線程語言，它有一個多線程包，GIL也就是全局解釋器鎖，以確保一次執行單個線程，一個線程保存GIL並在將其傳遞給下一個線程之前執行一些操作，也就產生了並行執行的錯覺。