當(dāng)前位置：首頁(yè) > 编程资源 > 编程问答 >内容正文

编程问答

Day39：threading模块、ThreadLocal

發(fā)布時(shí)間：2023/12/10 编程问答 39 豆豆

生活随笔收集整理的這篇文章主要介紹了 Day39：threading模块、ThreadLocal 小編覺得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.

一、threading模塊

1、線程對(duì)象的創(chuàng)建

1.1 Thread類直接創(chuàng)建

import threading import timedef countNum(n): # 定義某個(gè)線程要運(yùn)行的函數(shù)print("running on number:%s" %n)time.sleep(3)if __name__ == '__main__':t1 = threading.Thread(target=countNum,args=(23,)) #生成一個(gè)線程實(shí)例t2 = threading.Thread(target=countNum,args=(34,))t1.start() #啟動(dòng)線程t2.start()print("ending!")

1.2 Thread類繼承式創(chuàng)建

#繼承Thread式創(chuàng)建import threading import timeclass MyThread(threading.Thread):def __init__(self,num):threading.Thread.__init__(self)self.num=numdef run(self):print("running on number:%s" %self.num)time.sleep(3)t1=MyThread(56) t2=MyThread(78)t1.start() t2.start() print("ending")

2、Thread類的實(shí)例方法

2.1 join() 和 steDaemon()

# join()：在子線程完成運(yùn)行之前，這個(gè)子線程的父線程將一直被阻塞。# setDaemon(True)：'''將線程聲明為守護(hù)線程，必須在start() 方法調(diào)用之前設(shè)置，如果不設(shè)置為守護(hù)線程程序會(huì)被無(wú)限掛起。當(dāng)我們?cè)诔绦蜻\(yùn)行中，執(zhí)行一個(gè)主線程，如果主線程又創(chuàng)建一個(gè)子線程，主線程和子線程就分兵兩路，分別運(yùn)行，那么當(dāng)主線程完成想退出時(shí)，會(huì)檢驗(yàn)子線程是否完成。如果子線程未完成，則主線程會(huì)等待子線程完成后再退出。但是有時(shí)候我們需要的是只要主線程完成了，不管子線程是否完成，都要和主線程一起退出，這時(shí)就可以用setDaemon方法啦'''import threading from time import ctime,sleep import timedef Music(name):print ("Begin listening to {name}. {time}".format(name=name,time=ctime()))sleep(3)print("end listening {time}".format(time=ctime()))def Blog(title):print ("Begin recording the {title}. {time}".format(title=title,time=ctime()))sleep(5)print('end recording {time}'.format(time=ctime()))threads = []t1 = threading.Thread(target=Music,args=('FILL ME',)) t2 = threading.Thread(target=Blog,args=('',))threads.append(t1) threads.append(t2) if __name__ == '__main__':for t in threads:t.start()print ("all over %s" %ctime()) ''' 運(yùn)行結(jié)果 Begin listening to FILL ME. Tue Jul 18 16:15:06 2017 Begin recording the . Tue Jul 18 16:15:06 2017 all over Tue Jul 18 16:15:06 2017 end listening Tue Jul 18 16:15:09 2017 end recording Tue Jul 18 16:15:11 2017前三行瞬間執(zhí)行完畢，后兩行等待3秒和5秒執(zhí)行''' if __name__ == '__main__':for t in threads:t.setDaemon(True) #注意:一定在start之前設(shè)置t.start()print("all over %s" % ctime()) ''' 運(yùn)行結(jié)果： Begin listening to FILL ME. Tue Jul 18 16:31:23 2017 Begin recording the . Tue Jul 18 16:31:23 2017 all over Tue Jul 18 16:31:23 201每個(gè)線程都是守護(hù)線程，跟隨主線程一塊掛掉 ''' if __name__ == '__main__':# t2.setDaemon(True)for t in threads:# t.setDaemon(True) #注意:一定在start之前設(shè)置t.start()t1.join()print("all over %s" % ctime()) ''' 運(yùn)行結(jié)果： Begin listening to FILL ME. Tue Jul 18 16:34:41 2017 Begin recording the . Tue Jul 18 16:34:41 2017 end listening Tue Jul 18 16:34:44 2017 all over Tue Jul 18 16:34:44 2017 end recording Tue Jul 18 16:34:46 2017前兩行瞬間執(zhí)行完成后等待，第二三行一起執(zhí)行，最后一行最后出現(xiàn)。在t1.join()處阻塞，t1線程運(yùn)行完畢，主線程才繼續(xù)執(zhí)行。 ''' daemon A boolean value indicating whether this thread is a daemon thread (True) or not (False). This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False.The entire Python program exits when no alive non-daemon threads are left.當(dāng)daemon被設(shè)置為True時(shí)，如果主線程退出，那么子線程也將跟著退出，反之，子線程將繼續(xù)運(yùn)行，直到正常退出。 daemon

