python線程變數

Ⅰ python中多線程調用全局變數，值不是修改後的值

多線程讀取全局變數需要引用線程鎖，否則多個線程同時讀取同一個全局變數會出現和預期不一樣的值

Ⅱ Python多線程是什麼意思

簡單地說就是作為可能是僅有的支持多線程的解釋型語言（perl的多線程是殘疾，PHP沒有多線程），Python的多線程是有compromise的，在任意時間只有一個Python解釋器在解釋Python bytecode。
UPDATE：如評論指出，Ruby也是有thread支持的，而且至少Ruby MRI是有GIL的。
如果你的代碼是CPU密集型，多個線程的代碼很有可能是線性執行的。所以這種情況下多線程是雞肋，效率可能還不如單線程因為有context switch
但是：如果你的代碼是IO密集型，多線程可以明顯提高效率。例如製作爬蟲（我就不明白為什麼Python總和爬蟲聯系在一起…不過也只想起來這個例子…），絕大多數時間爬蟲是在等待socket返回數據。這個時候C代碼里是有release GIL的，最終結果是某個線程等待IO的時候其他線程可以繼續執行。
反過來講：你就不應該用Python寫CPU密集型的代碼…效率擺在那裡…
如果確實需要在CPU密集型的代碼里用concurrent，就去用multiprocessing庫。這個庫是基於multi process實現了類multi thread的API介面，並且用pickle部分地實現了變數共享。
再加一條，如果你不知道你的代碼到底算CPU密集型還是IO密集型，教你個方法：
multiprocessing這個mole有一個mmy的sub mole，它是基於multithread實現了multiprocessing的API。
假設你使用的是multiprocessing的Pool，是使用多進程實現了concurrency
from multiprocessing import Pool
如果把這個代碼改成下面這樣，就變成多線程實現concurrency
from multiprocessing.mmy import Pool
兩種方式都跑一下，哪個速度快用哪個就行了。
UPDATE:
剛剛才發現concurrent.futures這個東西，包含ThreadPoolExecutor和ProcessPoolExecutor，可能比multiprocessing更簡單

Ⅲ 如何進行Python主線程設置

輸入模塊可以使用其功能的其他程序。這就是為什麼我們使用Python標准庫的方法
輸入：。
＃的/ usr / bin中/ env的蟒蛇
＃文件名：！ Using_sys.py

進口SYS

列印「命令行參數是：」
因為我在sys.argv中：
我列印網上列印「\ \ n此PYTHONPATH是'，sys.path中，'\ N'

輸出：
$蟒蛇using_sys.py我們
參數的命令行參數：
using_sys
的.py我們
是
參數
登錄到到網PYTHONPATH為['/家庭/ swaroop /位元組/碼'，'/usr/lib/python23.zip「， BR>'/usr/lib/python2.3'，'/ usr / lib目錄/ python2.3 /開發平台，將linux2「，
」/usr/lib/python2.3/lib-tk'，'的/ usr /的lib / python2.3 / lib目錄-dynload「，
'的/ usr /lib/python2.3/site-packages'，'/usr/lib/python2.3/site-packages/gtk-2.0']

首先，我們使用import語句輸入sys模塊。基本上，這句話語句告訴Python中，我們要使用這個模塊。 sys模塊包含了與Python解釋器及其環境相關的功能。

當執行Python導入SYS語句，它被列在目錄中找到的sys.path變數sys.py模塊。如果您發現該文件，該模塊中的報表的主塊將被運行，然後這個你要使用的模塊。注意，在初始化過程只是我們第一次進行的輸入模塊。此外，「SYS」是「系統」的縮寫。通過使用點

sys模塊的argv變數表示--sys.argv--這種方法的一個優點是名稱不與你的程序中使用任何argv變數沖突。此外，還清楚地表明，該名稱是sys模塊的一部分。

sys.argv中的變數是一個字元串（列表中會詳細在後面的章節介紹）的列表。特別是，sys.argv中包含的命令行參數，即利用傳遞給你的程序的命令行參數的清單。

如果使用IDE來編寫和執行這些程序，請認準的命令行參數菜單的方法指定的程序。

在這里，當我們執行Python using_sys.py我們有觀點，我們使用Python命令來運行using_sys.py模塊，然後作為參數傳遞給程序的內容。 Python的，我們把它存儲在sys.argv變數。

記住，第一個參數始終是劇本sys.argv列表，它的名稱。所以，在這里，「using_sys.py」是sys.argv中[0]，'我們'是sys.argv中[1]，'是'是sys.argv中[2]和「論據」是sys.argv中[3]。注意，Python的從0開始計數，而不是從頭開始。

sys.path中包含的目錄名輸入模塊的列表。我們可以觀察到sys.path的第一個字元串是空的 - 這部分在當前目錄下的空字元串表示形式是sys.path中，這PYTHONPATH環境變數是相同的。這意味著，你可以直接在當前目錄下輸入模塊。否則，你必須把你的模塊在sys.path所列的目錄之一。

Ⅳ python多線程和多進程的區別有哪些

python多線程和多進程的區別有七種：

1、多線程可以共享全局變數，多進程不能。

