1. python 的多線程問題。。
python 的GIL規定每個時刻只能有一個線程訪問python虛擬機，所以你要用python的多線程來做計算是很不合算的，但是對於IO密集型的應用，例如網路交互來說，python的多線程還是非常給力的。
如果你是一個計算密集型的任務，非要用python來並行執行的話，有以下幾個方法：
1 使用python的multiprocessing 模塊，能夠發揮多核的優勢。
2 使用ironPython，但是這個只能在windows下用
3 使用pypy，這個可以實現真正的多線程。
2. Python多線程是什麼意思
幾乎所有的操作系統都支持同時運行多個任務，一個任務通常就是一個程序，所有運行中的任務都對應一個進程。即當一個程序進入內存運行時，即變成一個進程。進程就是處於運行過程中的程序，並且具有一定的獨立功能。進程是系統進行資源分配調度的一個獨立單位，當一個程序運行時，內部可能包含多個順序執流，每個順序執行流就是一個線程。
1、線程在程序中是獨立的，並發的執行流，劃分尺度小於進程，所有多線程程序的並發性高;
2、進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，可以極大地提高進程程序的運行效率;
3、線程比進程具有更高的性能，由於同一個進程中的線程都有共性，多個線程共享同一個進程的虛擬空間，可以很容易實現通信。操作系統在創建進程中，必須為該進程分配獨立內存空間，分配大量相關資源，但創建線程則簡單得多。
3. Python多線程
那是當然。你這樣寫就可以了
self.p[:]=array
這樣寫法的含義就是指針不變。只換內容。這樣就可以同步了。
你的寫法是，新建一個數組，再把指針緞帶self.p，如果其它的線程就會出問題。
另外你的p應該放在__init__之前。引用時使用T.p來引用，這樣更合理一些。
4. python之多線程
進程的概念：以一個整體的形式暴露給操作系統管理，裡麵包含各種資源的調用。 對各種資源管理的集合就可以稱為進程。
線程的概念：是操作系統能夠進行運算調度的最小單位。本質上就是一串指令的集合。
進程和線程的區別：
1、線程共享內存空間，進程有獨立的內存空間。
2、線程啟動速度快，進程啟動速度慢。注意：二者的運行速度是無法比較的。
3、線程是執行的指令集，進程是資源的集合
4、兩個子進程之間數據不共享，完全獨立。同一個進程下的線程共享同一份數據。
5、創建新的線程很簡單，創建新的進程需要對他的父進程進行一次克隆。
6、一個線程可以操作（控制）同一進程里的其他線程，但是進程只能操作子進程
7、同一個進程的線程可以直接交流，兩個進程想要通信，必須通過一個中間代理來實現。
8、對於線程的修改，可能會影響到其他線程的行為。但是對於父進程的修改不會影響到子進程。
第一個程序，使用循環來創建線程，但是這個程序中一共有51個線程，我們創建了50個線程，但是還有一個程序本身的線程，是主線程。這51個線程是並行的。注意：這個程序中是主線程啟動了子線程。
相比上個程序，這個程序多了一步計算時間，但是我們觀察結果會發現，程序顯示的執行時間只有0.007秒，這是因為最後一個print函數它存在於主線程，而整個程序主線程和所有子線程是並行的，那麼可想而知，在子線程還沒有執行完畢的時候print函數就已經執行了，總的來說，這個時間只是執行了一個線程也就是主線程所用的時間。
接下來這個程序，吸取了上面這個程序的缺點，創建了一個列表，把所有的線程實例都存進去，然後使用一個for循環依次對線程實例調用join方法，這樣就可以使得主線程等待所創建的所有子線程執行完畢才能往下走。 注意實驗結果：和兩個線程的結果都是兩秒多一點
注意觀察實驗結果，並沒有執行列印task has done，並且程序執行時間極其短。
這是因為在主線程啟動子線程前把子線程設置為守護線程。
只要主線程執行完畢，不管子線程是否執行完畢，就結束。但是會等待非守護線程執行完畢
主線程退出，守護線程全部強制退出。皇帝死了，僕人也跟著殉葬
應用的場景 ： socket-server
注意：gil只是為了減低程序開發復雜度。但是在2.幾的版本上，需要加用戶態的鎖（gil的缺陷）而在3點幾的版本上，加鎖不加鎖都一樣。
下面這個程序是一個典型的生產者消費者模型。
生產者消費者模型是經典的在開發架構中使用的模型
運維中的集群就是生產者消費者模型，生活中很多都是
那麼，多線程的使用場景是什麼？
python中的多線程實質上是對上下文的不斷切換，可以說是假的多線程。而我們知道，io操作不佔用cpu，計算佔用cpu，那麼python的多線程適合io操作密集的任務，比如socket-server，那麼cpu密集型的任務，python怎麼處理？python可以折中的利用計算機的多核：啟動八個進程，每個進程有一個線程。這樣就可以利用多進程解決多核問題。
5. python多線程幾種方法實現
Python進階(二十六)-多線程實現同步的四種方式
臨界資源即那些一次只能被一個線程訪問的資源，典型例子就是列印機，它一次只能被一個程序用來執行列印功能，因為不能多個線程同時操作，而訪問這部分資源的代碼通常稱之為臨界區。
鎖機制
threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行
當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。
信號量
信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允許最多三個線程同時訪問資源
def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):
6. python 怎麼實現多線程的
線程也就是輕量級的進程，多線程允許一次執行多個線程，Python是多線程語言，它有一個多線程包，GIL也就是全局解釋器鎖，以確保一次執行單個線程，一個線程保存GIL並在將其傳遞給下一個線程之前執行一些操作，也就產生了並行執行的錯覺。
7. python之多線程原理
並發：邏輯上具備同時處理多個任務的能力。
並行：物理上在同一時刻執行多個並發任務。
舉例：開個QQ，開了一個進程，開了微信，開了一個進程。在QQ這個進程裡面，傳輸文字開一個線程、傳輸語音開了一個線程、彈出對話框又開了一個線程。
總結：開一個軟體，相當於開了一個進程。在這個軟體運行的過程里，多個工作同時運轉，完成了QQ的運行，那麼這個多個工作分別有多個線程。
線程和進程之間的區別：
進程在python中的使用，對模塊threading進行操作，調用的這個三方庫。可以通過 help(threading) 了解其中的方法、變數使用情況。也可以使用 dir(threading) 查看目錄結構。
current_thread_num = threading.active_count() # 返回正在運行的線程數量
run_thread_len = len(threading.enumerate()) # 返回正在運行的線程數量
run_thread_list = threading.enumerate() # 返回當前運行線程的列表
t1=threading.Thread(target=dance) #創建兩個子線程，參數傳遞為函數名
t1.setDaemon(True) # 設置守護進程，守護進程：主線程結束時自動退出子線程。
t1.start() # 啟動子線程
t1.join() # 等待進程結束 exit()`# 主線程退出，t1子線程設置了守護進程，會自動退出。其他子線程會繼續執行。
8. python 多進程和多線程配合
由於python的多線程中存在PIL鎖，因此python的多線程不能利用多核，那麼，由於現在的計算機是多核的，就不能充分利用計算機的多核資源。但是python中的多進程是可以跑在不同的cpu上的。因此，嘗試了多進程+多線程的方式，來做一個任務。比如：從中科大的鏡像源中下載多個rpm包。
#!/usr/bin/pythonimport reimport commandsimport timeimport multiprocessingimport threadingdef download_image(url):
print '*****the %s rpm begin to download *******' % url
commands.getoutput('wget %s' % url)def get_rpm_url_list(url):
commands.getoutput('wget %s' % url)
rpm_info_str = open('index.html').read()
regu_mate = '(?<=<a href=")(.*?)(?=">)'
rpm_list = re.findall(regu_mate, rpm_info_str)
rpm_url_list = [url + rpm_name for rpm_name in rpm_list] print 'the count of rpm list is: ', len(rpm_url_list) return rpm_url_
def multi_thread(rpm_url_list):
threads = [] # url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
# rpm_url_list = get_rpm_url_list(url)
for index in range(len(rpm_url_list)): print 'rpm_url is:', rpm_url_list[index]
one_thread = threading.Thread(target=download_image, args=(rpm_url_list[index],))
threads.append(one_thread)
thread_num = 5 # set threading pool, you have put 4 threads in it
while 1:
count = min(thread_num, len(threads)) print '**********count*********', count ###25,25,...6707%25
res = [] for index in range(count):
x = threads.pop()
res.append(x) for thread_index in res:
thread_index.start() for j in res:
j.join() if not threads:
def multi_process(rpm_url_list):
# process num at the same time is 4
process = []
rpm_url_group_0 = []
rpm_url_group_1 = []
rpm_url_group_2 = []
rpm_url_group_3 = [] for index in range(len(rpm_url_list)): if index % 4 == 0:
rpm_url_group_0.append(rpm_url_list[index]) elif index % 4 == 1:
rpm_url_group_1.append(rpm_url_list[index]) elif index % 4 == 2:
rpm_url_group_2.append(rpm_url_list[index]) elif index % 4 == 3:
rpm_url_group_3.append(rpm_url_list[index])
rpm_url_groups = [rpm_url_group_0, rpm_url_group_1, rpm_url_group_2, rpm_url_group_3] for each_rpm_group in rpm_url_groups:
each_process = multiprocessing.Process(target = multi_thread, args = (each_rpm_group,))
process.append(each_process) for one_process in process:
one_process.start() for one_process in process:
one_process.join()# for each_url in rpm_url_list:# print '*****the %s rpm begin to download *******' %each_url## commands.getoutput('wget %s' %each_url)
def main():
url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
url_paas = 'http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/'
url_paas2 ='http://mirrors.ustc.e.cn/fedora/development/26/Server/x86_64/os/Packages/u/'
start_time = time.time()
rpm_list = get_rpm_url_list(url_paas) print multi_process(rpm_list) # print multi_thread(rpm_list)
#print multi_process()
# print multi_thread(rpm_list)
# for index in range(len(rpm_list)):
# print 'rpm_url is:', rpm_list[index]
end_time = time.time() print 'the download time is:', end_time - start_timeprint main()123456789101112131415161718
代碼的功能主要是這樣的：
main（）方法中調用get_rpm_url_list（base_url）方法，獲取要下載的每個rpm包的具體的url地址。其中base_url即中科大基礎的鏡像源的地址，比如：http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/，這個地址下有幾十個rpm包，get_rpm_url_list方法將每個rpm包的url地址拼出來並返回。
multi_process（rpm_url_list）啟動多進程方法，在該方法中，會調用多線程方法。該方法啟動4個多進程，將上面方法得到的rpm包的url地址進行分組，分成4組，然後每一個組中的rpm包再最後由不同的線程去執行。從而達到了多進程+多線程的配合使用。
代碼還有需要改進的地方，比如多進程啟動的進程個數和rpm包的url地址分組是硬編碼，這個還需要改進，畢竟，不同的機器，適合同時啟動的進程個數是不同的。