2.2 其他方法

Thread實(shí)例對(duì)象的方法# isAlive(): 返回線程是否活動(dòng)的。# getName(): 返回線程名。# setName(): 設(shè)置線程名。threading模塊提供的一些方法：# threading.currentThread(): 返回當(dāng)前的線程變量。# threading.enumerate(): 返回一個(gè)包含正在運(yùn)行的線程的list。正在運(yùn)行指線程啟動(dòng)后、結(jié)束前，不包括啟動(dòng)前和終止后的線程。# threading.activeCount(): 返回正在運(yùn)行的線程數(shù)量，與len(threading.enumerate())有相同的結(jié)果。

3、GIL（全局解釋器鎖）

''' 定義： In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)翻譯：在CPython中，全局解釋器鎖是一個(gè)互斥鎖，它可以防止多個(gè)本機(jī)線程同時(shí)執(zhí)行Python的編譯器。這個(gè)鎖是必需的，主要是因?yàn)镃Python的內(nèi)存管理不是線程安全的。(然而，由于GIL的存在，其他的特性已經(jīng)發(fā)展到依賴于它的保證。) '''

Python中的線程是操作系統(tǒng)的原生線程，Python虛擬機(jī)使用一個(gè)全局解釋器鎖（Global Interpreter Lock）來(lái)互斥線程對(duì)Python虛擬機(jī)的使用。為了支持多線程機(jī)制，一個(gè)基本的要求就是需要實(shí)現(xiàn)不同線程對(duì)共享資源訪問的互斥，所以引入了GIL。
GIL：在一個(gè)線程擁有了解釋器的訪問權(quán)之后，其他的所有線程都必須等待它釋放解釋器的訪問權(quán)，即使這些線程的下一條指令并不會(huì)互相影響。
在調(diào)用任何Python C API之前，要先獲得GIL
GIL缺點(diǎn)：多處理器退化為單處理器；優(yōu)點(diǎn)：避免大量的加鎖解鎖操作。

3.1 GIL的早期設(shè)計(jì)

Python支持多線程，而解決多線程之間數(shù)據(jù)完整性和狀態(tài)同步的最簡(jiǎn)單方法自然就是加鎖。于是有了GIL這把超級(jí)大鎖，而當(dāng)越來(lái)越多的代碼庫(kù)開發(fā)者接受了這種設(shè)定后，他們開始大量依賴這種特性（即默認(rèn)python內(nèi)部對(duì)象是thread-safe的，無(wú)需在實(shí)現(xiàn)時(shí)考慮額外的內(nèi)存鎖和同步操作）。慢慢的這種實(shí)現(xiàn)方式被發(fā)現(xiàn)是蛋疼且低效的。但當(dāng)大家試圖去拆分和去除GIL的時(shí)候，發(fā)現(xiàn)大量庫(kù)代碼開發(fā)者已經(jīng)重度依賴GIL而非常難以去除了。有多難？做個(gè)類比，像MySQL這樣的“小項(xiàng)目”為了把Buffer Pool Mutex這把大鎖拆分成各個(gè)小鎖也花了從5.5到5.6再到5.7多個(gè)大版為期近5年的時(shí)間，并且仍在繼續(xù)。MySQL這個(gè)背后有公司支持且有固定開發(fā)團(tuán)隊(duì)的產(chǎn)品走的如此艱難，那又更何況Python這樣核心開發(fā)和代碼貢獻(xiàn)者高度社區(qū)化的團(tuán)隊(duì)呢？

3.2 GIL的影響

