python線程優先順序
Ⅰ python 線程問題
參數傳遞有問題。有三種傳遞方式,可以去網上查一下即知。這里修改一下:
#...
#use tuple to pass parameter
t1=threading.Thread(target=albaba,args=(x))
t1.start()
t2=threading.Thread(target=albaba,args=(y))
t2.start()
#...
Ⅱ python 線程池的使用
最近在做一個爬蟲相關的項目,單線程的整站爬蟲,耗時真的不是一般的巨大,運行一次也是心累,,,所以,要想實現整站爬蟲,多線程是不可避免的,那麼python多線程又應該怎樣實現呢?這里主要要幾個問題(關於python多線程的GIL問題就不再說了,網上太多了)。
一、 既然多線程可以縮短程序運行時間,那麼,是不是線程數量越多越好呢?
顯然,並不是,每一個線程的從生成到消亡也是需要時間和資源的,太多的線程會佔用過多的系統資源(內存開銷,cpu開銷),而且生成太多的線程時間也是可觀的,很可能會得不償失,這里給出一個最佳線程數量的計算方式:
最佳線程數的獲取:
1、通過用戶慢慢遞增來進行性能壓測,觀察QPS(即每秒的響應請求數,也即是最大吞吐能力。),響應時間
2、根據公式計算:伺服器端最佳線程數量=((線程等待時間+線程cpu時間)/線程cpu時間) * cpu數量
3、單用戶壓測,查看CPU的消耗,然後直接乘以百分比,再進行壓測,一般這個值的附近應該就是最佳線程數量。
二、為什麼要使用線程池?
對於任務數量不斷增加的程序,每有一個任務就生成一個線程,最終會導致線程數量的失控,例如,整站爬蟲,假設初始只有一個鏈接a,那麼,這個時候只啟動一個線程,運行之後,得到這個鏈接對應頁面上的b,c,d,,,等等新的鏈接,作為新任務,這個時候,就要為這些新的鏈接生成新的線程,線程數量暴漲。在之後的運行中,線程數量還會不停的增加,完全無法控制。所以,對於任務數量不端增加的程序,固定線程數量的線程池是必要的。
三、如何使用線程池
過去使用threadpool模塊,現在一般使用concurrent.futures模塊,這個模塊是python3中自帶的模塊,但是,python2.7以上版本也可以安裝使用,具體使用方式如下:
注意到:
concurrent.futures.ThreadPoolExecutor,在提交任務的時候,有兩種方式,一種是submit()函數,另一種是map()函數,兩者的主要區別在於:
Ⅲ Python中進程和線程的區別詳解
什麼是進程(Process):普通的解釋就是,進程是程序的一次執行,而什麼是線程(Thread),線程可以理解為進程中的執行的一段程序片段。在一個多任務環境中下面的概念可以幫助我們理解兩者間的差別:進程間是獨立的,這表現在內存空間,上下文環境;線程運行在進程空間內。 一般來講(不使用特殊技術)進程是無法突破進程邊界存取其他進程內的存儲空間;而線程由於處於進程空間內,所以同一進程所產生的線程共享同一內存空間。同一進程中的兩段代碼不能夠同時執行,除非引入線程。線程是屬於進程的,當進程退出時該進程所產生的線程都會被強制退出並清除。線程佔用的資源要少於進程所佔用的資源。進程和線程都可以有優先順序。在線程系統中進程也是一個線程。可以將進程理解為一個程序的第一個線程。
線程是指進程內的一個執行單元,也是進程內的可調度實體.與進程的區別:(1)地址空間:進程內的一個執行單元;進程至少有一個線程;它們共享進程的地址空間;而進程有自己獨立的地址空間;(2)進程是資源分配和擁有的單位,同一個進程內的線程共享進程的資源(3)線程是處理器調度的基本單位,但進程不是.(4)二者均可並發執行.
Ⅳ python多線程和多進程的區別有哪些
python多線程和多進程的區別有七種:
1、多線程可以共享全局變數,多進程不能。
2、多線程中,所有子線程的進程號相同;多進程中,不同的子進程進程號不同。
3、線程共享內存空間;進程的內存是獨立的。
4、同一個進程的線程之間可以直接交流;兩個進程想通信,必須通過一個中間代理來實現。
5、創建新線程很簡單;創建新進程需要對其父進程進行一次克隆。
6、一個線程可以控制和操作同一進程里的其他線程;但是進程只能操作子進程。
7、兩者最大的不同在於:在多進程中,同一個變數,各自有一份拷貝存在於每個進程中,互不影響;而多線程中,所有變數都由所有線程共享。
更多Python知識,請關註:Python自學網!!
Ⅳ Python多線程
那是當然。你這樣寫就可以了
self.p[:]=array
這樣寫法的含義就是指針不變。只換內容。這樣就可以同步了。
你的寫法是,新建一個數組,再把指針緞帶self.p,如果其它的線程就會出問題。
另外你的p應該放在__init__之前。引用時使用T.p來引用,這樣更合理一些。
Ⅵ 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多進程和多線程的區別
進程是程序(軟體,應用)的一個執行實例,每個運行中的程序,可以同時創建多個進程,但至少要有一個。每個進程都提供執行程序所需的所有資源,都有一個虛擬的地址空間、可執行的代碼、操作系統的介面、安全的上下文(記錄啟動該進程的用戶和許可權等等)、唯一的進程ID、環境變數、優先順序類、最小和最大的工作空間(內存空間)。進程可以包含線程,並且每個進程必須有至少一個線程。每個進程啟動時都會最先產生一個線程,即主線程,然後主線程會再創建其他的子線程。
線程,有時被稱為輕量級進程(Lightweight Process,LWP),是程序執行流的最小單元。一個標準的線程由線程ID,當前指令指針(PC),寄存器集合和堆棧組成。另外,線程是進程中的一個實體,是被系統獨立調度和分派的基本單位,線程自己不獨立擁有系統資源,但它可與同屬一個進程的其它線程共享該進程所擁有的全部資源。每一個應用程序都至少有一個進程和一個線程。在單個程序中同時運行多個線程完成不同的被劃分成一塊一塊的工作,稱為多線程。
舉個例子,某公司要生產一種產品,於是在生產基地建設了很多廠房,每個廠房內又有多條流水生產線。所有廠房配合將整個產品生產出來,單個廠房內的流水線負責生產所屬廠房的產品部件,每個廠房都擁有自己的材料庫,廠房內的生產線共享這些材料。公司要實現生產必須擁有至少一個廠房一條生產線。換成計算機的概念,那麼這家公司就是應用程序,廠房就是應用程序的進程,生產線就是某個進程的一個線程。
線程的特點:
線程是一個execution context(執行上下文),即一個cpu執行時所需要的一串指令。假設你正在讀一本書,沒有讀完,你想休息一下,但是你想在回來時繼續先前的進度。有一個方法就是記下頁數、行數與字數這三個數值,這些數值就是execution context。如果你的室友在你休息的時候,使用相同的方法讀這本書。你和她只需要這三個數字記下來就可以在交替的時間共同閱讀這本書了。
線程的工作方式與此類似。CPU會給你一個在同一時間能夠做多個運算的幻覺,實際上它在每個運算上只花了極少的時間,本質上CPU同一時刻只能幹一件事,所謂的多線程和並發處理只是假象。CPU能這樣做是因為它有每個任務的execution context,就像你能夠和你朋友共享同一本書一樣。
進程與線程區別:
同一個進程中的線程共享同一內存空間,但進程之間的內存空間是獨立的。
同一個進程中的所有線程的數據是共享的,但進程之間的數據是獨立的。
對主線程的修改可能會影響其他線程的行為,但是父進程的修改(除了刪除以外)不會影響其他子進程。
線程是一個上下文的執行指令,而進程則是與運算相關的一簇資源。
同一個進程的線程之間可以直接通信,但是進程之間的交流需要藉助中間代理來實現。
創建新的線程很容易,但是創建新的進程需要對父進程做一次復制。
一個線程可以操作同一進程的其他線程,但是進程只能操作其子進程。
線程啟動速度快,進程啟動速度慢(但是兩者運行速度沒有可比性)。
由於現代cpu已經進入多核時代,並且主頻也相對以往大幅提升,多線程和多進程編程已經成為主流。Python全面支持多線程和多進程編程,同時還支持協程。
Ⅷ python基礎(21)-線程通信
到這里,我們要聊一下線程通信的內容;
首先,我們拋開語言不談,先看看比較基礎的東西,線程間通信的方式;其實也就是哪幾種(我這里說的,是我的所謂的知道的。。。)事件,消息隊列,信號量,條件變數(鎖算不算?我只是認為是同步的一種);所以我們也就是要把這些掌握了,因為各有各的好處嘛;
條件變數我放到了上面的線程同步裡面講了,我總感覺這算是同步的一種,沒有很多具體信息的溝通;同時吧,我認為條件變數比較重要,因為這種可以應用於線程池的操作上;所以比較重要;這里,拋開條件變數不談,我們看看其他的東西;
1、消息隊列:
queue 模塊下提供了幾個阻塞隊列,這些隊列主要用於實現線程通信。在 queue 模塊下主要提供了三個類,分別代表三種隊列,它們的主要區別就在於進隊列、出隊列的不同。
關於這三個隊列類的簡單介紹如下:
queue.Queue(maxsize=0):代表 FIFO(先進先出)的常規隊列,maxsize 可以限制隊列的大小。如果隊列的大小達到隊列的上限,就會加鎖,再次加入元素時就會被阻塞,直到隊列中的元素被消費。如果將 maxsize 設置為 0 或負數,則該隊列的大小就是無限制的。
queue.LifoQueue(maxsize=0):代表 LIFO(後進先出)的隊列,與 Queue 的區別就是出隊列的順序不同。
PriorityQueue(maxsize=0):代表優先順序隊列,優先順序最小的元素先出隊列。
這三個隊列類的屬性和方法基本相同, 它們都提供了如下屬性和方法:
Queue.qsize():返回隊列的實際大小,也就是該隊列中包含幾個元素。
Queue.empty():判斷隊列是否為空。
Queue.full():判斷隊列是否已滿。
Queue.put(item, block=True, timeout=None):向隊列中放入元素。如果隊列己滿,且 block 參數為 True(阻塞),當前線程被阻塞,timeout 指定阻塞時間,如果將 timeout 設置為 None,則代表一直阻塞,直到該隊列的元素被消費;如果隊列己滿,且 block 參數為 False(不阻塞),則直接引發 queue.FULL 異常。
Queue.put_nowait(item):向隊列中放入元素,不阻塞。相當於在上一個方法中將 block 參數設置為 False。
Queue.get(item, block=True, timeout=None):從隊列中取出元素(消費元素)。如果隊列已滿,且 block 參數為 True(阻塞),當前線程被阻塞,timeout 指定阻塞時間,如果將 timeout 設置為 None,則代表一直阻塞,直到有元素被放入隊列中; 如果隊列己空,且 block 參數為 False(不阻塞),則直接引發 queue.EMPTY 異常。
Queue.get_nowait(item):從隊列中取出元素,不阻塞。相當於在上一個方法中將 block 參數設置為 False。
其實我們想想,這個隊列,是python進行封裝的,那麼我們可以用在線程間的通信;同時也是可以用做一個數據結構;先進先出就是隊列,後進先出就是棧;我們用這個棧寫個十進制轉二進制的例子:
沒毛病,可以正常的列印;其中需要注意的就是,maxsize在初始化的時候如果是0或者是個負數的話,那麼就會是不限制大小;
那麼其實我們想想,我們如果用做線程通信的話,我們兩個線程,可以把隊列設置為1的大小,如果是1對多,比如是創建者和消費者的關系,我們完全可以作為消息隊列,比如說創建者一直在創建一些東西,然後放入到消息隊列裡面,然後供消費著使用;就是一個很好的例子;所以,其實說是消息隊列,也就是隊列,沒差;
=====================================================================
下面來看一下事件
Event 是一種非常簡單的線程通信機制,一個線程發出一個 Event,另一個線程可通過該 Event 被觸發。
Event 本身管理一個內部旗標,程序可以通過 Event 的 set() 方法將該旗標設置為 True,也可以調用 clear() 方法將該旗標設置為 False。程序可以調用 wait() 方法來阻塞當前線程,直到 Event 的內部旗標被設置為 True。
Event 提供了如下方法:
is_set():該方法返回 Event 的內部旗標是否為True。
set():該方法將會把 Event 的內部旗標設置為 True,並喚醒所有處於等待狀態的線程。
clear():該方法將 Event 的內部旗標設置為 False,通常接下來會調用 wait() 方法來阻塞當前線程。
wait(timeout=None):該方法會阻塞當前線程。
這里我想解釋一下;其實對於事件來說,事件可以看成和條件變數是一樣的,只是我們說說不一樣的地方;
1、對於事件來說,一旦觸發了事件,也就是說,一旦set為true了,那麼就會一直為true,需要clear調內部的標志,才能繼續wait;但是conditon不是,他是一次性的喚醒其他線程;
2、conditon自己帶鎖;事件呢?不是的;沒有自己的鎖;比如說有一個存錢的線程,有一個是取錢的線程;那麼存錢的線程要存錢;需要怎麼辦呢?1、發現銀行沒有錢了(is_set判斷);2、鎖住銀行;3、存錢;4、釋放銀行;5、喚醒事件;對於取錢的人;1、判斷是否有錢;2、被喚醒了,然後鎖住銀行;3、開始取錢;4、清理告訴存錢的人,我沒錢了(clear);5、釋放鎖;6、等著錢存進去;
其實說白了,就是記住一點;這個旗標需要自己clear就對了
寫個例子,怕以後忘了怎麼用;
其實時間和信號量比較像;但是信號量不用自己清除標志位;但是事件是需要的;
Ⅸ python 線程優先順序 怎麼設置
PersistenceConfig(持久層配置)
我們想要一個配置了所有可用倉庫的MONGODB配置。在這個簡單的應用中我們只用了一個倉庫,所以配置也非常的簡單:
@Configuration
class PersistenceConfig {
@Bean
public AccountRepository accountRepository() throws UnknownHostException {
return new MongoAccountRepository(mongoTemplate());
Ⅹ python thread 怎麼區分主線程
在Python語言中Python線程可以從這里開始與主線程對GIL的競爭,在t_bootstrap中,申請完了GIL,也就是說子線程也就獲得了GIL,使其始終保存著活動線程的狀態對象。
當PyEval_AcquireThread結束之後,子線程也就獲得了GIL,並且做好了一切執行的准備。接下來子線程通過PyEval_ CallObjectWithKeywords,將最終調用我們已經非常熟悉的PyEval_EvalFrameEx。
也就是Python的位元組碼執行引擎。傳遞進PyEval_CallObjectWithKeywords的boot->func是一PyFunctionObject對象,正是therad1.py中定義的threadProc編譯後的結果。在PyEval_CallObjectWithKeywords結束之後,子線程將釋放GIL,並完成銷毀線程的所有掃尾工作,到了這里,子線程就結束了。
從t_bootstrap的代碼看上去,似乎子線程會一直執行,直到子線程的所有計算都完成,才會通過PyThreadState_DeleteCurrent釋放GIL。如此一來,那主線程豈非一直都會處於等待GIL的狀態?如果真是這樣,那Python線程顯然就不可能支持多線程機制了。
實際上在PyEval_EvalFrameEx中,圖15-2中顯示的Python內部維護的那個模擬時鍾中斷會不斷地激活線程的調度機制,在子線程和主線程之間不斷地進行切換。從而真正實現多線程機制,當然,這一點我們將在後面詳細剖析。現在我們感興趣的是子線程在PyEval_AcquireThreade中到底做了什麼。
到這里,了解了PyEval_AcquireThread,似乎創建線程的機制都清晰了。但實際上,有一個非常重要的機制——線程狀態保護機制——隱藏在了一個毫不起眼的地方:PyThreadState_New。
[threadmole.c] static PyObject* thread_PyThread_start_new_thread(PyObject *self, PyObject *fargs) { PyObject *func, *args, *keyw = NULL; struct bootstate *boot; long ident; PyArg_UnpackTuple(fargs, "start_new_thread", 2, 3, &func, &args, &keyw); //[1]:創建bootstate結構 boot = PyMem_NEW(struct bootstate, 1); boot->interp = PyThreadState_GET()->interp; boot->funcfunc = func; boot->argsargs = args; boot->keywkeyw = keyw; //[2]:初始化多線程環境 PyEval_InitThreads(); /* Start the interpreter's thread-awareness */ //[3]:創建線程 ident = PyThread_start_new_thread(t_bootstrap, (void*) boot); return PyInt_FromLong(ident); [thread.c] /* Support for runtime thread stack size tuning. A value of 0 means using the platform's default stack size or the size specified by the THREAD_STACK_SIZE macro. */ static size_t _pythread_stacksize = 0; [thread_nt.h] long PyThread_start_new_thread(void (*func)(void *), void *arg) { unsigned long rv; callobj obj; obj.id = -1; /* guilty until proved innocent */ obj.func = func; obj.arg = arg; obj.done = CreateSemaphore(NULL, 0, 1, NULL); rv = _beginthread(bootstrap, _pythread_stacksize, &obj); /* use default stack size */ if (rv == (unsigned long)-1) { //創建raw thread失敗 obj.id = -1; } else { WaitForSingleObject(obj.done, INFINITE); } CloseHandle((HANDLE)obj.done); return obj.id; }
這個機制對於理解Python線程的創建和維護是非常關鍵的。要剖析線程狀態的保護機制,我們首先需要回顧一下線程狀態。在Python中,每一個Python線程都會有一個線程狀態對象與之關聯。
在線程狀態對象中,記錄了每一個線程所獨有的一些信息。實際上,在剖析Python的初始化過程時,我們曾經見過這個對象。每一個線程對應的線程狀態對象都保存著這個線程當前的PyFrameObject對象,線程的id這樣一些信息。有時候,線程是需要訪問這些信息的。
比如考慮一個最簡單的情形,在某種情況下,每個線程都需要訪問線程狀態對象中所保存的thread_id信息,顯然,線程A獲得的應該是A的thread_id,線程B亦然。倘若線程A獲得的是B的thread_id,那就壞菜了。這就意味著Python線程內部必須有一套機制,這套機制與操作系統管理進程的機制非常類似。
我們知道,在操作系統從進程A切換到進程B時,首先會保存進程A的上下文環境,再進行切換;當從進程B切換回進程A時,又會恢復進程A的上下文環境,這樣就保證了進程A始終是在屬於自己的上下文環境中運行。
這里的線程狀態對象就等同於進程的上下文,Python同樣會有一套存儲、恢復線程狀態對象的機制。同時,在Python內部,維護著一個全局變數:PyThreadState * _PyThread- State_Current。
當前活動線程所對應的線程狀態對象就保存在這個變數里,當Python調度線程時,會將被激活的線程所對應的線程狀態對象賦給_PyThreadState_Current,使其始終保存著活動線程的狀態對象。
這就引出了這樣的一個問題:Python如何在調度進程時,獲得被激活線程對應的狀態對象?Python內部會通過一個單向鏈表來管理所有的Python線程的狀態對象,當需要尋找一個線程對應的狀態對象時。