多執行緒可簡單理解為同時執行多個任務。本文跟大家分享Python 多執行緒Threading初學教學實例詳解，有興趣的朋友一起學習吧
1.1 什麼是多執行緒Threading
多執行緒可簡單理解為同時執行多個任務。
多行程和多執行緒都可以執行多個任務，執行緒是行程的一部分。線程的特點是線程之間可以共享內存和變量，資源消耗少（不過在Unix環境中，多進程和多線程資源調度消耗差距不明顯，Unix調度較快），缺點是線程之間的同步和加鎖比較麻煩。
1.2 新增執行緒Thread
導入模組
import threading
取得已啟動的執行緒數
threading.active_count()
查看所有執行緒資訊
threading.enumerate()
查看現在正在執行的執行緒
threading.current_thread()
新增線程，threading.Thread()接收參數target代表這個執行緒要完成的任務，需自行定義
def thread_job(): print('This is a thread of %s' % threading.current_thread()) def main(): thread = threading.Thread(target=thread_job,) # 定义线程 thread.start() # 让线程开始工作 if __name__ == '__main__': main()
1.3 join 功能
#因為執行緒是同時進行的，使用join功能可讓執行緒完成後再進行下一步操作，即阻塞呼叫線程，直到佇列中的所有任務都被處理掉。
import threading
import time
def thread_job():
print('T1 start\n')
for i in range(10):
time.sleep(0.1)
print('T1 finish\n')
def T2_job():
print('T2 start\n')
print('T2 finish\n')
def main():
added_thread=threading.Thread(target=thread_job,name='T1')
thread2=threading.Thread(target=T2_job,name='T2')
added_thread.start()
#added_thread.join()
thread2.start()
#thread2.join()
print('all done\n')
if __name__=='__main__':
main()範例如上所示，當不使用join功能的時候，結果如下圖所示：
執行了join功能之後，T1運行完之後才執行T2，之後再執行print（'all done'）
##1.4 儲存程序結果queue
queue是python標準函式庫中的執行緒安全的佇列（FIFO）實作,提供了一個適用於多執行緒程式設計的先進先出的資料結構，也就是佇列，用來在生產者和消費者執行緒之間的訊息傳遞 （1）基本FIFO佇列class queue.Queue(maxsize=0)
class queue.LifoQueue(maxsize=0)
class queue.PriorityQueue(maxsize=0)
import threading
import time
from queue import Queue
def job(l,q):
for i in range(len(l)):
l[i]=l[i]**2
q.put(l)
def multithreading():
q=Queue()
threads=[]
data=[[1,2,3],[3,4,5],[4,5,6],[5,6,7]]
for i in range(4):
t=threading.Thread(target=job,args=(data[i],q))
t.start()
threads.append(t)
for thread in threads:
thread.join()
results=[]
for _ in range(4):
results.append(q.get())
print(results)
if __name__=='__main__':
multithreading()
Global Interpreter Lock全域解釋器鎖，python的執行由python虛擬機（也成解釋器主循環）控制，GIL的控制對python虛擬機的訪問，保證在任意時刻，只有一個執行緒在解釋器中運行。在多執行緒環境中能，python虛擬機器按照以下方式執行：
#1.設定GIL
#2.切換到一個執行緒去執行
3.執行：
a.指定數量的字節碼指令，或
b.線程主動讓出控制（可以調用time.sleep(0)）
4.把線程設置為睡眠狀態
5.解鎖GIL
6.重複1-5
在呼叫外部程式碼（如C/C++擴充函數）的時候，GIL將會被鎖定，直到這個函數結束為止（由於在這段期間沒有python的字節碼被運行，所以不會做線程切換）。
下面為影片中所舉例的程式碼，將一個數擴大4倍，分為正常方式、以及分配給4個執行緒去做，發現耗時其實並沒有相差太多量級。
import threading
from queue import Queue
import copy
import time
def job(l, q):
res = sum(l)
q.put(res)
def multithreading(l):
q = Queue()
threads = []
for i in range(4):
t = threading.Thread(target=job, args=(copy.copy(l), q), name='T%i' % i)
t.start()
threads.append(t)
[t.join() for t in threads]
total = 0
for _ in range(4):
total += q.get()
print(total)
def normal(l):
total = sum(l)
print(total)
if __name__ == '__main__':
l = list(range(1000000))
s_t = time.time()
normal(l*4)
print('normal: ',time.time()-s_t)
s_t = time.time()
multithreading(l)
print('multithreading: ', time.time()-s_t)#
1.6 线程锁 Lock
如果线程1得到了结果，想要让线程2继续使用1的结果进行处理，则需要对1lock，等到1执行完，再开始执行线程2。一般来说对share memory即对共享内存进行加工处理时会用到lock。
import threading
def job1():
global A, lock #全局变量
lock.acquire() #开始lock
for i in range(10):
A += 1
print('job1', A)
lock.release() #释放
def job2():
global A, lock
lock.acquire()
for i in range(10):
A += 10
print('job2', A)
lock.release()
if __name__ == '__main__':
lock = threading.Lock()
A = 0
t1 = threading.Thread(target=job1)
t2 = threading.Thread(target=job2)
t1.start()
t2.start()
t1.join()
t2.join()运行结果如下所示：
总结
以上是Python中關於多執行緒Threading入門簡介的詳細內容。更多資訊請關注PHP中文網其他相關文章！