無(wú)論你啟多少個(gè)線程，你有多少個(gè)cpu, Python在執(zhí)行一個(gè)進(jìn)程的時(shí)候會(huì)淡定的在同一時(shí)刻只允許一個(gè)線程運(yùn)行。
所以，python是無(wú)法利用多核CPU實(shí)現(xiàn)多線程的。
這樣，python對(duì)于計(jì)算密集型的任務(wù)開多線程的效率甚至不如串行(沒有大量切換)，但是，對(duì)于IO密集型的任務(wù)效率還是有顯著提升的。

?計(jì)算密集型

3.3 解決方案

用multiprocessing替代Thread multiprocessing庫(kù)的出現(xiàn)很大程度上是為了彌補(bǔ)thread庫(kù)因?yàn)镚IL而低效的缺陷。它完整的復(fù)制了一套thread所提供的接口方便遷移。唯一的不同就是它使用了多進(jìn)程而不是多線程。每個(gè)進(jìn)程有自己的獨(dú)立的GIL，因此也不會(huì)出現(xiàn)進(jìn)程之間的GIL爭(zhēng)搶。

#coding:utf8 from multiprocessing import Process import timedef counter():i = 0for _ in range(40000000):i = i + 1return Truedef main():l=[]start_time = time.time()for _ in range(2):t=Process(target=counter)t.start()l.append(t)#t.join()for t in l:t.join()end_time = time.time()print("Total time: {}".format(end_time - start_time))if __name__ == '__main__':main()'''py2.7:串行:6.1565990448 s并行:3.1639978885 spy3.5:串行:6.556925058364868 s并發(fā):3.5378448963165283 s''' 使用multiprocessing

當(dāng)然multiprocessing也不是萬(wàn)能良藥。它的引入會(huì)增加程序?qū)崿F(xiàn)時(shí)線程間數(shù)據(jù)通訊和同步的困難。就拿計(jì)數(shù)器來(lái)舉例子，如果我們要多個(gè)線程累加同一個(gè)變量，對(duì)于thread來(lái)說(shuō)，申明一個(gè)global變量，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由于進(jìn)程之間無(wú)法看到對(duì)方的數(shù)據(jù)，只能通過(guò)在主線程申明一個(gè)Queue，put再get或者用share memory的方法。這個(gè)額外的實(shí)現(xiàn)成本使得本來(lái)就非常痛苦的多線程程序編碼，變得更加痛苦了。

總結(jié)：因?yàn)镚IL的存在，只有IO Bound場(chǎng)景下得多線程會(huì)得到較好的性能 - 如果對(duì)并行計(jì)算性能較高的程序可以考慮把核心部分換成C模塊，或者索性用其他語(yǔ)言實(shí)現(xiàn) - GIL在較長(zhǎng)一段時(shí)間內(nèi)將會(huì)繼續(xù)存在，但是會(huì)不斷對(duì)其進(jìn)行改進(jìn)。

所以對(duì)于GIL，既然不能反抗，那就學(xué)會(huì)去享受它吧！

4、同步鎖（Lock）

import time import threading def addNum():global num #在每個(gè)線程中都獲取這個(gè)全局變量#num-=1temp=numtime.sleep(0.1)num =temp-1 # 對(duì)此公共變量進(jìn)行-1操作num = 100 #設(shè)定一個(gè)共享變量thread_list = []s=time.time() for i in range(100):t = threading.Thread(target=addNum)t.start()thread_list.append(t)for t in thread_list: #等待所有線程執(zhí)行完畢t.join()print('Result: ', num ,'cost time: ' ,time.time()-s) #運(yùn)行結(jié)果 #Result: 99 cost time: 0.11100625991821289

分析結(jié)果：

綠色框代表進(jìn)程，藍(lán)色框代表子線程，一共開了100個(gè)子線程（不包括主線程）。

開啟一個(gè)子線程并運(yùn)行后，temp被賦值為100，然后遇到阻塞，其他子線程搶到CPU進(jìn)行執(zhí)行，此時(shí)num沒有執(zhí)行－1操作，所以線程2 的temp也被賦值為100，然后遇到阻塞。其他線程搶CPU執(zhí)行。0.1秒的時(shí)間足夠100個(gè)線程都將temp賦值為100，然后再執(zhí)行－1操作。所以num = 100 - 1 ，到結(jié)束num=99。

解決方法：使用同步鎖對(duì)數(shù)據(jù)進(jìn)行保護(hù)