2、多線程中，所有子線程的進程號相同；多進程中，不同的子進程進程號不同。

3、線程共享內存空間；進程的內存是獨立的。

4、同一個進程的線程之間可以直接交流；兩個進程想通信，必須通過一個中間代理來實現。

5、創建新線程很簡單；創建新進程需要對其父進程進行一次克隆。

6、一個線程可以控制和操作同一進程里的其他線程；但是進程只能操作子進程。

7、兩者最大的不同在於：在多進程中，同一個變數，各自有一份拷貝存在於每個進程中，互不影響；而多線程中，所有變數都由所有線程共享。

更多Python知識，請關註：Python自學網！！

Ⅳ python中多進程和多線程的區別

什麼是線程、進程?
進程(process)與線程(thread)是操作系統的基本概念，它們比較抽象，不容易掌握。
關於這兩者，最經典的一句話就是「進程是資源分配的最小單位，線程是CPU調度的最小單位」，線程是程序中一個單一的順序控制流程，進程內一個相對獨立的、可調度的執行單元，是系統獨立調度和分配CPU的基本單位指運行中的程序的調度單位，在單個程序中同時運行多個線程完成不同的工作，稱為多線程。
進程與線程的區別是什麼?
進程是資源分配的基本單位，所有與該進程有關的資源，都被記錄在進程式控制制塊PCB中，以表示該進程擁有這些資源或正在使用它們，另外，進程也是搶占處理機的調度單位，它擁有一個完整的虛擬地址空間，當進程發生調度時，不同的進程擁有不同的虛擬地址空間，而同一進程內的不同線程共享同一地址空間。
與進程相對應的，線程與資源分配無關，它屬於某一個進程，並與進程內的其他線程一起共享進程的資源，線程只由相關堆棧(系統棧或用戶棧)寄存器和線程式控制製表TCB組成，寄存器可被用來存儲線程內的局部變數，但不能存儲其他線程的相關變數。
通常在一個進程中可以包含若干個線程，它們可以利用進程所擁有的資源，在引入線程的操作系統中，通常都是把進程作為分配資源的基本單位，而把線程作為獨立運行和獨立調度的基本單位。
由於線程比進程更小，基本上不擁有系統資源，所以對它的調度所付出的開銷就會小得多，能更高效的提高系統內多個程序間並發執行的程度，從而顯著提高系統資源的利用率和吞吐量。
因而近年來推出的通用操作系統都引入了線程，以便進一步提高系統的並發性，並把它視為現代操作系統的一個重要指標。

Ⅵ python之多線程原理

並發：邏輯上具備同時處理多個任務的能力。
並行：物理上在同一時刻執行多個並發任務。

舉例：開個QQ，開了一個進程，開了微信，開了一個進程。在QQ這個進程裡面，傳輸文字開一個線程、傳輸語音開了一個線程、彈出對話框又開了一個線程。
總結：開一個軟體，相當於開了一個進程。在這個軟體運行的過程里，多個工作同時運轉，完成了QQ的運行，那麼這個多個工作分別有多個線程。

線程和進程之間的區別：

進程在python中的使用，對模塊threading進行操作，調用的這個三方庫。可以通過 help(threading) 了解其中的方法、變數使用情況。也可以使用 dir(threading) 查看目錄結構。

current_thread_num = threading.active_count() # 返回正在運行的線程數量
run_thread_len = len(threading.enumerate()) # 返回正在運行的線程數量
run_thread_list = threading.enumerate() # 返回當前運行線程的列表
t1=threading.Thread(target=dance) #創建兩個子線程，參數傳遞為函數名
t1.setDaemon(True) # 設置守護進程，守護進程：主線程結束時自動退出子線程。
t1.start() # 啟動子線程
t1.join() # 等待進程結束 exit()`# 主線程退出，t1子線程設置了守護進程，會自動退出。其他子線程會繼續執行。

Ⅶ 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線程的狀態對象，當需要尋找一個線程對應的狀態對象時。

Ⅷ 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 像這樣定義多線程的類在調用時怎麼把調用父類的參數傳遞給子函數

你已經實現了啊。在__init__初始化參數里，將參數傳遞進去。

另外因為線程工作在主程序同一個空間里，所以可以用全局變數傳遞。比如定義一個global v，然後在主程序里設置好。
再在線程里用global v來引用。

如果在線程運行當中，動態的改參數。可以象是這里的thread_stop設置。由主進程與從進程單對單的傳遞信號。

另外還可以通過隊列。這個好處是有一個鎖，可以全局使用。

此外你還可以引入一個消息管理器。各個線程與主進程直接通過消息傳遞變數。

進程之間也可以通過共享內存來實現RPC通信，就是交換數據。

線程處理完的數據，如果主程序想處理。可以這樣。讓線程通過全局變數，通過隊列傳回來。

不過主進程通常還有一個任務，就是監督線程的完成退處，並管理線程中止信號。

比如你這個程序少了一個
thread.join() 這里的join可以加一個timeout，當超時時，主進程就可以脫身出來，做一些其它的事情，比如處理返回數值。 如果線程通過一個數組變數將狀態傳回主進程。這樣輪洵子線程狀態會比join的效率更高。

