⑴ python多線程
有很多的場景中的事情是同時進行的,比如開車的時候,手和腳共同來駕駛汽車,再比如唱歌跳舞也是同時進行的
結果:
• _thread
• threading(推薦使用)
結果:
threading.enumerate() 可查看當前正在運行的線程
結果:
結果:
結果:
結果: 出現資源競爭導致計算結果不正確
(1)當多個線程幾乎同時修改某一個共享數據的時候,需要進行同步控制
(2)線程同步能夠保證多個線程安全訪問資源,最簡單的同步機制是引入互斥鎖
(3)互斥鎖為資源引入一個狀態: 鎖定/非鎖定
(4)某個線程要更愛共享數據時,先將其鎖定,此時資源的狀態為"鎖定", 其他線程不能更改;直到該線程釋放資源,將資源狀態變為"非鎖定"
(5)互斥鎖保證了每次只有一個線程進行寫入操作,從而保證了多線程情況下數據的正確性
結果: 計算正確
結果:卡住了
在線程間共享多個資源的時候,如果兩個線程分別戰友一部分資源且同時等待對方資源,就會造成死鎖
(1)程序設計時避免(銀行家演算法)
(2)添加超時時間
⑵ python的with關鍵字
with表達式其實是try-finally的簡寫形式。但是又不是全相同。
其中的context是一個表達式，返回的是一個對象，var用來保存context表達式返回的對象，可以有單個或者多個返回值。
表達式open('1.txt')返回是一個_io.TextIOWrapper 類型的變數用f接受到。在with語句塊中就可以使用這個變數操作文件。執行with這個結構之後。f會自動關閉。相當於自帶了一個finally。
但是with本身並沒有異常捕獲的功能，但是如果發生了運行時異常，它照樣可以關閉文件釋放資源。
這個例子可以看出with沒有捕獲異常的功能。
這個例子可以看出with發生了異常也會關閉程序。
自定義類必須包含上述幾個方法才能正確使用with關鍵字。
下面我們故意加一個NameError
即使程序發生了錯誤，python解釋器終止了我們的程序，但是我們的類 還是順利關閉了。
1、文件操作。2、進程線程之間互斥對象。3、支持上下文其他對象
⑶ 在Python中重新啟動一個線程問題，怎麼解決
給出一個簡單的線程互斥的例子，例子中同時啟動兩個線程，a線程獲取鎖，獲取後b線程處於等待狀態，只有a線程釋放鎖，才能進入b線程。代碼如下：
importthreading
importtime
defhello(name):
print(name+'started')
lock.acquire(True)
time.sleep(50)
print(name+'running')
lock.release()
print(name+'exit')
lock=threading.Lock()
a=threading.Thread(target=hello,args='a')
b=threading.Thread(target=hello,args='b')
a.start()
b.start()
⑷ 深入解析Python中的線程同步方法
深入解析Python中的線程同步方法
同步訪問共享資源
在使用線程的時候，一個很重要的問題是要避免多個線程對同一變數或其它資源的訪問沖突。一旦你稍不留神，重疊訪問、在多個線程中修改（共享資源）等這些操作會導致各種各樣的問題；更嚴重的是，這些問題一般只會在比較極端（比如高並發、生產伺服器、甚至在性能更好的硬體設備上）的情況下才會出現。
比如有這樣一個情況：需要追蹤對一事件處理的次數
counter = 0
def process_item(item):
global counter
... do something with item ...
counter += 1
如果你在多個線程中同時調用這個函數，你會發現counter的值不是那麼准確。在大多數情況下它是對的，但有時它會比實際的少幾個。
出現這種情況的原因是，計數增加操作實際上分三步執行:
解釋器獲取counter的當前值計算新值將計算的新值回寫counter變數
考慮一下這種情況：在當前線程獲取到counter值後，另一個線程搶佔到了CPU，然後同樣也獲取到了counter值，並進一步將counter值重新計算並完成回寫；之後時間片重新輪到當前線程（這里僅作標識區分，並非實際當前），此時當前線程獲取到counter值還是原來的，完成後續兩步操作後counter的值實際只加上1。
另一種常見情況是訪問不完整或不一致狀態。這類情況主要發生在一個線程正在初始化或更新數據時，另一個進程卻嘗試讀取正在更改的數據。
原子操作
實現對共享變數或其它資源的同步訪問最簡單的方法是依靠解釋器的原子操作。原子操作是在一步完成執行的操作，在這一步中其它線程無法獲得該共享資源。
通常情況下，這種同步方法只對那些只由單個核心數據類型組成的共享資源有效，譬如，字元串變數、數字、列表或者字典等。下面是幾個線程安全的操作：
讀或者替換一個實例屬性讀或者替換一個全局變數從列表中獲取一項元素原位修改一個列表（例如：使用append增加一個列表項）從字典中獲取一項元素原位修改一個字典（例如：增加一個字典項、調用clear方法）
注意，上面提到過，對一個變數或者屬性進行讀操作，然後修改它，最終將其回寫不是線程安全的。因為另外一個線程會在這個線程讀完卻沒有修改或回寫完成之前更改這個共享變數/屬性。
鎖
鎖是Python的threading模塊提供的最基本的同步機制。在任一時刻，一個鎖對象可能被一個線程獲取，或者不被任何線程獲取。如果一個線程嘗試去獲取一個已經被另一個線程獲取到的鎖對象，那麼這個想要獲取鎖對象的線程只能暫時終止執行直到鎖對象被另一個線程釋放掉。
鎖通常被用來實現對共享資源的同步訪問。為每一個共享資源創建一個Lock對象，當你需要訪問該資源時，調用acquire方法來獲取鎖對象（如果其它線程已經獲得了該鎖，則當前線程需等待其被釋放），待資源訪問完後，再調用release方法釋放鎖：
lock = Lock()
lock.acquire() #: will block if lock is already held
... access shared resource
lock.release()
注意，即使在訪問共享資源的過程中出錯了也應該釋放鎖，可以用try-finally來達到這一目的：
lock.acquire()
try:
... access shared resource
finally:
lock.release() #: release lock, no matter what
在Python 2.5及以後的版本中，你可以使用with語句。在使用鎖的時候，with語句會在進入語句塊之前自動的獲取到該鎖對象，然後在語句塊執行完成後自動釋放掉鎖：
from __future__ import with_statement #: 2.5 only
with lock:
... access shared resource
acquire方法帶一個可選的等待標識，它可用於設定當有其它線程佔有鎖時是否阻塞。如果你將其值設為False，那麼acquire方法將不再阻塞，只是如果該鎖被佔有時它會返回False:
if not lock.acquire(False):
... 鎖資源失敗
else:
try:
... access shared resource
finally:
lock.release()
你可以使用locked方法來檢查一個鎖對象是否已被獲取，注意不能用該方法來判斷調用acquire方法時是否會阻塞，因為在locked方法調用完成到下一條語句（比如acquire）執行之間該鎖有可能被其它線程佔有。
if not lock.locked():
#: 其它線程可能在下一條語句執行之前佔有了該鎖
lock.acquire() #: 可能會阻塞
簡單鎖的缺點
標準的鎖對象並不關心當前是哪個線程佔有了該鎖；如果該鎖已經被佔有了，那麼任何其它嘗試獲取該鎖的線程都會被阻塞，即使是佔有鎖的這個線程。考慮一下下面這個例子：
lock = threading.Lock()
def get_first_part():
lock.acquire()
try:
... 從共享對象中獲取第一部分數據
finally:
lock.release()
return data
def get_second_part():
lock.acquire()
try:
... 從共享對象中獲取第二部分數據
finally:
lock.release()
return data
示例中，我們有一個共享資源，有兩個分別取這個共享資源第一部分和第二部分的函數。兩個訪問函數都使用了鎖來確保在獲取數據時沒有其它線程修改對應的共享數據。
現在，如果我們想添加第三個函數來獲取兩個部分的數據，我們將會陷入泥潭。一個簡單的方法是依次調用這兩個函數，然後返回結合的結果：
def get_both_parts():
first = get_first_part()
seconde = get_second_part()
return first, second
這里的問題是，如有某個線程在兩個函數調用之間修改了共享資源，那麼我們最終會得到不一致的數據。最明顯的解決方法是在這個函數中也使用lock:
def get_both_parts():
lock.acquire()
try:
first = get_first_part()
seconde = get_second_part()
finally:
lock.release()
return first, second
然而，這是不可行的。裡面的兩個訪問函數將會阻塞，因為外層語句已經佔有了該鎖。為了解決這個問題，你可以通過使用標記在訪問函數中讓外層語句釋放鎖，但這樣容易失去控制並導致出錯。幸運的是，threading模塊包含了一個更加實用的鎖實現：re-entrant鎖。
Re-Entrant Locks (RLock)
RLock類是簡單鎖的另一個版本，它的特點在於，同一個鎖對象只有在被其它的線程佔有時嘗試獲取才會發生阻塞；而簡單鎖在同一個線程中同時只能被佔有一次。如果當前線程已經佔有了某個RLock鎖對象，那麼當前線程仍能再次獲取到該RLock鎖對象。
lock = threading.Lock()
lock.acquire()
lock.acquire() #: 這里將會阻塞
lock = threading.RLock()
lock.acquire()
lock.acquire() #: 這里不會發生阻塞
RLock的主要作用是解決嵌套訪問共享資源的問題，就像前面描述的示例。要想解決前面示例中的問題，我們只需要將Lock換為RLock對象，這樣嵌套調用也會OK.
lock = threading.RLock()
def get_first_part():
... see above
def get_second_part():
... see above
def get_both_parts():
... see above
這樣既可以單獨訪問兩部分數據也可以一次訪問兩部分數據而不會被鎖阻塞或者獲得不一致的數據。
注意RLock會追蹤遞歸層級，因此記得在acquire後進行release操作。
Semaphores
信號量是一個更高級的鎖機制。信號量內部有一個計數器而不像鎖對象內部有鎖標識，而且只有當佔用信號量的線程數超過信號量時線程才阻塞。這允許了多個線程可以同時訪問相同的代碼區。
semaphore = threading.BoundedSemaphore()
semaphore.acquire() #: counter減小
... 訪問共享資源
semaphore.release() #: counter增大
當信號量被獲取的時候，計數器減小；當信號量被釋放的時候，計數器增大。當獲取信號量的時候，如果計數器值為0，則該進程將阻塞。當某一信號量被釋放，counter值增加為1時，被阻塞的線程（如果有的話）中會有一個得以繼續運行。
信號量通常被用來限制對容量有限的資源的訪問，比如一個網路連接或者資料庫伺服器。在這類場景中，只需要將計數器初始化為最大值，信號量的實現將為你完成剩下的事情。
max_connections = 10
semaphore = threading.BoundedSemaphore(max_connections)
如果你不傳任何初始化參數，計數器的值會被初始化為1.
Python的threading模塊提供了兩種信號量實現。Semaphore類提供了一個無限大小的信號量，你可以調用release任意次來增大計數器的值。為了避免錯誤出現，最好使用BoundedSemaphore類，這樣當你調用release的次數大於acquire次數時程序會出錯提醒。
線程同步
鎖可以用在線程間的同步上。threading模塊包含了一些用於線程間同步的類。
Events
一個事件是一個簡單的同步對象，事件表示為一個內部標識(internal flag)，線程等待這個標識被其它線程設定，或者自己設定、清除這個標識。
event = threading.Event()
#: 一個客戶端線程等待flag被設定
event.wait()
#: 服務端線程設置或者清除flag
event.set()
event.clear()
一旦標識被設定，wait方法就不做任何處理（不會阻塞），當標識被清除時，wait將被阻塞直至其被重新設定。任意數量的線程可能會等待同一個事件。
Conditions
條件是事件對象的高級版本。條件表現為程序中的某種狀態改變，線程可以等待給定條件或者條件發生的信號。
下面是一個簡單的生產者/消費者實例。首先你需要創建一個條件對象：
#: 表示一個資源的附屬項
condition = threading.Condition()
生產者線程在通知消費者線程有新生成資源之前需要獲得條件：
#: 生產者線程
... 生產資源項
condition.acquire()
... 將資源項添加到資源中
condition.notify() #: 發出有可用資源的信號
condition.release()
消費者必須獲取條件（以及相關聯的鎖），然後嘗試從資源中獲取資源項：
#: 消費者線程
condition.acquire()
while True:
...從資源中獲取資源項
if item:
break
condition.wait() #: 休眠，直至有新的資源
condition.release()
... 處理資源
wait方法釋放了鎖，然後將當前線程阻塞，直到有其它線程調用了同一條件對象的notify或者notifyAll方法，然後又重新拿到鎖。如果同時有多個線程在等待，那麼notify方法只會喚醒其中的一個線程，而notifyAll則會喚醒全部線程。
為了避免在wait方法處阻塞，你可以傳入一個超時參數，一個以秒為單位的浮點數。如果設置了超時參數，wait將會在指定時間返回，即使notify沒被調用。一旦使用了超時，你必須檢查資源來確定發生了什麼。
注意，條件對象關聯著一個鎖，你必須在訪問條件之前獲取這個鎖；同樣的，你必須在完成對條件的訪問時釋放這個鎖。在生產代碼中，你應該使用try-finally或者with.
可以通過將鎖對象作為條件構造函數的參數來讓條件關聯一個已經存在的鎖，這可以實現多個條件公用一個資源：
lock = threading.RLock()
condition_1 = threading.Condition(lock)
condition_2 = threading.Condition(lock)
互斥鎖同步
我們先來看一個例子：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time, threading
# 假定這是你的銀行存款:
balance = 0
muxlock = threading.Lock()
def change_it(n):
# 先存後取，結果應該為0:
global balance
balance = balance + n
balance = balance - n
def run_thread(n):
# 循環次數一旦多起來，最後的數字就變成非0
for i in range(100000):
change_it(n)
t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t3 = threading.Thread(target=run_thread, args=(9,))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print balance
結果 :
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
61
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
24
上面的例子引出了多線程編程的最常見問題：數據共享。當多個線程都修改某一個共享數據的時候，需要進行同步控制。
線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖為資源引入一個狀態：鎖定/非鎖定。某個線程要更改共享數據時，先將其鎖定，此時資源的狀態為「鎖定」，其他線程不能更改；直到該線程釋放資源，將資源的狀態變成「非鎖定」，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作，從而保證了多線程情況下數據的正確性。
threading模塊中定義了Lock類，可以方便的處理鎖定：
#創建鎖mutex = threading.Lock()
#鎖定mutex.acquire([timeout])
#釋放mutex.release()
其中，鎖定方法acquire可以有一個超時時間的可選參數timeout。如果設定了timeout，則在超時後通過返回值可以判斷是否得到了鎖，從而可以進行一些其他的處理。
使用互斥鎖實現上面的例子的代碼如下：
balance = 0
muxlock = threading.Lock()
def change_it(n):
# 獲取鎖，確保只有一個線程操作這個數
muxlock.acquire()
global balance
balance = balance + n
balance = balance - n
# 釋放鎖，給其他被阻塞的線程繼續操作
muxlock.release()
def run_thread(n):
for i in range(10000):
change_it(n)
加鎖後的結果，就能確保數據正確：
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
⑸ python有了GIL，為什麼還有線程鎖
在python的原始解釋器CPython中存在著GIL（Global Interpreter Lock，全局解釋器鎖），因此在解釋執行python代碼時，會產生互斥鎖來限制線程對共享資源的訪問，直到解釋器遇到I/O操作或者操作次數達到一定數目時才會釋放GIL。
所以，雖然CPython的線程庫直接封裝了系統的原生線程，但CPython整體作為一個進程，同一時間只會有一個獲得GIL的線程在跑，其他線程則處於等待狀態。這就造成了即使在多核CPU中，多線程也只是做著分時切換而已。
不過muiltprocessing的出現，已經可以讓多進程的python代碼編寫簡化到了類似多線程的程度了。
⑹ Python多線程總結
在實際處理數據時，因系統內存有限，我們不可能一次把所有數據都導出進行操作，所以需要批量導出依次操作。為了加快運行，我們會採用多線程的方法進行數據處理， 以下為我總結的多線程批量處理數據的模板：
主要分為三大部分：
共分4部分對多線程的內容進行總結。
先為大家介紹線程的相關概念:
在飛車程序中，如果沒有多線程，我們就不能一邊聽歌一邊玩飛車，聽歌與玩 游戲 不能並行；在使用多線程後，我們就可以在玩 游戲 的同時聽背景音樂。在這個例子中啟動飛車程序就是一個進程，玩 游戲 和聽音樂是兩個線程。
Python 提供了 threading 模塊來實現多線程:
因為新建線程系統需要分配資源、終止線程系統需要回收資源，所以如果可以重用線程，則可以減去新建/終止的開銷以提升性能。同時，使用線程池的語法比自己新建線程執行線程更加簡潔。
Python 為我們提供了 ThreadPoolExecutor 來實現線程池，此線程池默認子線程守護。它的適應場景為突發性大量請求或需要大量線程完成任務，但實際任務處理時間較短。
其中 max_workers 為線程池中的線程個數，常用的遍歷方法有 map 和 submit+as_completed 。根據業務場景的不同，若我們需要輸出結果按遍歷順序返回，我們就用 map 方法，若想誰先完成就返回誰，我們就用 submit+as_complete 方法。
我們把一個時間段內只允許一個線程使用的資源稱為臨界資源，對臨界資源的訪問，必須互斥的進行。互斥，也稱間接制約關系。線程互斥指當一個線程訪問某臨界資源時，另一個想要訪問該臨界資源的線程必須等待。當前訪問臨界資源的線程訪問結束，釋放該資源之後，另一個線程才能去訪問臨界資源。鎖的功能就是實現線程互斥。
我把線程互斥比作廁所包間上大號的過程，因為包間里只有一個坑，所以只允許一個人進行大號。當第一個人要上廁所時，會將門上上鎖，這時如果第二個人也想大號，那就必須等第一個人上完，將鎖解開後才能進行，在這期間第二個人就只能在門外等著。這個過程與代碼中使用鎖的原理如出一轍，這里的坑就是臨界資源。 Python 的 threading 模塊引入了鎖。 threading 模塊提供了 Lock 類，它有如下方法加鎖和釋放鎖：
我們會發現這個程序只會列印「第一道鎖」，而且程序既沒有終止，也沒有繼續運行。這是因為 Lock 鎖在同一線程內第一次加鎖之後還沒有釋放時，就進行了第二次 acquire 請求，導致無法執行 release ，所以鎖永遠無法釋放，這就是死鎖。如果我們使用 RLock 就能正常運行，不會發生死鎖的狀態。
在主線程中定義 Lock 鎖，然後上鎖，再創建一個子 線程t 運行 main 函數釋放鎖，結果正常輸出，說明主線程上的鎖，可由子線程解鎖。
如果把上面的鎖改為 RLock 則報錯。在實際中設計程序時，我們會將每個功能分別封裝成一個函數，每個函數中都可能會有臨界區域，所以就需要用到 RLock 。
一句話總結就是 Lock 不能套娃， RLock 可以套娃； Lock 可以由其他線程中的鎖進行操作， RLock 只能由本線程進行操作。
⑺ python線程怎麼銷毀
【Python】線程的創建、執行、互斥、同步、銷毀
還是《【Java】利用synchronized(this)完成線程的臨界區》（點擊打開鏈接）、《【Linux】線程互斥》（點擊打開鏈接）、《【C++】Windows線程的創建、執行、互斥、同步、銷毀》（點擊打開鏈接）中的設置多個線程對一個ticket進行自減操作，用來說明Python中多線程的運用，涉及的創建、執行、互斥、同步、銷毀問題。
運行結果如下，還是差不多，運行三次，每次的運行結果，每個線程最終的得票結果是不同的，但是4個線程最終「得票」的總和為 ticket 最初設置的值為100000，證明這4個線程成功實現了互斥。
雖然每次運行結果是不同，但是可以看得出每次運行結果大抵上是平均的。貌似Python對線程作系統資源的處理，比Java要好。
然而，Python總要實現多線程，代碼並不像想像中簡單，具體如下：
[python] view plain print?在CODE上查看代碼片派生到我的代碼片
# -*-coding:utf-8-*-
import threading;
mutex_lock = threading.RLock(); # 互斥鎖的聲明
ticket = 100000; # 總票數
# 用於統計各個線程的得票數
ticket_for_thread1 = 0;
ticket_for_thread2 = 0;
ticket_for_thread3 = 0;
ticket_for_thread4 = 0;
class myThread(threading.Thread): # 線程處理函數
def __init__(self, name):
threading.Thread.__init__(self); # 線程類必須的初始化
self.thread_name = name; # 將傳遞過來的name構造到類中的name
def run(self):
# 聲明在類中使用全局變數
global mutex_lock;
global ticket;
global ticket_for_thread1;
global ticket_for_thread2;
global ticket_for_thread3;
global ticket_for_thread4;
while 1:
mutex_lock.acquire(); # 臨界區開始，互斥的開始
# 僅能有一個線程↓↓↓↓↓↓↓↓↓↓↓↓
if ticket > 0:
ticket -= 1;
# 統計哪到線程拿到票
print "%s搶到了票！票還剩餘：%d。" % (self.thread_name, ticket);
if self.thread_name == "線程1":
ticket_for_thread1 += 1;
elif self.thread_name == "線程2":
ticket_for_thread2 += 1;
elif self.thread_name == "線程3":
ticket_for_thread3 += 1;
elif self.thread_name == "線程4":
ticket_for_thread4 += 1;
else:
break;
# 僅能有一個線程↑↑↑↑↑↑↑↑↑↑↑↑
mutex_lock.release(); # 臨界區結束，互斥的結束
mutex_lock.release(); # python在線程死亡的時候，不會清理已存在在線程函數的互斥鎖，必須程序猿自己主動清理
print "%s被銷毀了！" % (self.thread_name);
# 初始化線程
thread1 = myThread("線程1");
thread2 = myThread("線程2");
thread3 = myThread("線程3");
thread4 = myThread("線程4");
# 開啟線程
thread1.start();
thread2.start();
thread3.start();
thread4.start();
# 等到線程1、2、3、4結束才進行以下的代碼（同步）
thread1.join();
thread2.join();
thread3.join();
thread4.join();
print "票都搶光了，大家都散了吧！";
print "=========得票統計=========";
print "線程1：%d張" % (ticket_for_thread1);
print "線程2：%d張" % (ticket_for_thread2);
print "線程3：%d張" % (ticket_for_thread3);
print "線程4：%d張" % (ticket_for_thread4);
1、從上面的代碼可以看出，在Python2.7中要使用線程必須使用threading而不是古老的thread模塊。
如果你像網上部分遺留依舊的文章一樣，在Python2.7中使用thread來實現線程，至少在Eclipse的Pydev中會報錯：sys.excepthook is missing，lost sys.stderr如下圖所示：
所以必須使用現時Python建議使用的threading。
2、與其它編程語言類似，聲明一個互斥鎖，與一系列的得票數。之後，與Java同樣地，Python實現線程的函數，是要重寫一個類。而類中使用全局變數，則與同為腳本語言的php一樣《【php】global的使用與php的全局變數》（點擊打開鏈接），要用global才能使用這個全局變數，而不是C/C++可以直接使用。
3、需要注意的，Python需要在線程跑完class myThread(threading.Thread)這個類的def run(self)方法之前，必須自己手動清理互斥鎖，它不會像其它編程語言那樣，說線程跑完def run(self)方法，會自然而然地清理該線程被創建的互斥鎖。如果沒有最後一句手動清理互斥鎖，則會造成死鎖。
4、最後與其它編程語言一樣了，利用線程的join方法可以等待這個線程跑完def run(self)方法中的所有代碼，才執行之後的代碼，實現同步。否則主函數中的代碼，相當於與父線程。主函數開啟的線程，相當於其子線程，互不影響的。