鎖通常被用來(lái)實(shí)現(xiàn)對(duì)共享資源的同步訪問。為每一個(gè)共享資源創(chuàng)建一個(gè)Lock對(duì)象，當(dāng)你需要訪問該資源時(shí)，調(diào)用acquire方法來(lái)獲取鎖對(duì)象（如果其它線程已經(jīng)獲得了該鎖，則當(dāng)前線程需等待其被釋放），待資源訪問完后，再調(diào)用release方法釋放鎖：

import threadingR=threading.Lock()R.acquire() ''' 對(duì)公共數(shù)據(jù)的操作 ''' R.release() import time import threading def addNum():global num #在每個(gè)線程中都獲取這個(gè)全局變量#num-=1R.acquire() #保護(hù)數(shù)據(jù)，串行執(zhí)行temp=numtime.sleep(0.1)num =temp-1 # 對(duì)此公共變量進(jìn)行-1操作R.release()num = 100 #設(shè)定一個(gè)共享變量 thread_list = []R=threading.Lock() #實(shí)例化鎖對(duì)象s=time.time() for i in range(100):t = threading.Thread(target=addNum)t.start()thread_list.append(t)for t in thread_list: #等待所有線程執(zhí)行完畢t.join()print('Result: ', num ,'cost time: ' ,time.time()-s) #運(yùn)行結(jié)果 #Result: 0 cost time: 10.023573398590088 ''' 1、為什么有了GIL，還需要線程同步？多線程環(huán)境下必須存在資源的競(jìng)爭(zhēng),那么如何才能保證同一時(shí)刻只有一個(gè)線程對(duì)共享資源進(jìn)行存取?加鎖, 對(duì), 加鎖可以保證存取操作的唯一性, 從而保證同一時(shí)刻只有一個(gè)線程對(duì)共享數(shù)據(jù)存取.通常加鎖也有2種不同的粒度的鎖:coarse-grained(粗粒度)： python解釋器層面維護(hù)著一個(gè)全局的鎖機(jī)制,用來(lái)保證線程安全。內(nèi)核級(jí)通過(guò)GIL實(shí)現(xiàn)的互斥保護(hù)了內(nèi)核的共享資源。fine-grained(細(xì)粒度)：那么程序員需要自行地加,解鎖來(lái)保證線程安全，用戶級(jí)通過(guò)自行加鎖保護(hù)的用戶程序的共享資源。2、GIL為什么限定在一個(gè)進(jìn)程上？你寫一個(gè)py程序，運(yùn)行起來(lái)本身就是一個(gè)進(jìn)程，這個(gè)進(jìn)程是由解釋器來(lái)翻譯的，所以GIL限定在當(dāng)前進(jìn)程；如果又創(chuàng)建了一個(gè)子進(jìn)程，那么兩個(gè)進(jìn)程是完全獨(dú)立的，這個(gè)字進(jìn)程也是有python解釋器來(lái)運(yùn)行的，所以這個(gè)子進(jìn)程上也是受GIL影響的 ''' 擴(kuò)展思考

5、死鎖與遞歸鎖

所謂死鎖：是指兩個(gè)或兩個(gè)以上的進(jìn)程或線程在執(zhí)行過(guò)程中，因爭(zhēng)奪資源而造成的一種互相等待的現(xiàn)象，若無(wú)外力作用，它們都將無(wú)法推進(jìn)下去。此時(shí)稱系統(tǒng)處于死鎖狀態(tài)或系統(tǒng)產(chǎn)生了死鎖，這些永遠(yuǎn)在互相等待的進(jìn)程稱為死鎖進(jìn)程。

import threading,timeLockA=threading.Lock() #定義鎖A LockB=threading.Lock() #定義鎖Bclass MyThread(threading.Thread):def __init__(self):threading.Thread.__init__(self)def run(self):self.foo()self.bar()def foo(self):LockA.acquire() #加A鎖print('I am foo %s get LOCKA-------%s'%(self.name,time.ctime()))LockB.acquire() #加B鎖print('I am foo %s get LOCKB-------%s' % (self.name, time.ctime()))LockB.release() #解B鎖LockA.release() #解A鎖，A鎖被線程2拿到def bar(self):LockB.acquire() #加B鎖print('I am bar %s get LOCKB-------%s' % (self.name, time.ctime()))LockA.acquire() #需要加A鎖，但A鎖被線程2占用，線程2需要加B鎖，相互拿不到鎖，造成死鎖print('I am bar %s get LOCKA-------%s' % (self.name, time.ctime()))LockA.release()LockB.release()for i in range(10):t=MyThread()t.start() ''' 運(yùn)行結(jié)果： I am foo Thread-1 get LOCKA-------Tue Jul 18 18:22:26 2017 I am foo Thread-1 get LOCKB-------Tue Jul 18 18:22:26 2017 I am bar Thread-1 get LOCKB-------Tue Jul 18 18:22:26 2017 I am foo Thread-2 get LOCKA-------Tue Jul 18 18:22:26 2017 '''