你這個程序里用文件傳遞也不是不可以。這是一個很好思路。當你傳遞變數困難時，可以用文件。或者是資料庫。

Ⅹ 小白都看懂了，Python 中的線程和進程精講，建議收藏

目錄

眾所周知，CPU是計算機的核心，它承擔了所有的計算任務。而操作系統是計算機的管理者，是一個大管家，它負責任務的調度，資源的分配和管理，統領整個計算機硬體。應用程序是具有某種功能的程序，程序運行與操作系統之上

在很早的時候計算機並沒有線程這個概念，但是隨著時代的發展，只用進程來處理程序出現很多的不足。如當一個進程堵塞時，整個程序會停止在堵塞處，並且如果頻繁的切換進程，會浪費系統資源。所以線程出現了

線程是能擁有資源和獨立運行的最小單位，也是程序執行的最小單位。一個進程可以擁有多個線程，而且屬於同一個進程的多個線程間會共享該進行的資源

① 200 多本 Python 電子書（和經典的書籍）應該有

② Python標准庫資料（最全中文版）

③ 項目源碼（四五十個有趣且可靠的練手項目及源碼）

④ Python基礎入門、爬蟲、網路開發、大數據分析方面的視頻（適合小白學習）

⑤ Python學習路線圖（告別不入流的學習）
私信我01即可獲取大量Python學習資源

進程時一個具有一定功能的程序在一個數據集上的一次動態執行過程。進程由程序，數據集合和進程式控制制塊三部分組成。程序用於描述進程要完成的功能，是控制進程執行的指令集；數據集合是程序在執行時需要的數據和工作區；程序控制塊（PCB）包含程序的描述信息和控制信息，是進程存在的唯一標志

在Python中，通過兩個標准庫 thread 和 Threading 提供對線程的支持, threading 對 thread 進行了封裝。 threading 模塊中提供了 Thread , Lock , RLOCK , Condition 等組件

在Python中線程和進程的使用就是通過 Thread 這個類。這個類在我們的 thread 和 threading 模塊中。我們一般通過 threading 導入

默認情況下，只要在解釋器中，如果沒有報錯，則說明線程可用

守護模式：

現在我們程序代碼中，有多個線程， 並且在這個幾個線程中都會去 操作同一部分內容，那麼如何實現這些數據的共享呢？

這時，可以使用 threading庫裡面的鎖對象 Lock 去保護

Lock 對象的acquire方法 是申請鎖

每個線程在操作共享數據對象之前，都應該申請獲取操作權，也就是調用該共享數據對象對應的鎖對象的acquire方法，如果線程A 執行了 acquire() 方法，別的線程B 已經申請到了這個鎖， 並且還沒有釋放，那麼 線程A的代碼就在此處 等待 線程B 釋放鎖，不去執行後面的代碼。

直到線程B 執行了鎖的 release 方法釋放了這個鎖， 線程A 才可以獲取這個鎖，就可以執行下面的代碼了

如：

到在使用多線程時，如果數據出現和自己預期不符的問題，就可以考慮是否是共享的數據被調用覆蓋的問題

使用 threading 庫裡面的鎖對象 Lock 去保護

Python中的多進程是通過multiprocessing包來實現的，和多線程的threading.Thread差不多，它可以利用multiprocessing.Process對象來創建一個進程對象。這個進程對象的方法和線程對象的方法差不多也有start(), run(), join()等方法，其中有一個方法不同Thread線程對象中的守護線程方法是setDeamon，而Process進程對象的守護進程是通過設置daemon屬性來完成的

守護模式：

其使用方法和線程的那個 Lock 使用方法類似

Manager的作用是提供多進程共享的全局變數，Manager()方法會返回一個對象，該對象控制著一個服務進程，該進程中保存的對象運行其他進程使用代理進行操作

語法：

線程池的基類是 concurrent.futures 模塊中的 Executor ， Executor 提供了兩個子類，即 ThreadPoolExecutor 和 ProcessPoolExecutor ，其中 ThreadPoolExecutor 用於創建線程池，而 ProcessPoolExecutor 用於創建進程池

如果使用線程池/進程池來管理並發編程，那麼只要將相應的 task 函數提交給線程池/進程池，剩下的事情就由線程池/進程池來搞定

Exectuor 提供了如下常用方法：

程序將 task 函數提交（submit）給線程池後，submit 方法會返回一個 Future 對象，Future 類主要用於獲取線程任務函數的返回值。由於線程任務會在新線程中以非同步方式執行，因此，線程執行的函數相當於一個「將來完成」的任務，所以 Python 使用 Future 來代表

Future 提供了如下方法：

使用線程池來執行線程任務的步驟如下：

最佳線程數目 = （（線程等待時間+線程CPU時間）/線程CPU時間 ）* CPU數目

也可以低於 CPU 核心數

使用線程池來執行線程任務的步驟如下：

關於進程的開啟代碼一定要放在 if __name__ == '__main__': 代碼之下，不能放到函數中或其他地方

開啟進程的技巧

開啟進程的數量最好低於最大 CPU 核心數