Python-多線程、多進(jìn)程、協(xié)程
基本使用
**基本概念
**
- 進(jìn)程
- 幾乎所有的操作系統(tǒng)都支持同時(shí)運(yùn)行多個(gè)任務(wù)，一個(gè)任務(wù)通常就是一個(gè)程序，每個(gè)運(yùn)行中的程序就是一個(gè)進(jìn)程
- 進(jìn)程是處于運(yùn)行過程中的程序，并且具有一定的獨(dú)立功能
- 進(jìn)程是系統(tǒng)進(jìn)行資源分配調(diào)度的一個(gè)獨(dú)立單位
- 線程
- 線程（Thread）也叫 輕量級(jí)進(jìn)程 ，是操作系統(tǒng)能夠進(jìn)行運(yùn)算調(diào)度的最小單位
- 它被包涵在進(jìn)程之中，是進(jìn)程中的實(shí)際運(yùn)作單位，線程自己不擁有系統(tǒng)資源，只擁有一點(diǎn)兒在運(yùn)行中必不可少的資源，但它可與同屬一個(gè)進(jìn)程的其它線程共享進(jìn)程所擁有的全部資源
- 進(jìn)程中的多個(gè)線程之間可以并發(fā)執(zhí)行
一個(gè)進(jìn)程可以擁有多個(gè)線程，一個(gè)線程必須有一個(gè)父進(jìn)程。線程可以擁有自己的堆棧、自己的程序計(jì)數(shù)器和自己的局部變量，但不擁有系統(tǒng)資源，它與父進(jìn)程的其他線程共享該進(jìn)程所擁有的全部資源。
多線程的優(yōu)點(diǎn)
- 進(jìn)程之間不能共享內(nèi)存，但線程之間共享內(nèi)存非常容易
- 操作系統(tǒng)在創(chuàng)建進(jìn)程時(shí)，需要為該進(jìn)程重新分配系統(tǒng)資源，但創(chuàng)建線程的代價(jià)則小得多。因此，使用多線程來實(shí)現(xiàn)多任務(wù)并發(fā)執(zhí)行比使用多進(jìn)程的效率高
- Python 語言內(nèi)置了多線程功能支持，而不是單純地作為底層操作系統(tǒng)的調(diào)度方式，從而簡(jiǎn)化了 Python 的多線程編程
示例
**方式一： **使用 threading.Thread(target=方法名) 的方式實(shí)現(xiàn)多線程
參數(shù)說明：threading.Thread(參數(shù)說明)
- target： 指定該線程要調(diào)度的目標(biāo)方法。只傳函數(shù)名，不傳函數(shù)，即不加()
- args： 指定一個(gè)元組，以位置參數(shù)的形式為target指定的函數(shù)傳入?yún)?shù)。元組的第一個(gè)參數(shù)傳給target的第一個(gè)，以此類推
- kwargs： 指定一個(gè)字典，以關(guān)鍵字參數(shù)的形式為target指定的函數(shù)傳入?yún)?shù)
- daemon:指定所構(gòu)建的線程是否為后臺(tái)線程
import time
import threading
def eat(num):
for i in range(num):
print("我正在吃飯......")
time.sleep(1)
def drunk(num=10):
for i in range(num):
print("我正在喝水......")
time.sleep(1)
if __name__ == '__main__':
# 創(chuàng)建兩個(gè)線程
t1 = threading.Thread(target=eat, args=(10,))
t2 = threading.Thread(target=drunk)
# 啟動(dòng)兩個(gè)線程
t1.start()
t2.start()
while True:
threadList = threading.enumerate()
print("正在運(yùn)行的線程是：", threadList)
print("正在運(yùn)行的線程數(shù)量是：", len(threadList))
time.sleep(2)
方式二： 繼承threading.Thread
import time
import threading
class MyThread(threading.Thread):
def run(self):
for i in range(10):
print("線程啟動(dòng)了，我的名字叫：", self.name)
time.sleep(1)
if __name__ == '__main__':
# 創(chuàng)建兩個(gè)線程
t1 = MyThread()
t2 = MyThread()
# 啟動(dòng)兩個(gè)線程, start() 方法內(nèi)部會(huì)自動(dòng)去調(diào)用 run方法，所以此處寫 start() 就可以了
t1.start()
t2.start()
while True:
threadList = threading.enumerate()
print("正在運(yùn)行的線程是：", threadList)
print("正在運(yùn)行的線程數(shù)量是：", len(threadList))
time.sleep(2)
全局變量、互斥鎖、死鎖
共享全局變量示例
import threading
g_num = 0
def fun_1(num):
global g_num
for i in range(num):
g_num += 1
print("------fun_1的g_num值：%d" % g_num)
def fun_2(num):
global g_num
for i in range(num):
g_num += 1
print("------fun_2的g_num值：%d" % g_num)
if __name__ == '__main__':
t1 = threading.Thread(target=fun_1, args=(1000000,))
t2 = threading.Thread(target=fun_2, args=(1000000,))
t1.start()
t2.start()
輸出結(jié)果 ：
從以上結(jié)果可以看出，直接使用全局變量是有問題的，按理說，預(yù)期結(jié)果應(yīng)該是2000000，實(shí)際結(jié)果相關(guān)很大，且每次執(zhí)行結(jié)果都不一樣
原因
- 在g_num=0 時(shí)，t1取得g_num=0，此時(shí)系統(tǒng)把t1調(diào)度為 "sleeping" 狀態(tài)，把t2轉(zhuǎn)換為 "running" 狀態(tài)，t2 這時(shí)也獲得了 g_num=0
- 然后 t2對(duì)得到的值進(jìn)行加1，并賦給g_num，使得g_num=1
- 然后系統(tǒng)又把 t2調(diào)度為"sleeing"，把t1轉(zhuǎn)為"running",線程t1又把它之前得到的0 加1后賦值給 g_num。
- 這樣就導(dǎo)致了 t1和t2都對(duì) g_num加1，但結(jié)果仍然是 g_num=1
解決方案：互斥鎖
- 當(dāng)多個(gè)線程幾乎同時(shí)修改某個(gè)共享數(shù)據(jù)的時(shí)候，需要進(jìn)行同步控制
- 某個(gè)線程要更改共享數(shù)據(jù)時(shí)，先將其鎖定，此時(shí)資源狀態(tài)為**” 鎖定 “ ，其他線程不能更改；直到該線程釋放資源，將資源的狀態(tài)改為 ”**非鎖定 “， 其他的線程才能再次鎖定該資源。互拆鎖保證了 每次只有一個(gè)線程進(jìn)行寫入操作 ，從而保證了多線程數(shù)據(jù)的正確性
import threading
g_num = 0
def fun_1(num):
global g_num
for i in range(num):
# 上鎖，如果之前沒上鎖，此時(shí)調(diào)用就會(huì)上鎖；如果之前上鎖了，此時(shí)調(diào)用就會(huì)阻塞，直接鎖被別人釋放
lock.acquire()
g_num += 1
# 釋放鎖
lock.release()
print("------fun_1的g_num值：%d" % g_num)
def fun_2(num):
global g_num
for i in range(num):
# 上鎖，如果之前沒上鎖，此時(shí)調(diào)用就會(huì)上鎖；如果之前上鎖了，此時(shí)調(diào)用就會(huì)阻塞，直接鎖被別人釋放
lock.acquire()
g_num += 1
# 釋放鎖
lock.release()
print("------fun_2的g_num值：%d" % g_num)
if __name__ == '__main__':
# 創(chuàng)建一個(gè)互斥鎖，默認(rèn)是沒上鎖的
lock=threading.Lock()
t1 = threading.Thread(target=fun_1, args=(1000000,))
t2 = threading.Thread(target=fun_2, args=(1000000,))
t1.start()
t2.start()
死鎖
- 在線程共享多個(gè)資源的時(shí)候，如果兩個(gè)線程分別占有一部分資源并且同時(shí)等待對(duì)方的資源，就會(huì)造成死鎖
- 盡管死鎖很少發(fā)生，但一旦發(fā)生就會(huì)造成程序停止響應(yīng)
import threading
import time
def fun_1():
# 1號(hào)鎖，上鎖
lock1.acquire()
print("fun_1..do some thing.........1")
time.sleep(1)
# 2號(hào)鎖，上鎖，如果被別人占用了，則會(huì)阻塞
lock2.acquire()
print("fun_1..do some thing..........2")
# 釋放2號(hào)鎖
lock2.release()
# 釋放1號(hào)鎖
lock1.release()
def fun_2():
# 2號(hào)鎖，上鎖
lock2.acquire()
print("fun_2..do some thing.........2")
time.sleep(1)
# 1號(hào)鎖，上鎖，如果被別人占用了，則會(huì)阻塞
lock1.acquire()
print("fun_2..do some thing..........1")
# 釋放1號(hào)鎖
lock1.release()
# 釋放2號(hào)鎖
lock2.release()
if __name__ == '__main__':
# 創(chuàng)建兩個(gè)互斥鎖
lock1=threading.Lock()
lock2=threading.Lock()
t1 = threading.Thread(target=fun_1)
t2 = threading.Thread(target=fun_2)
t1.start()
t2.start()
輸出結(jié)果：會(huì)一直停止阻塞
死鎖解決方案
-
程序設(shè)計(jì)時(shí)避免
-
**添加超時(shí)等待
**
進(jìn)程
進(jìn)程的狀態(tài)
- 新建：操作系統(tǒng)調(diào)度啟動(dòng)一個(gè)新進(jìn)程
- 就緒態(tài)：運(yùn)行的條件都已經(jīng)滿足，等待cpu執(zhí)行
- 執(zhí)行態(tài)：cpu 正在執(zhí)行
- 等待態(tài)：等待某些條件滿足，例如一個(gè)程序sleep了，此時(shí)就處于等待態(tài)
進(jìn)程的創(chuàng)建
- 在python中，提供了 multiprocessing 模塊，就是跨平臺(tái)的多進(jìn)程模塊，模塊提供了 Process類來代表一人進(jìn)程對(duì)象，這個(gè)對(duì)象可以理解為一個(gè)獨(dú)立的進(jìn)程
- Process 參數(shù)說明
- target：傳遞函數(shù)的引用，子進(jìn)程將執(zhí)行這個(gè)函數(shù)
- args：給target指定的函數(shù)，傳遞參數(shù),以元組的方式傳遞,非必填
- kwargs：給target指定的函數(shù)傳遞命名參數(shù)，非必填
- name：給進(jìn)程設(shè)定一個(gè)名稱,非必填
- group：指定進(jìn)程組，非必填
- Process 對(duì)象的常用方法
- start()：?jiǎn)?dòng)子進(jìn)程
- is_alive()：判斷子進(jìn)程是否還活著
- join(timeout)：是否等待子進(jìn)程執(zhí)行結(jié)束，或等待多少秒
- terminate()：不管任務(wù)是否完成，立即終止子進(jìn)程
- Process 對(duì)象的常用屬性
- name：當(dāng)前進(jìn)程的別名，默認(rèn)為Process-x, x為從1開始遞增的整數(shù)
- pid：當(dāng)前進(jìn)程的pid (進(jìn)程號(hào))
示例
import time
import os
import multiprocessing
def eat(num):
for i in range(num):
print("我正在吃飯......,我的進(jìn)程號(hào)是：%d,父進(jìn)程的進(jìn)程號(hào)是：%d" % (os.getpid(),os.getppid()))
time.sleep(1)
def drunk(num):
for i in range(num):
print("我正在喝水......我的進(jìn)程號(hào)是：%d,父進(jìn)程的進(jìn)程號(hào)是：%d" % (os.getpid(),os.getppid()))
time.sleep(1)
if __name__ == '__main__':
# 創(chuàng)建兩個(gè)進(jìn)程
p1 = multiprocessing.Process(target=eat, args=(10,))
p2 = multiprocessing.Process(target=drunk, args=(10,))
# 啟動(dòng)兩個(gè)進(jìn)程
p1.start()
p2.start()
print("主進(jìn)程的進(jìn)程號(hào)是：%d" %os.getpid())
輸出結(jié)果
進(jìn)程線程區(qū)別
- 功能區(qū)別
- 進(jìn)程：能夠完成多任務(wù)，比如，在一臺(tái)電腦上運(yùn)行多個(gè)qq
- 線程：能夠完成多任務(wù)，比如，在一個(gè)qq中開多個(gè)聊天窗口
- 調(diào)度
- 進(jìn)程是資源分配的基本單位
- 線程是cpu調(diào)度和執(zhí)行的最小單位
- 擁有資源
- 進(jìn)程擁有資源的一個(gè)獨(dú)立單位
- 線程不擁有系統(tǒng)資源，但可以訪問隸屬于進(jìn)程的資源
- 穩(wěn)定性
進(jìn)程有獨(dú)立的地址空間，多進(jìn)程較穩(wěn)定，因?yàn)槠渲幸粋€(gè)出現(xiàn)狀況不影 響另外一個(gè)
同一個(gè)進(jìn)程的多個(gè)線程，共用地址空間，多線程相比于多進(jìn)程，穩(wěn)定性要差，因?yàn)橐粋€(gè)線程出現(xiàn)問題會(huì)嚴(yán)重影響其他線程
- 依賴關(guān)系
- 一個(gè)線程只能屬性一個(gè)進(jìn)程
- 一個(gè)進(jìn)程至少有一個(gè)線程
- 針對(duì)全局變量的共享
- 多進(jìn)程間不共享全局變量（進(jìn)程間都是獨(dú)立的）
- 多線程間共享全局變量
進(jìn)程間的通信
- 不同的進(jìn)程間有時(shí)也需要進(jìn)行數(shù)據(jù)傳遞，在Python中，可以使用 muitiprocessiong模塊的 Queue ，來實(shí)現(xiàn)進(jìn)程間的數(shù)據(jù)傳遞
- Queue 是一個(gè)消息隊(duì)列，數(shù)據(jù)是先進(jìn)先出的原則
示例
import time
import multiprocessing
def set_data(queue):
numList=[1,2,3,4]
for i in numList:
# 給隊(duì)列中放數(shù)據(jù),如果隊(duì)列已經(jīng)滿了，則會(huì)阻塞，直到能放數(shù)據(jù)為止
queue.put(i)
time.sleep(1)
def get_data(queue):
while True:
# 判斷隊(duì)列中如果沒有數(shù)據(jù)了，則退出循環(huán)
if queue.empty():
break
# 從隊(duì)列中取數(shù)據(jù)
data=queue.get()
print("從隊(duì)列中取出的數(shù)據(jù)是：",data)
if __name__ == '__main__':
# 創(chuàng)建一個(gè)消息列表，容量是3(表示只能裝3個(gè)數(shù)據(jù))
queue=multiprocessing.Queue(3)
# 創(chuàng)建兩個(gè)進(jìn)程
p1 = multiprocessing.Process(target=set_data, args=(queue,))
p2 = multiprocessing.Process(target=get_data, args=(queue,))
# 啟動(dòng)兩個(gè)進(jìn)程
p1.start()
p2.start()
**輸出結(jié)果 **
進(jìn)程池
- 需要?jiǎng)?chuàng)建成百上千個(gè)進(jìn)程時(shí)，可以使用 muitiprocessing模塊提供的 Pool 方法
- 初始化Pool時(shí) ，可以指定一個(gè)最大進(jìn)程數(shù)，當(dāng)有新的請(qǐng)求提交到Pool中時(shí)，如果池里面沒有滿，就會(huì)創(chuàng)建一個(gè)新的進(jìn)程來執(zhí)行該請(qǐng)求，如果已經(jīng)滿了，那么就會(huì)等待，直到池中有空閑進(jìn)程，會(huì)調(diào)用空閑進(jìn)程來執(zhí)行新任務(wù)
示例
import time
import os
import multiprocessing
def work(msg):
print("開始執(zhí)行工作,當(dāng)前進(jìn)程是：",os.getpid())
time.sleep(2)
print("接收到的消息數(shù)據(jù)是：%s"%msg)
if __name__ == '__main__':
# 創(chuàng)建進(jìn)程池，容量為3
pool=multiprocessing.Pool(3)
for i in range(10):
# pool.apply_async(要調(diào)用的目標(biāo)，（傳遞給目標(biāo)的參數(shù)元組,））
# 每次循環(huán)將會(huì)用空閑的子進(jìn)程去執(zhí)行任務(wù)
pool.apply_async(work,("傳遞參數(shù):%d"%i,))
# 關(guān)閉進(jìn)程池，關(guān)閉后進(jìn)程池不再接收新請(qǐng)求
pool.close()
# 等待進(jìn)程池中所有的子進(jìn)程執(zhí)行完成 ，必須放在close 語句之后
pool.join()
輸出結(jié)果
協(xié)程
迭代器
- 迭代是訪問集合元素的一種方式
- 迭代器是一個(gè)可以記住遍歷位置的對(duì)象。
- 迭代器對(duì)象從集合的第一個(gè)元素開始訪問，直到所有的元素都訪問完成
- 迭代器只會(huì)前進(jìn)，不會(huì)后退
- 我們把對(duì) list、set、str、tuple 等類型的數(shù)據(jù)使用 for...in ... 的方式從中獲取數(shù)據(jù)，這樣的過程稱為 遍歷（循環(huán)） ，也叫迭代
判斷一個(gè)數(shù)據(jù)類型是否可迭代，使用 isinstance(xxx,Iterable)
from collections.abc import Iterable
list1=[1,2]
str1="123"
tuple1=(1,2)
dict1={1:"a",2:"b"}
num=122
print(isinstance(list1,Iterable))
print(isinstance(str1,Iterable))
print(isinstance(tuple1,Iterable))
print(isinstance(dict1,Iterable))
print(isinstance(num,Iterable))
輸出結(jié)果
自已實(shí)現(xiàn)迭代器示例
class MyIterator:
"""自己實(shí)現(xiàn)一個(gè)迭代器"""
def __init__(self):
self.name = list()
self.currentIndex = 0
def add(self, arg):
self.name.append(arg)
def __iter__(self):
# 如果想要一個(gè)對(duì)象成為可以被迭代的對(duì)象，即可以使用 for ... in ... ，那么必須實(shí)現(xiàn) __iter__ 方法
return self
def __len__(self):
return len(self.name)
def __next__(self):
# 當(dāng)使用for...in... 迭代時(shí)，會(huì)先調(diào)用 __iter__ 方法，然后調(diào)用其返回對(duì)象中的 __next__ 方法(即本方法)
if self.currentIndex < len(self.name):
result = self.name[self.currentIndex]
self.currentIndex += 1
return result
else:
# 拋出一個(gè) 停止迭代的異常
raise StopIteration
myIter = MyIterator()
myIter.add("張三")
myIter.add("李四")
myIter.add("王五")
for i in myIter:
print(i)
# 獲取集合長(zhǎng)度
print(len(myIter))
**生成器
**
- 生成器是一種特殊的迭代器
- 創(chuàng)建生成器有兩種方式
- 方式一：把一個(gè)列表生成式的[] 改成 ()
-
# 原始列表 l=[x*2 for x in range(10)] # 構(gòu)建生成器 g=(x*2 for x in range(10)) # 迭代創(chuàng)建的生成器 for i in g: print(i)
- 方式二：使用 yield 關(guān)鍵字
-
def create_age(num): currentAge=0 while currentAge
協(xié)程
- 實(shí)現(xiàn)方式一：采用yield 實(shí)現(xiàn)
import time
def eat():
while True:
print("我在吃飯.....")
time.sleep(1)
yield
def drunk():
while True:
print("我在喝水.....")
time.sleep(1)
yield
if __name__ == '__main__':
# 創(chuàng)建兩個(gè)生成器
eat=eat()
drunk=drunk()
while True:
next(eat)
next(drunk)
- 實(shí)現(xiàn)方式二：采用 greenlet 實(shí)現(xiàn)
- 先安裝 greenlet 模塊：pip install greenlet
import time
from greenlet import greenlet
def eat():
while True:
print("我在吃飯.....")
# 切換到g2中運(yùn)行
g2.switch()
time.sleep(1)
def drunk():
while True:
print("我在喝水.....")
# 切換到g1中運(yùn)行
g1.switch()
time.sleep(1)
if __name__ == '__main__':
# 創(chuàng)建兩個(gè)生成器
g1 = greenlet(eat)
g2 = greenlet(drunk)
# 切換到g1中運(yùn)行
g1.switch()
- 實(shí)現(xiàn)方式三：采用 gevent實(shí)現(xiàn) （ 推薦使用 ）
- 由于 greenlet 需要人手動(dòng)切換，比較占用IO資源，并且會(huì)出現(xiàn)，一旦中間某個(gè)程序處于線程等待的話，會(huì)一直等待很長(zhǎng)時(shí)間的問題。所以gevent就應(yīng)運(yùn)而生，gevent 遇到延時(shí)阻塞會(huì)自動(dòng)切換
- 先安裝 gevent模塊：pip install gevent
import time
import gevent
from gevent import monkey
# 有耗時(shí)操作時(shí)需要, 將程序中用到的耗時(shí)操作的代碼，換為gevent中自己實(shí)現(xiàn)的模塊
monkey.patch_all()
def work(num):
for i in range(num):
print(gevent.getcurrent(), i)
# 使用 mokey.patch_all() 之后，程序會(huì)自動(dòng)替換成 gevent里面的 gevent.sleep() 方法
time.sleep(1)
if __name__ == '__main__':
# 創(chuàng)建并啟動(dòng)協(xié)程
gevent.joinall({
gevent.spawn(work, 10),
gevent.spawn(work, 10)
})
圖片下載器實(shí)現(xiàn)
import gevent
from gevent import monkey
from urllib import request
# 有耗時(shí)操作時(shí)需要, 將程序中用到的耗時(shí)操作的代碼，換為gevent中自己實(shí)現(xiàn)的模塊
monkey.patch_all()
def down_pic(filename,url):
resp=request.urlopen(url)
data=resp.read()
# 寫入文件
with open(filename,"wb") as f:
f.write(data)
if __name__ == '__main__':
# 創(chuàng)建并啟動(dòng)協(xié)程
gevent.joinall({
gevent.spawn(down_pic, "1.jpg","https://himg3.qunarzz.com/imgs/201812/14/C._M0DCiiigrWCy4LQi1024.jpg"),
gevent.spawn(down_pic, "2.jpg","https://source.qunarzz.com/site/images/zhuanti/huodong/shangwu.jpg")
})
總結(jié)
- 進(jìn)程是資源分配的單位
- 線程是操作系統(tǒng)調(diào)度的單位
- 進(jìn)程切換需要的資源最大，效率很低
- 線程切換需要的資源一般，效率一般（不考慮GIL的情況下）
- 協(xié)程切換任務(wù)資源很小，效率高
- 多進(jìn)程、多線程根據(jù)cpu核數(shù)不一樣可能是并行的，但是協(xié)程是在一個(gè)線程中，所以是并發(fā)
聲明：本文內(nèi)容及配圖由入駐作者撰寫或者入駐合作網(wǎng)站授權(quán)轉(zhuǎn)載。文章觀點(diǎn)僅代表作者本人，不代表電子發(fā)燒友網(wǎng)立場(chǎng)。文章及其配圖僅供工程師學(xué)習(xí)之用，如有內(nèi)容侵權(quán)或者其他違規(guī)問題，請(qǐng)聯(lián)系本站處理。
舉報(bào)投訴
-
操作系統(tǒng)
+關(guān)注
關(guān)注
37文章
6834瀏覽量
123348 -
程序
+關(guān)注
關(guān)注
117文章
3787瀏覽量
81073 -
任務(wù)
+關(guān)注
關(guān)注
1文章
20瀏覽量
8547 -
進(jìn)程
+關(guān)注
關(guān)注
0文章
203瀏覽量
13962
發(fā)布評(píng)論請(qǐng)先 登錄
相關(guān)推薦
多線程和多進(jìn)程的區(qū)別
6.你的數(shù)據(jù)庫(kù)一會(huì)又500個(gè)連接數(shù)，一會(huì)有10個(gè)，你分析一下情況7.udp和tcp的區(qū)別8.多線程和多進(jìn)程的區(qū)別9.有一臺(tái)web服務(wù)器，你選擇用多線程還是多進(jìn)程，...
發(fā)表于 07-19 07:21
淺談多進(jìn)程多線程的選擇
魚還是熊掌：淺談多進(jìn)程多線程的選擇關(guān)于多進(jìn)程和多線程，教科書上最經(jīng)典的一句話是“進(jìn)程是資源分配的最小單位，
發(fā)表于 08-24 07:38
協(xié)程和線程有什么區(qū)別
協(xié)程和線程的區(qū)別協(xié)程和線程的共同目的之一是實(shí)現(xiàn)系統(tǒng)資源的上下文調(diào)用，不過它們的實(shí)現(xiàn)層級(jí)不同；
發(fā)表于 12-10 06:23
python多線程和多進(jìn)程對(duì)比
段可以干多件事，譬如可以邊吃飯邊看電視；在Python中，多線程 和 協(xié)程 雖然是嚴(yán)格上來說是串行，但卻比一般的串行程序執(zhí)行效率高得很。 一般的串行程序，在程序阻塞的時(shí)候，只能干等著，
發(fā)表于 03-15 16:42
LINUX系統(tǒng)下多線程與多進(jìn)程性能分析
采用多進(jìn)程處理多個(gè)任務(wù)，會(huì)占用很多系統(tǒng)資源（主要是CPU 和內(nèi)存的使用）。在LINUX 中，則對(duì)這種弊端進(jìn)行了改進(jìn)，在用戶態(tài)實(shí)現(xiàn)了多線程處理多任務(wù)。本文系統(tǒng)論述了多線程間
發(fā)表于 08-13 08:31
?20次下載
如何選好多線程和多進(jìn)程
關(guān)于多進(jìn)程和多線程，教科書上最經(jīng)典的一句話是“進(jìn)程是資源分配的最小單位，線程是CPU調(diào)度的最小單位”，這句話應(yīng)付考試基本上夠了，但如果在工作中遇到類似的選擇問題，那就沒有這么簡(jiǎn)單了，選
多進(jìn)程與多線程的深度比較
嵌入式Linux中文站，關(guān)于多進(jìn)程和多線程，教科書上最經(jīng)典的一句話是“進(jìn)程是資源分配的最小單位，線程是CPU調(diào)度的最小單位”。這句話應(yīng)付考試基本上夠了，但如果在工作中遇
發(fā)表于 04-02 14:42
?473次閱讀
Python后端項(xiàng)目的協(xié)程是什么
最近公司 Python 后端項(xiàng)目進(jìn)行重構(gòu)，整個(gè)后端邏輯基本都變更為采用“異步”協(xié)程的方式實(shí)現(xiàn)?？粗鴿M屏幕經(jīng)過 async await（協(xié)程在
python多線程和多進(jìn)程的對(duì)比
在同一時(shí)間段可以干多件事，譬如可以邊吃飯邊看電視； 在Python中， 多線程 和 協(xié)程 雖然是嚴(yán)格上來說是串行，但卻比一般的串行程序執(zhí)行效率高得很。 一般的串行程序，在程序阻塞的時(shí)候
Python多進(jìn)程學(xué)習(xí)
Python 多進(jìn)程 (Multiprocessing) 是一種同時(shí)利用計(jì)算機(jī)多個(gè)處理器核心 (CPU cores) 進(jìn)行并行處理的技術(shù)，它與 Python 的多線程 (Multith
淺談Linux網(wǎng)絡(luò)編程中的多進(jìn)程和多線程
在Linux網(wǎng)絡(luò)編程中，我們應(yīng)該見過很多網(wǎng)絡(luò)框架或者server，有多進(jìn)程的處理方式，也有多線程處理方式，孰好孰壞并沒有可比性，首先選擇多進(jìn)程還是多線程我們需要考慮業(yè)務(wù)場(chǎng)景，其次結(jié)合當(dāng)
發(fā)表于 08-08 16:56
?829次閱讀
關(guān)于Python多進(jìn)程和多線程詳解
進(jìn)程（process）和線程（thread）是操作系統(tǒng)的基本概念，但是它們比較抽象，不容易掌握。關(guān)于多進(jìn)程和多線程，教科書上最經(jīng)典的一句話是“進(jìn)程
Linux系統(tǒng)上多線程和多進(jìn)程的運(yùn)行效率
關(guān)于多進(jìn)程和多線程，教科書上最經(jīng)典的一句話是“進(jìn)程是資源分配的最小單位，線程是CPU調(diào)度的最小單位”，這句話應(yīng)付考試基本上夠了，但如果在工作中遇到類似的選擇問題，那就沒有這么簡(jiǎn)單了，選
你還是分不清多進(jìn)程和多線程嗎？一文搞懂！
你還是分不清多進(jìn)程和多線程嗎？一文搞懂！ 多進(jìn)程和多線程是并發(fā)編程中常見的兩個(gè)概念，它們都可以用于提高程序的性能和效率。但是它們的實(shí)現(xiàn)方式和使用場(chǎng)景略有不同。 1.
Python中多線程和多進(jìn)程的區(qū)別
Python作為一種高級(jí)編程語言，提供了多種并發(fā)編程的方式，其中多線程與多進(jìn)程是最常見的兩種方式之一。在本文中，我們將探討Python中多線程
工商網(wǎng)監(jiān)
評(píng)論