線程是操作系統調度運算的最小單位，本文記錄python使用多線程的方法。
**線程（Thread）**也叫輕量級進程，是操作系統能夠進行運算調度的最小單位，它被包涵在進程之中，是進程中的實際運作單位。線程自己不擁有系統資源，只擁有一點兒在運行中必不可少的資源，但它可與同屬一個進程的其它線程共享進程所擁有的全部資源。一個線程可以創建和撤消另一個線程，同一進程中的多個線程之間可以並發執行。
線程在程序中是獨立的、並發的執行流。與分隔的進程相比，進程中線程之間的隔離程度要小，它們共享內存、文件句柄和其他進程應有的狀態。
因為線程的劃分尺度小於進程，使得多線程程序的並發性高。進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，從而極大地提高了程序的運行效率。
線程比進程具有更高的性能，這是由於同一個進程中的線程都有共性多個線程共享同一個進程的虛擬空間。線程共享的環境包括進程代碼段、進程的公有數據等，利用這些共享的數據，線程之間很容易實現通信。
操作系統在創建進程時，必須為該進程分配獨立的內存空間，並分配大量的相關資源，但創建線程則簡單得多。因此，使用多線程來實現並發比使用多進程的性能要高得多。
總結起來，使用多線程編程具有如下幾個優點：
普通創建方式
import threading
import time
def run(n):
print("task", n)
time.sleep(1)
print('2s')
time.sleep(1)
print('1s')
time.sleep(1)
print('0s')
time.sleep(1)
if __name__ == '__main__':
t1 = threading.Thread(target=run, args=("t1",))
t2 = threading.Thread(target=run, args=("t2",))
t1.start()
t2.start()
----------------------------------
>>> task t1
>>> task t2
>>> 2s
>>> 2s
>>> 1s
>>> 1s
>>> 0s
>>> 0s繼承threading.Thread來自定義線程類，其本質是重構Thread類中的run方法
import threading
import time
class MyThread(threading.Thread):
def __init__(self, n):
super(MyThread, self).__init__() # 重構run函數必須要寫
self.n = n
def run(self):
print("task", self.n)
time.sleep(1)
print('2s')
time.sleep(1)
print('1s')
time.sleep(1)
print('0s')
time.sleep(1)
if __name__ == "__main__":
t1 = MyThread("t1")
t2 = MyThread("t2")
t1.start()
t2.start()
----------------------------------
>>> task t1
>>> task t2
>>> 2s
>>> 2s
>>> 1s
>>> 1s
>>> 0s
>>> 0s我們看下面這個例子，這裡使用setDaemon(True)把所有的子線程都變成了主線程的守護線程，因此當主進程結束後，子線程也會隨之結束。所以當主線程結束後，整個程序就退出了。
import threading
import time
def run(n):
print("task", n)
time.sleep(1) #此時子線程停1s
print('3')
time.sleep(1)
print('2')
time.sleep(1)
print('1')
if __name__ == '__main__':
t = threading.Thread(target=run, args=("t1",))
t.setDaemon(True) #把子進程設置為守護線程，必須在start()之前設置
t.start()
print("end")
----------------------------------
>>> task t1
>>> end我們可以發現，設置守護線程之後，當主線程結束時，子線程也將立即結束，不再執行。
為了讓守護線程執行結束之後，主線程再結束，我們可以使用join方法，讓主線程等待子線程執行。
import threading
import time
def run(n):
print("task", n)
time.sleep(1) #此時子線程停1s
print('3')
time.sleep(1)
print('2')
time.sleep(1)
print('1')
if __name__ == '__main__':
t = threading.Thread(target=run, args=("t1",))
t.setDaemon(True) #把子進程設置為守護線程，必須在start()之前設置
t.start()
t.join() # 設置主線程等待子線程結束
print("end")
----------------------------------
>>> task t1
>>> 3
>>> 2
>>> 1
>>> end線程是進程的執行單元，進程是系統分配資源的最小單位，所以在同一個進程中的多線程是共享資源的。
import threading
import time
g_num = 100
def work1():
global g_num
for i in range(3):
g_num += 1
print("in work1 g_num is : %d" % g_num)
def work2():
global g_num
print("in work2 g_num is : %d" % g_num)
if __name__ == '__main__':
t1 = threading.Thread(target=work1)
t1.start()
time.sleep(1)
t2 = threading.Thread(target=work2)
t2.start()
----------------------------------
>>> in work1 g_num is : 103
>>> in work2 g_num is : 103由於線程之間是進行隨機調度，並且每個線程可能只執行n條執行之後，當多個線程同時修改同一條數據時可能會出現髒數據，所以，出現了線程鎖，即同一時刻允許一個線程執行操作。線程鎖用於鎖定資源，你可以定義多個鎖, 像下面的代碼, 當你需要獨占某一資源時，任何一個鎖都可以鎖這個資源，就好比你用不同的鎖都可以把相同的一個門鎖住是一個道理。
由於線程之間是進行隨機調度，如果有多個線程同時操作一個對象，如果沒有很好地保護該對象，會造成程序結果的不可預期，我們也稱此為“線程不安全”。
為了方式上面情況的發生，就出現了互斥鎖(Lock)
from threading import Thread,Lock
import os,time
def work():
global n
lock.acquire()
temp=n
time.sleep(0.1)
n=temp-1
lock.release()
if __name__ == '__main__':
lock=Lock()
n=100
l=[]
for i in range(100):
p=Thread(target=work)
l.append(p)
p.start()
for p in l:
p.join()RLcok類的用法和Lock類一模一樣，但它支持嵌套，在多個鎖沒有釋放的時候一般會使用RLcok類。
import threading
import time
def Func(lock):
global gl_num
lock.acquire()
gl_num += 1
time.sleep(1)
print(gl_num)
lock.release()
if __name__ == '__main__':
gl_num = 0
lock = threading.RLock()
for i in range(10):
t = threading.Thread(target=Func, args=(lock,))
t.start()互斥鎖同時只允許一個線程更改數據，而Semaphore是同時允許一定數量的線程更改數據 ，比如廁所有3個坑，那最多只允許3個人上廁所，後面的人只能等裡面有人出來了才能再進去。
import threading
import time
def run(n, semaphore):
semaphore.acquire() #加鎖
time.sleep(1)
print("run the thread:%s\n" % n)
semaphore.release() #釋放
if __name__ == '__main__':
num = 0
semaphore = threading.BoundedSemaphore(5) # 最多允許5個線程同時運行
for i in range(22):
t = threading.Thread(target=run, args=("t-%s" % i, semaphore))
t.start()
while threading.active_count() != 1:
pass # print threading.active_count()
else:
print('-----all threads done-----')python線程的事件用於主線程控制其他線程的執行，事件是一個簡單的線程同步對象，其主要提供以下幾個方法：
事件處理的機制：全局定義了一個“Flag”，當flag值為“False”，那麼event.wait()就會阻塞，當flag值為“True”，那麼event.wait()便不再阻塞。
#利用Event類模擬紅綠燈
import threading
import time
event = threading.Event()
def lighter():
count = 0
event.set() #初始值為綠燈
while True:
if 5 < count <=10 :
event.clear() # 紅燈，清除標志位
print("\33[41;1mred light is on...\033[0m")
elif count > 10:
event.set() # 綠燈，設置標志位
count = 0
else:
print("\33[42;1mgreen light is on...\033[0m")
time.sleep(1)
count += 1
def car(name):
while True:
if event.is_set(): #判斷是否設置了標志位
print("[%s] running..."%name)
time.sleep(1)
else:
print("[%s] sees red light,waiting..."%name)
event.wait()
print("[%s] green light is on,start going..."%name)
light = threading.Thread(target=lighter,)
light.start()
car = threading.Thread(target=car,args=("MINI",))
car.start()threading 執行函數後無法執行 return，在需要返回值的函數中有些不方便
解決這個問題的核心思路是創建全局變量，收集線程們運行後返回的結果
import threading
def num_adder(num, res):
res[0] += num
if __name__ == '__main__':
threading_list = list()
result = [0]
for num in range(100):
t = threading.Thread(target=num_adder, args=(num+1, result, ))
threading_list.append(t)
t.start()
for t in threading_list:
t.join()
print(f"{result}")
pass
輸出 1 到 100 的累加和值 5050 由於python的 GIL 機制，使得我們只能使用單核的CPU，同一時間只會有一個線程操作數據，反而不用擔心線程安全的問題（不過保險起見還是加個鎖的好）
在非python環境中，單核情況下，同時只能有一個任務執行。多核時可以支持多個線程同時執行。但是在python中，無論有多少核，同時只能執行一個線程。究其原因，這就是由於GIL的存在導致的。
GIL的全稱是Global Interpreter Lock(全局解釋器鎖)，來源是python設計之初的考慮，為了數據安全所做的決定。某個線程想要執行，必須先拿到GIL，我們可以把GIL看作是“通行證”，並且在一個python進程中，GIL只有一個。拿不到通行證的線程，就不允許進入CPU執行。GIL只在cpython中才有，因為cpython調用的是c語言的原生線程，所以他不能直接操作cpu，只能利用GIL保證同一時間只能有一個線程拿到數據。而在pypy和jpython中是沒有GIL的。
Python多線程的工作過程： python在使用多線程的時候，調用的是c語言的原生線程。
python針對不同類型的代碼執行效率也是不同的：
1、CPU密集型代碼(各種循環處理、計算等等)，在這種情況下，由於計算工作多，ticks計數很快就會達到阈值，然後觸發GIL的釋放與再競爭（多個線程來回切換當然是需要消耗資源的），所以python下的多線程對CPU密集型代碼並不友好。 2、IO密集型代碼(文件處理、網絡爬蟲等涉及文件讀寫的操作)，多線程能夠有效提升效率(單線程下有IO操作會進行IO等待，造成不必要的時間浪費，而開啟多線程能在線程A等待時，自動切換到線程B，可以不浪費CPU的資源，從而能提升程序執行效率)。所以python的多線程對IO密集型代碼比較友好。
使用建議？
python下想要充分利用多核CPU，就用多進程。因為每個進程有各自獨立的GIL，互不干擾，這樣就可以真正意義上的並行執行，在python中，多進程的執行效率優於多線程(僅僅針對多核CPU而言)。
GIL在python中的版本差異：
1、在python2.x裡，GIL的釋放邏輯是當前線程遇見IO操作或者ticks計數達到100時進行釋放。（ticks可以看作是python自身的一個計數器，專門做用於GIL，每次釋放後歸零，這個計數可以通過sys.setcheckinterval 來調整）。而每次釋放GIL鎖，線程進行鎖競爭、切換線程，會消耗資源。並且由於GIL鎖存在，python裡一個進程永遠只能同時執行一個線程(拿到GIL的線程才能執行)，這就是為什麼在多核CPU上，python的多線程效率並不高。 2、在python3.x中，GIL不使用ticks計數，改為使用計時器（執行時間達到阈值後，當前線程釋放GIL），這樣對CPU密集型程序更加友好，但依然沒有解決GIL導致的同一時間只能執行一個線程的問題，所以效率依然不盡如人意。