?解決方案：使用遞歸鎖

import threading,timeRlock=threading.RLock()　　#定義遞歸鎖class MyThread(threading.Thread):def __init__(self):threading.Thread.__init__(self)def run(self):self.foo()self.bar()def foo(self):Rlock.acquire() #遞歸鎖counter+1print('I am foo %s get LOCKA-------%s'%(self.name,time.ctime()))Rlock.acquire() #遞歸鎖counter+1print('I am foo %s get LOCKB-------%s' % (self.name, time.ctime()))Rlock.release() #遞歸鎖counter-1Rlock.release() #遞歸鎖counter-1　　遞歸鎖counter為零，可被其他線程獲取def bar(self):Rlock.acquire() #遞歸鎖counter+1print('I am bar %s get LOCKB-------%s' % (self.name, time.ctime()))Rlock.acquire() #遞歸鎖counter+1print('I am bar %s get LOCKA-------%s' % (self.name, time.ctime()))Rlock.release()　　　#遞歸鎖counter-1Rlock.release()　　　#遞歸鎖counter-1for i in range(10):t=MyThread()t.start()

''' 運(yùn)行結(jié)果： I am foo Thread-1 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-1 get LOCKB-------Tue Jul 18 18:30:01 2017 I am foo Thread-2 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-2 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-1 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-1 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-3 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-3 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-2 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-2 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-4 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-4 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-4 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-4 get LOCKA-------Tue Jul 18 18:30:01 2017 I am bar Thread-3 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-3 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-6 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-6 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-6 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-6 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-5 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-5 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-5 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-5 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-9 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-9 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-9 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-9 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-7 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-7 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-7 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-7 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-10 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-10 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-10 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-10 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-8 get LOCKA-------Tue Jul 18 18:30:01 2017 I am foo Thread-8 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-8 get LOCKB-------Tue Jul 18 18:30:01 2017 I am bar Thread-8 get LOCKA-------Tue Jul 18 18:30:01 2017 ''' 運(yùn)行結(jié)果

在Python中為了支持在同一線程中多次請(qǐng)求同一資源，python提供了可重入鎖RLock。這個(gè)RLock內(nèi)部維護(hù)著一個(gè)Lock和一個(gè)counter變量，counter記錄了acquire的次數(shù)，從而使得資源可以被多次require。直到一個(gè)線程所有的acquire都被release，其他的線程才能獲得資源。

6、Semaphore（信號(hào)量）

Semaphore管理一個(gè)內(nèi)置的計(jì)數(shù)器，
每當(dāng)調(diào)用acquire()時(shí)內(nèi)置計(jì)數(shù)器-1；
調(diào)用release() 時(shí)內(nèi)置計(jì)數(shù)器+1；
計(jì)數(shù)器不能小于0；當(dāng)計(jì)數(shù)器為0時(shí)，acquire()將阻塞線程直到其他線程調(diào)用release()。

實(shí)例：(同時(shí)只有5個(gè)線程可以獲得semaphore,即可以限制最大連接數(shù)為5)：

import threading import timesemaphore = threading.Semaphore(5)def func():if semaphore.acquire():print (threading.currentThread().getName() + ' get semaphore')time.sleep(2)semaphore.release()for i in range(20):t1 = threading.Thread(target=func)t1.start() ''' 運(yùn)行結(jié)果： Thread-1 get semaphore Thread-2 get semaphore Thread-3 get semaphore Thread-4 get semaphore Thread-5 get semaphore Thread-6 get semaphore Thread-8 get semaphore Thread-7 get semaphore Thread-10 get semaphore Thread-9 get semaphore Thread-12 get semaphore Thread-11 get semaphore Thread-13 get semaphore Thread-14 get semaphore Thread-15 get semaphore Thread-16 get semaphore Thread-17 get semaphore Thread-18 get semaphore Thread-19 get semaphore Thread-20 get semaphore每5個(gè)一起打印 '''

