Python一些線程的玩法總結(jié)
一、線程基礎(chǔ)以及守護(hù)進(jìn)程
線程是CPU調(diào)度的最小單位
全局解釋器鎖
全局解釋器鎖GIL（global interpreter lock）
全局解釋器鎖的出現(xiàn)主要是為了完成垃圾回收機(jī)制的回收機(jī)制，對不同線程的引用計(jì)數(shù)的變化記錄的更加精準(zhǔn)。
全局解釋器鎖導(dǎo)致了同一個(gè)進(jìn)程中的多個(gè)線程只能有一個(gè)線程真正被CPU執(zhí)行。
GIL鎖每執(zhí)行700條指令才會(huì)進(jìn)行一次（輪轉(zhuǎn)）切換（從一個(gè)線程切換到另外一個(gè)線程）
節(jié)省的是IO操作（不占用CPU）的時(shí)間，而不是CPU計(jì)算的時(shí)間，因?yàn)镃PU的計(jì)算速度非?？欤蠖鄶?shù)情況下，我們沒有辦法把一條進(jìn)程中所有的IO操作都規(guī)避掉。
threading模塊
import time
from threading import Thread, current_thread, enumerate, active_count
def func(i):
print('start%s' % i, current_thread().ident) # 函數(shù)中獲取當(dāng)前線程id
time.sleep(1)
print('end%s' % i)
if __name__ == '__main__':
t1 = []
for i in range(3):
t = Thread(target=func, args=(i,))
t.start()
print(t.ident) # 查看當(dāng)前線程id
t1.append(t)
print(enumerate(), active_count())
for t in t1:
t.join()
print('所有線程執(zhí)行完畢')
線程是不能從外部強(qiáng)制終止（terminate），所有的子線程只能是自己執(zhí)行完代碼之后就關(guān)閉。
current_thread 獲取當(dāng)前的線程對象
current_thread().ident 或者 線程對象.ident 獲取當(dāng)前線程id。
enumerate返回一個(gè)列表，存儲(chǔ)了所有活著的線程對象，包括主線程。
active_count返回一個(gè)數(shù)字，存儲(chǔ)了所有活著的線程個(gè)數(shù)。
【注意】enumerate導(dǎo)入之后，會(huì)和內(nèi)置函數(shù)enumerate重名，需要做特殊的處理
- from threading import enumerate as en
- import threading
threading.enumerate()
面向?qū)ο蠓绞介_啟一個(gè)線程
from threading import Thread
class MyThread(Thread):
def __init__(self, a, b):
super(MyThread, self).__init__()
self.a = a
self.b = b
def run(self):
print(self.ident)
t = MyThread(1, 3)
t.start() # 開啟線程，才在線程中執(zhí)行run方法
print(t.ident)
線程之間的數(shù)據(jù)是共享的
from threading import Thread
n = 100
def func():
global n
n -= 1
t_li = []
for i in range(100):
t = Thread(target=func)
t.start()
t_li.append(t)
for t in t_li:
t.join()
print(n)
結(jié)果是：0
守護(hù)線程
主線程會(huì)等待子線程結(jié)束之后才結(jié)束，為什么？
因?yàn)橹骶€程結(jié)束，進(jìn)程就會(huì)結(jié)束。
- 守護(hù)線程隨著主線程的結(jié)束而結(jié)束
- 守護(hù)進(jìn)程會(huì)隨著主進(jìn)程的代碼結(jié)束而結(jié)束，如果主進(jìn)程代碼之后還有其他子進(jìn)程在運(yùn)行，守護(hù)進(jìn)程不守護(hù)。
- 守護(hù)線程會(huì)隨著主線程的結(jié)束而結(jié)束，如果主線程代碼結(jié)束之后還有其他子線程在運(yùn)行，守護(hù)線程也守護(hù)。
import time
from threading import Thread
def son():
while True:
print('in son')
time.sleep(1)
def son2():
for i in range(3):
print('in son2...')
time.sleep(1)
# flag a
t = Thread(target=son)
t.daemon = True
t.start()
# flag b a-->b用時(shí)0s
Thread(target=son2).start()
為什么守護(hù)線程會(huì)在主線程的代碼結(jié)束之后繼續(xù)守護(hù)其他子線程？
答：因?yàn)槭刈o(hù)進(jìn)程和守護(hù)線程的結(jié)束原理不同。守護(hù)進(jìn)程需要主進(jìn)程來回收資源，守護(hù)線程是隨著主線程的結(jié)束而結(jié)束，其他子線程–>主線程結(jié)束–>主進(jìn)程結(jié)束–>整個(gè)進(jìn)程中所有的資源都被回收，守護(hù)線程也會(huì)被回收。
二、線程鎖（互斥鎖）
線程之間也存在數(shù)據(jù)不安全
import dis
a = 0
def func():
global a
a += 1
dis.dis(func) # 得到func方法中的代碼翻譯成CPU指令
"""
結(jié)果
0 LOAD_GLOBAL 0 (a)
2 LOAD_CONST 1 (1)
4 INPLACE_ADD
6 STORE_GLOBAL 0 (a)
8 LOAD_CONST 0 (None)
10 RETURN_VALUE
"""
+=、-=、*=、/=、while、if、帶返回值的方法（都是先計(jì)算后賦值，前提要涉及到全局變量或靜態(tài)變量） 等都是數(shù)據(jù)不安全的，append、pop、queue、logging模塊等都是數(shù)據(jù)安全的。
列表中的方法或者字典中的方法去操作全局變量的時(shí)候，數(shù)據(jù)是安全的。
只有一個(gè)線程，永遠(yuǎn)不會(huì)出現(xiàn)線程不安全現(xiàn)象。
采用加鎖的方式來保證數(shù)據(jù)安全。
from threading import Thread, Lock
n = 0
def add(lock):
for i in range(500000):
global n
with lock:
n += 1
def sub(lock):
for i in range(500000):
global n
with lock:
n -= 1
t_li = []
lock = Lock()
for i in range(2):
t1 = Thread(target=add, args=(lock,))
t1.start()
t2 = Thread(target=sub, args=(lock,))
t2.start()
t_li.append(t1)
t_li.append(t2)
for t in t_li:
t.join()
print(n)
線程安全的單例模式
import time
from threading import Thread, Lock
class A:
__instance = None
lock = Lock()
def __new__(cls, *args, **kwargs):
with cls.lock:
if not cls.__instance:
time.sleep(0.00001)
cls.__instance = super().__new__(cls)
return cls.__instance
def func():
a = A()
print(a)
for i in range(10):
Thread(target=func).start()
不用考慮加鎖的小技巧
- 不要操作全局變量
- 不要在類中操作靜態(tài)變量
因?yàn)槎鄠€(gè)線程同時(shí)操作全局變量/靜態(tài)變量，會(huì)產(chǎn)生數(shù)據(jù)不安全現(xiàn)象。
三、線程鎖（遞歸鎖）
from threading import Lock, RLock
# Lock 互斥鎖
# RLock 遞歸（recursion）鎖
l = Lock()
l.acquire()
print('希望被鎖住的代碼')
l.release()
rl = RLock() # 在同一個(gè)線程中可以被acquire多次
rl.acquire()
rl.acquire()
rl.acquire()
print('希望被鎖住的代碼')
rl.release()
from threading import Thread, RLock
def func(i, lock):
lock.acquire()
lock.acquire()
print(i, ':start')
lock.release()
lock.release()
print(i, ':end')
lock = RLock()
for i in range(5):
Thread(target=func, args=(i, lock)).start()
互斥鎖與遞歸鎖
遞歸鎖在同一個(gè)線程中可以被acquire多次，而互斥鎖不行
互斥鎖效率高，遞歸鎖效率相對低
多把互斥鎖容易產(chǎn)生死鎖現(xiàn)象，遞歸鎖可以快速解決死鎖
四、死鎖
死鎖：指兩個(gè)或兩個(gè)以上的進(jìn)程或線程在執(zhí)行過程中，因爭奪資源而造成的一種互相等待的現(xiàn)象。
死鎖現(xiàn)象是怎么產(chǎn)生的？
答：有多把鎖，并且在多個(gè)線程中交叉使用。與互斥鎖、遞歸鎖無關(guān)，都會(huì)發(fā)生死鎖。如果是互斥鎖，出現(xiàn)了死鎖現(xiàn)象，最快速的解決方案是把所有的互斥鎖都改成一把遞歸鎖（noodle_lock = fork_lock = RLock()），程序的效率會(huì)降低。
from threading import Thread, Lock
import time
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
noodle_lock.acquire()
print(name, '搶到面了')
fork_lock.acquire()
print(name, '搶到叉子了')
print(name, '吃面')
time.sleep(0.0001)
fork_lock.release()
print(name, '放下叉子了')
noodle_lock.release()
print(name, '放下面了')
def eat2(name):
fork_lock.acquire()
print(name, '搶到叉子了')
noodle_lock.acquire()
print(name, '搶到面了')
print(name, '吃面')
noodle_lock.release()
print(name, '放下面了')
fork_lock.release()
print(name, '放下叉子了')
Thread(target=eat1, args=('lucy',)).start()
Thread(target=eat2, args=('jack',)).start()
Thread(target=eat1, args=('rose',)).start()
Thread(target=eat2, args=('disen',)).start()
五、隊(duì)列
隊(duì)列：線程之間數(shù)據(jù)安全的容器
線程隊(duì)列：數(shù)據(jù)安全，先進(jìn)先出
原理：加鎖 + 鏈表
Queue
fifo 先進(jìn)先出的隊(duì)列
get和put
import queue q = queue.Queue(3) # fifo 先進(jìn)先出的隊(duì)列 q.put(1) q.put(2) print(q.get()) print(q.get())
1
2
get_nowait
import queue
# from queue import Empty # 不是內(nèi)置的錯(cuò)誤類型，而是queue模塊中的錯(cuò)誤
q = queue.Queue() # fifo 先進(jìn)先出的隊(duì)列
try:
q.get_nowait()
except queue.Empty:
pass
print('隊(duì)列為空，繼續(xù)執(zhí)行其他代碼')
put_nowait
用的很少，因?yàn)殛?duì)列滿時(shí)，拋異常，數(shù)據(jù)放不進(jìn)去，丟失了。
LifoQueue
后進(jìn)先出的隊(duì)列，也就是棧。last in first out
from queue import LifoQueue lq = LifoQueue() lq.put(1) lq.put(2) print(lq.get()) print(lq.get())
2
1
PriorityQueue
優(yōu)先級(jí)隊(duì)列，按照放入數(shù)據(jù)的第一位數(shù)值從小到大輸出
from queue import PriorityQueue priq = PriorityQueue() priq.put((2, 'lucy')) priq.put((0, 'rose')) priq.put((1, 'jack')) print(priq.get()) print(priq.get()) print(priq.get())
(0, 'rose')
(1, 'jack')
(2, 'lucy')
三種隊(duì)列使用場景
先進(jìn)先出：用于處理服務(wù)類任務(wù)（買票任務(wù)）
后進(jìn)先出：算法中用的比較多
優(yōu)先級(jí)隊(duì)列：比如，VIP制度，VIP用戶優(yōu)先；
六、相關(guān)面試題
請聊聊進(jìn)程隊(duì)列的特點(diǎn)和實(shí)現(xiàn)原理
特點(diǎn)：實(shí)現(xiàn)進(jìn)程之間的通信；數(shù)據(jù)安全；先進(jìn)先出。
實(shí)現(xiàn)原理：基于管道 + 鎖 實(shí)現(xiàn)的，管道是基于文件級(jí)別的socket + pickle 實(shí)現(xiàn)的。
你了解生產(chǎn)者消費(fèi)者模型嗎，如何實(shí)現(xiàn)
了解
為什么了解？工作經(jīng)驗(yàn)
采集圖片/爬取音樂：由于要爬取大量的數(shù)據(jù)，想提高爬取效率 有用過一個(gè)生產(chǎn)者消費(fèi)者模型，這個(gè)模型是我自己寫的，消息中間件，用的是xxx（redis），我獲取網(wǎng)頁的過程作為生產(chǎn)者，分析網(wǎng)頁，獲取所有歌曲歌曲鏈接的過程作為消費(fèi)者。 自己寫監(jiān)控，或者是自己寫郵件報(bào)警系統(tǒng)，監(jiān)控程序作為生產(chǎn)者，一旦發(fā)現(xiàn)有問題的程序，就需要把要發(fā)送的郵件信息交給消息中間件redis，消費(fèi)者就從中間件中取值，然后來處理發(fā)郵件的邏輯。
什么時(shí)候用過？
項(xiàng)目 或者 例子，結(jié)合上面一起
在python中實(shí)現(xiàn)生產(chǎn)者消費(fèi)者模型可以用哪些機(jī)制
消息中間件 celery（分布式框架）：定時(shí)發(fā)短信的任務(wù)
從你的角度說說進(jìn)程在計(jì)算機(jī)中扮演什么角色
進(jìn)程用來管理一個(gè)運(yùn)行中的程序的資源，是資源分配的最小單位
進(jìn)程與進(jìn)程之間內(nèi)存是隔離的
進(jìn)程是由操作系統(tǒng)負(fù)責(zé)調(diào)度的，并且多個(gè)進(jìn)程之間是一種競爭關(guān)系，所以我們應(yīng)該對進(jìn)程的三狀態(tài)時(shí)刻關(guān)注，盡量減少進(jìn)程中的IO操作，或者在進(jìn)程里面開線程來規(guī)避IO，讓我們寫的程序在運(yùn)行的時(shí)候能夠更多的占用CPU資源。
為什么線程之間的數(shù)據(jù)不安全
線程之間數(shù)據(jù)共享
多線程的情況下，
如果在計(jì)算某一個(gè)變量的時(shí)候，還要進(jìn)行賦值操作，這個(gè)過程不是由一條完整的CPU指令完成的； 如果在判斷某個(gè)bool表達(dá)式之后，再做某些操作，這個(gè)過程也不是由一條完整的CPU指令完成的； 在中間發(fā)生了GIL鎖的切換（時(shí)間片的輪轉(zhuǎn)），可能會(huì)導(dǎo)致數(shù)據(jù)不安全。
讀程序，請確認(rèn)執(zhí)行到最后number的長度是否一定為 1
import threading
import time
# loop = 1E7 # 10000000.
loop = int(1E7) # 10000000
def _add(loop: int = 1):
global numbers
for _ in range(loop):
numbers.append(0)
def _sub(loop: int = 1):
global numbers
for _ in range(loop):
while not numbers:
time.sleep(1E-8)
numbers.pop()
numbers = [0]
ta = threading.Thread(target=_add, args=(loop,))
ts = threading.Thread(target=_sub, args=(loop,))
# ts1 = threading.Thread(target=_sub, args=(loop,))
ta.start()
ts.start()
# ts1.start()
ta.join()
ts.join()
# ts1.join()
因?yàn)橹婚_啟了一個(gè)進(jìn)行pop操作的線程，如果開啟多個(gè)pop操作的線程，必須在while前面加鎖，因?yàn)榭赡苡袃蓚€(gè)線程，一個(gè)執(zhí)行了while not numbers，發(fā)生了GIL的切換，另外一個(gè)線程執(zhí)行完了代碼，numbers剛好沒有了數(shù)據(jù)，導(dǎo)致結(jié)果一個(gè)pop成功，一個(gè)pop不成功。
所以number長度一定為1，如果把注釋去了，不一定為1
讀程序，請確認(rèn)執(zhí)行到最后number的長度是否一定為 1
import threading
import time
loop = int(1E7)
def _add(loop: int = 1):
global numbers
for _ in range(loop):
numbers.append(0)
def _sub(loop: int = 1):
global numbers
for _ in range(loop):
while not numbers:
time.sleep(1E-8)
numbers.pop()
numbers = [0]
ta = threading.Thread(target=_add, args=(loop,))
ts = threading.Thread(target=_sub, args=(loop,))
ta.start()
ta.join()
ts.start()
ts.join()
一定為1，因?yàn)槭峭降摹?/p>
讀程序，請確認(rèn)執(zhí)行到最后number是否一定為 0
import threading
loop = int(1E7)
def _add(loop: int = 1):
global numbers
for _ in range(loop):
numbers += 1
def _sub(loop: int = 1):
global numbers
for _ in range(loop):
numbers -= 1
numbers = 0
ta = threading.Thread(target=_add, args=(loop,))
ts = threading.Thread(target=_sub, args=(loop,))
ta.start()
ta.join()
ts.start()
ts.join()
一定等于0，因?yàn)槭峭降摹?/p>
讀程序，請確認(rèn)執(zhí)行到最后number是否一定為 0
import threading
loop = int(1E7)
def _add(loop: int = 1):
global numbers
for _ in range(loop):
numbers += 1
def _sub(loop: int = 1):
global numbers
for _ in range(loop):
numbers -= 1
numbers = 0
ta = threading.Thread(target=_add, args=(loop,))
ts = threading.Thread(target=_sub, args=(loop,))
ta.start()
ts.start()
ta.join()
ts.join()
不一定為0，因?yàn)槭钱惒降那掖嬖?+= 操作
七、判斷數(shù)據(jù)是否安全
是否數(shù)據(jù)共享，是同步還是異步（數(shù)據(jù)共享并且異步的情況下）
- +=、-=、*=、/=、a = 計(jì)算之后賦值給變量
- if、while 條件，這兩個(gè)判斷是由多個(gè)線程完成的
這兩種情況下，數(shù)據(jù)不安全。
八、進(jìn)程池 & 線程池
以前，有多少個(gè)任務(wù)就開多少個(gè)進(jìn)程或線程。
什么是池
要在程序開始的時(shí)候，還沒有提交任務(wù)，先創(chuàng)建幾個(gè)線程或者進(jìn)程，放在一個(gè)池子里，這就是池
為什么要用池
如果先開好進(jìn)程/線程，那么有任務(wù)之后就可以直接使用這個(gè)池中的數(shù)據(jù)了；并且開好的進(jìn)程/線程會(huì)一直存在在池中，可以被多個(gè)任務(wù)反復(fù)利用，這樣極大的減少了開啟/關(guān)閉/調(diào)度進(jìn)程/調(diào)度線程的時(shí)間開銷。
池中的線程/進(jìn)程個(gè)數(shù)控制了操作系統(tǒng)需要調(diào)用的任務(wù)個(gè)數(shù)，控制池中的單位，有利于提高操作系統(tǒng)的效率，減輕操作系統(tǒng)的負(fù)擔(dān)。
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor # threading模塊 沒有提供池 # multiprocessing模塊 仿照threading增加了Pool（逐漸被淘汰） # concurrent.futures模塊 線程池，進(jìn)程池都能夠用相似的方式開啟/使用 ThreadPoolExecutor() # 參數(shù)代表開啟多少個(gè)線程，線程的個(gè)數(shù)一般起cpu個(gè)數(shù)*4（或者*5） ProcessPoolExecutor() # 參數(shù)代表開啟多少個(gè)進(jìn)程，進(jìn)程的個(gè)數(shù)一般起cpu個(gè)數(shù)+1
創(chuàng)建線程池并提交任務(wù)
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import time
def func(a, b):
print(current_thread().ident, a, b)
time.sleep(1)
tp = ThreadPoolExecutor(4) # 創(chuàng)建線程池對象
for i in range(20):
# tp.submit(func, i, i + 1)
# 向池中提交任務(wù)
tp.submit(func, a=i, b=i + 1) # 位置傳參，關(guān)鍵字傳參都可以
創(chuàng)建進(jìn)程池并提交任務(wù)
from concurrent.futures import ProcessPoolExecutor
import os
import time
def func(a, b):
print(os.getpid(), 'start', a, b)
time.sleep(1)
print(os.getpid(), 'end', a, b)
if __name__ == '__main__':
tp = ProcessPoolExecutor(4) # 創(chuàng)建進(jìn)程池對象
for i in range(20):
# tp.submit(func, i, i + 1)
# 向池中提交任務(wù)
tp.submit(func, a=i, b=i + 1) # 位置傳參，關(guān)鍵字傳參都可以
獲取任務(wù)結(jié)果
from concurrent.futures import ProcessPoolExecutor
import os
import time
def func(a, b):
print(os.getpid(), 'start', a, b)
time.sleep(1)
print(os.getpid(), 'end', a, b)
return a * b
if __name__ == '__main__':
tp = ProcessPoolExecutor(4) # 創(chuàng)建進(jìn)程池對象
future_d = {}
for i in range(20): # 異步非阻塞的
ret = tp.submit(func, a=i, b=i + 1) # future未來對象
# print(ret) # <Future at 0x1ad918e1148 state=running>
# print(ret.result()) # 這樣需要等待，同步的
future_d[i] = ret
for key in future_d: # 同步阻塞的
print(key, future_d[key].result())
tp對象的map
map 只適合傳遞簡單的參數(shù)，并且必須是一個(gè)可迭代的類型
from concurrent.futures import ProcessPoolExecutor
import os
import time
def func(a):
print(os.getpid(), 'start', a[0], a[1])
time.sleep(1)
print(os.getpid(), 'end', a[0], a[1])
return a[0] * a[1]
if __name__ == '__main__':
tp = ProcessPoolExecutor(4)
ret = tp.map(func, ((i, i + 1) for i in range(20))) # 一般函數(shù)只接收一個(gè)參數(shù)，要想傳入多個(gè)，使用元組方式
for r in ret:
print(r)
回調(diào)函數(shù)
當(dāng)有一個(gè)結(jié)果需要進(jìn)行處理時(shí)，都會(huì)綁定一個(gè)回調(diào)函數(shù)來處理，除非是得到所有結(jié)果之后才做處理，我們使用 把結(jié)果存入列表 遍歷列表 的方式。
回調(diào)函數(shù)效率最高的。
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import time
def func(a, b):
print(current_thread().ident, 'start', a, b)
time.sleep(1)
print(current_thread().ident, 'end', a)
return a * b
if __name__ == '__main__':
tp = ThreadPoolExecutor(4)
future_d = {}
for i in range(20): # 異步非阻塞的
ret = tp.submit(func, a=i, b=i + 1)
future_d[i] = ret
for key in future_d: # 同步阻塞的
print(key, future_d[key].result())
上述代碼，打印結(jié)果是按照順序（0,1,2,3……），并不是誰先結(jié)束就打印誰。
使用回調(diào)函數(shù)以后，誰先執(zhí)行完就打印誰，代碼如下：
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import time
def func(a, b):
print(current_thread().ident, 'start', a, b)
time.sleep(1)
print(current_thread().ident, 'end', a)
return a, a * b
def print_func(ret): # 異步阻塞 每個(gè)任務(wù)都是各自阻塞各自，誰先執(zhí)行完誰先打印
print(ret.result())
if __name__ == '__main__':
tp = ThreadPoolExecutor(4)
for i in range(20): # 異步非阻塞的
ret = tp.submit(func, a=i, b=i + 1) # [ret0, ret1, ..., ret19]
ret.add_done_callback(print_func) # 異步阻塞 [print_func, print_func,...,print_func]
# 回調(diào)機(jī)制
# 回調(diào)函數(shù) 給ret對象綁定一個(gè)回調(diào)函數(shù)，等待ret對應(yīng)的任務(wù)有了結(jié)果之后立即調(diào)用print_func函數(shù)
# 就可以對結(jié)果立即進(jìn)行處理，而不用按照順序接收結(jié)果處理結(jié)果
ret這個(gè)任務(wù)會(huì)在執(zhí)行完畢的瞬間立即觸發(fā)print_func函數(shù)，并且把任務(wù)的返回值對象傳遞到print_func做參數(shù)。
回調(diào)函數(shù)的例子
from concurrent.futures import ThreadPoolExecutor
import requests
def get_page(url): # 訪問網(wǎng)頁，獲取網(wǎng)頁源代碼，用線程池中的線程來操作
respone = requests.get(url)
if respone.status_code == 200:
return {'url': url, 'text': respone.text}
def parse_page(res): # 獲取到字典結(jié)果之后，計(jì)算網(wǎng)頁源代碼的長度，把'https://www.baidu.com : 長度值'寫到文件里，線程任務(wù)執(zhí)行完畢之后綁定回調(diào)函數(shù)
res = res.result()
parse_res = 'url:<%s> size:[%s]\n' % (res['url'], len(res['text']))
with open('db.txt', 'a') as f:
f.write(parse_res)
if __name__ == '__main__':
urls = [
'https://www.baidu.com',
'https://www.python.org',
'https://www.openstack.org',
'https://www.tencent.com/zh-cn',
'http://www.sina.com.cn/'
]
tp = ThreadPoolExecutor(4)
for url in urls:
ret = tp.submit(get_page, url)
ret.add_done_callback(parse_page) # 誰先回來誰就先把結(jié)果寫進(jìn)文件
# 不用回調(diào)函數(shù)：
# 按照順序獲取網(wǎng)頁，baidu python openstack tencent sina
# 也只能按照順序?qū)?
# 用上了回調(diào)函數(shù)
# 按照順序獲取網(wǎng)頁，baidu python openstack tencent sina
# 哪一個(gè)網(wǎng)頁先返回結(jié)果，就先執(zhí)行哪個(gè)網(wǎng)頁對應(yīng)的回調(diào)函數(shù)（parse_page）
進(jìn)程池線程池的應(yīng)用場景 進(jìn)程池：
場景：高計(jì)算的場景，沒有IO操作（沒有文件操作，沒有數(shù)據(jù)庫操作，沒有網(wǎng)絡(luò)操作，沒有input）；
進(jìn)程的個(gè)數(shù)：[cpu_count*1, cpu_count*2]
線程池：
場景：爬蟲
線程的個(gè)數(shù)：一般根據(jù)IO的比例定制，cpu_count*5
到此這篇關(guān)于Python一些線程的玩法總結(jié)的文章就介紹到這了,更多相關(guān)Python線程的玩法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Python根據(jù)已知鄰接矩陣?yán)L制無向圖操作示例
這篇文章主要介紹了Python根據(jù)已知鄰接矩陣?yán)L制無向圖操作,涉及Python使用networkx、matplotlib進(jìn)行數(shù)值運(yùn)算與圖形繪制相關(guān)操作技巧,需要的朋友可以參考下2018-06-06
Python中關(guān)于面向?qū)ο笾欣^承的詳細(xì)講解
面向?qū)ο缶幊?(OOP) 語言的一個(gè)主要功能就是“繼承”。繼承是指這樣一種能力：它可以使用現(xiàn)有類的所有功能，并在無需重新編寫原來的類的情況下對這些功能進(jìn)行擴(kuò)展2021-10-10
這篇文章主要介紹了django之自定義軟刪除Model的方法，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2019-08-08
這篇文章主要和大家分享五個(gè)Python中隱藏的實(shí)用技巧，文中的示例代碼講解詳細(xì)，對我們學(xué)習(xí)Python有一定的幫助，感興趣的小伙伴可以學(xué)習(xí)一下2022-05-05
Python數(shù)據(jù)可視化處理庫PyEcharts柱狀圖,餅圖,線性圖,詞云圖常用實(shí)例詳解
這篇文章主要介紹了Python數(shù)據(jù)可視化處理庫PyEcharts柱狀圖、餅圖、線性圖常用實(shí)例詳解,需要的朋友可以參考下2020-02-02
這篇文章主要介紹了python中的元組與列表及元組的更改，元組是由一對方括號(hào)構(gòu)成的序列。列表創(chuàng)建后，可以根據(jù)自己的需要改變他的內(nèi)容，下面更多詳細(xì)內(nèi)容，需要的小伙伴可以參考一下2022-03-03
Python實(shí)現(xiàn)統(tǒng)計(jì)文章閱讀量的方法詳解
這篇文章主要為大家詳細(xì)介紹了如何溧陽Python語言實(shí)現(xiàn)統(tǒng)計(jì)文章閱讀量的功能，文中的示例代碼講解詳細(xì)，感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下2023-02-02
使用PyTorch將文件夾下的圖片分為訓(xùn)練集和驗(yàn)證集實(shí)例
今天小編就為大家分享一篇使用PyTorch將文件夾下的圖片分為訓(xùn)練集和驗(yàn)證集實(shí)例，具有很好的參考價(jià)值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-01-01
這篇文章主要介紹了Python paramiko使用方法代碼匯總,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2020-11-11
pytorch nn.Conv2d()中的padding以及輸出大小方式
今天小編就為大家分享一篇pytorch nn.Conv2d()中的padding以及輸出大小方式，具有很好的參考價(jià)值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-01-01