應(yīng)用：連接池

二、ThreadLocal

在多線程環(huán)境下，每個(gè)線程都有自己的數(shù)據(jù)。一個(gè)線程使用自己的局部變量比使用全局變量好，因?yàn)榫植孔兞恐挥芯€程自己能看見，不會(huì)影響其他線程，而全局變量的修改必須加鎖。

但是局部變量也有問題，就是在函數(shù)調(diào)用的時(shí)候，傳遞起來(lái)很麻煩：

def process_student(name):std = Student(name)# std是局部變量，但是每個(gè)函數(shù)都要用它，因此必須傳進(jìn)去：do_task_1(std)do_task_2(std)def do_task_1(std):do_subtask_1(std)do_subtask_2(std)def do_task_2(std):do_subtask_2(std)do_subtask_2(std)

每個(gè)函數(shù)一層一層調(diào)用都這么傳參數(shù)那還得了？用全局變量？也不行，因?yàn)槊總€(gè)線程處理不同的Student對(duì)象，不能共享。

如果用一個(gè)全局dict存放所有的Student對(duì)象，然后以thread自身作為key獲得線程對(duì)應(yīng)的Student對(duì)象如何？

global_dict = {}def std_thread(name):std = Student(name)# 把std放到全局變量global_dict中：global_dict[threading.current_thread()] = stddo_task_1()do_task_2()def do_task_1():# 不傳入std，而是根據(jù)當(dāng)前線程查找：std = global_dict[threading.current_thread()]...def do_task_2():# 任何函數(shù)都可以查找出當(dāng)前線程的std變量：std = global_dict[threading.current_thread()]...

這種方式理論上是可行的，它最大的優(yōu)點(diǎn)是消除了std對(duì)象在每層函數(shù)中的傳遞問題，但是，每個(gè)函數(shù)獲取std的代碼有點(diǎn)丑。

有沒有更簡(jiǎn)單的方式？

ThreadLocal應(yīng)運(yùn)而生，不用查找dict，ThreadLocal幫你自動(dòng)做這件事：

import threading# 創(chuàng)建全局ThreadLocal對(duì)象: local_school = threading.local()def process_student():# 獲取當(dāng)前線程關(guān)聯(lián)的student:std = local_school.studentprint('Hello, %s (in %s)' % (std, threading.current_thread().name))def process_thread(name):# 綁定ThreadLocal的student:local_school.student = nameprocess_student()t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A') t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B') t1.start() t2.start() t1.join() t2.join() ''' 執(zhí)行結(jié)果：Hello, Alice (in Thread-A) Hello, Bob (in Thread-B) '''

全局變量local_school就是一個(gè)ThreadLocal對(duì)象，每個(gè)Thread對(duì)它都可以讀寫student屬性，但互不影響。你可以把local_school看成全局變量，但每個(gè)屬性如local_school.student都是線程的局部變量，可以任意讀寫而互不干擾，也不用管理鎖的問題，ThreadLocal內(nèi)部會(huì)處理。

可以理解為全局變量local_school是一個(gè)dict，不但可以用local_school.student，還可以綁定其他變量，如local_school.teacher等等。

ThreadLocal最常用的地方就是為每個(gè)線程綁定一個(gè)數(shù)據(jù)庫(kù)連接，HTTP請(qǐng)求，用戶身份信息等，這樣一個(gè)線程的所有調(diào)用到的處理函數(shù)都可以非常方便地訪問這些資源。

小結(jié)

一個(gè)ThreadLocal變量雖然是全局變量，但每個(gè)線程都只能讀寫自己線程的獨(dú)立副本，互不干擾。ThreadLocal解決了參數(shù)在一個(gè)線程中各個(gè)函數(shù)之間互相傳遞的問題。

參考博客（海峰）：

http://www.cnblogs.com/linhaifeng/articles/6817679.html

轉(zhuǎn)載于:https://www.cnblogs.com/zzn91/p/7300119.html

總結(jié)

以上是生活随笔為你收集整理的Day39：threading模块、ThreadLocal的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。

上一篇： JAVA 疯狂讲义学习笔记
下一篇： halcon对光源打光不均匀进行平场矫正