style alt 列表 過多 all 同步請求 nag pool cpu調度

異步的 apply_async
# 1.如果是異步的提交任務,那麽任務提交之後進程池和主進程也異步了,
#主進程不會自動等待進程池中的任務執行完畢
# 2.如果需要主進程等待,需要p.join
# 但是join的行為是依賴close
# 3.如果這個函數是有返回值的
# 也可以通過ret.get()來獲取返回值
# 但是如果一邊提交一遍獲取返回值會讓程序變成同步的
# 所以要想保留異步的效果,應該講返回對象保存在列表裏,所有任務提交完成之後再來取結果
# 這種方式也可以去掉join,來完成主進程的阻塞

同步請求的

import os
import time
from
 
 multiprocessing import Pool
# 同步請求的
# def wahaha():
#     time.sleep(1)
#     print(os.getpid())
#     return True
#
# if __name__ == ‘__main__‘:
#     p = Pool(5)  # CPU的個數 或者 +1
#     ret_l = []
#     for i in range(20):
#        ret = p.apply(func = wahaha)   # 同步的,不用
#        print(ret)

View Code

異步請求的

ef wahaha():
    time.sleep(1)
    print(os.getpid())

if __name__ == ‘__main__‘:
    p = Pool(5)  # CPU的個數 或者 +1
    ret_l = []
    for i in range(20):
       ret = p.apply_async(func = wahaha) # async  異步的
       ret_l.append(ret)
    p.close()  # 關閉 進程池中的進程不工作了
               # 而是關閉了進程池,讓任務不能再繼續提交了
    p.join()   # 等待這個池中提交的任務都執行完
    # # 表示等待所有子進程中的代碼都執行完 主進程才結束
 

View Code

# 異步提交,獲取返回值,等待所有任務都執行完畢之後再統一獲取結果

def wahaha():
    time.sleep(1)
    print(os.getpid())
    return True

if __name__ == ‘__main__‘:
    p = Pool(5)  # CPU的個數 或者 +1
    ret_l = []
    for i in range(20):
       ret = p.apply_async(func = wahaha) # async  異步的
       ret_l.append(ret)
    p.close()  # 關閉 進程池中的進程不工作了
               # 而是關閉了進程池,讓任務不能再繼續提交了
    p.join()   # 等待這個池中提交的任務都執行完
    for ret in ret_l:
        print(ret.get())

View Code

異步提交,獲取返回值,一個任務執行完畢之後就可以獲取到一個結果(順序是按照提交任務的順序)

def wahaha():
    time.sleep(1)
    print(os.getpid())
    return True

if __name__ == ‘__main__‘:
    p = Pool(5)  # CPU的個數 或者 +1
    ret_l = []
    for i in range(20):
       ret = p.apply_async(func = wahaha) # async  異步的
       ret_l.append(ret)
    for ret in ret_l:
        print(ret.get())

View Code

2 回調函數 _ 在主進程中執行

在發起任務的時候 指定callback參數

在每個進程執行完apply_async任務之後,返回值會直接作為參數傳遞給callback的函數,執行callback函數中的代碼

等待池中的任務執行完畢

import os
import time
import random
from multiprocessing import Pool
def wahaha(num):
    time.sleep(random.random())
    print(‘pid : ‘,os.getpid(),num)
    return num

def back(arg):
    print(‘call_back : ‘,os.getpid(),arg)

if __name__ == ‘__main__‘:
    print(‘主進程‘,os.getpid())
    p = Pool(5)  # CPU的個數 或者 +1
    for i in range(20):
       ret = p.apply_async(func = wahaha,args=(i,),callback=back) # async  異步的
    p.close()
    p.join()

View Code

3 進程的總結

# 進程
# 進程三狀態
# 同步異步阻塞非阻塞
# 請解釋異步非阻塞
# 給開發完成的所有裝飾器+log
# 是計算機中最小的資源分配單位
# 進程的創建 Process
# 進程之間的異步 本身子進程主進程之間都是異步的
# 進程之間的同步控制 Lock Semaphore Event
# 進程之間的數據隔離 本身進程與進程之間都是數據隔離的
# 進程之間通信 IPC 管道 隊列
# 數據共享 Manager
# 進程池 -可以獲取返回值
# 同步調用 - 基本不用的
# 異步調用 - 重要的
# apply_async
# get獲取結果
# close
# join
# 回調函數 Pool 回調函數在主進程中執行
# apply_async(func = wahaha,callback = back)

4 線程的概念

# 進程
# 是計算機中最小的資源分配單位
# 在利用多個CPU執行的過程中,對多個程序的資源進行管理和隔離 # 進程的弊端
# 開啟和關閉 以及 切換 都會帶來很大的時間開銷
# 過多的進程還會造成操作系統調度的壓力 # 線程
# 線程是CPU調度的最小單位
# 每個進程中至少有一個線程
# 實際上執行代碼的是線程 # 線程屬於進程
# 進程負責獲取操作系統分配給我的資源
# 線程負責執行代碼 # 從代碼的角度上來看
# 多進程
# 開啟和結束 時間開銷大
# 切換的效率低
# 內存隔離
# 多線程
# 開啟和結束 時間開銷非常小
# 切換效率高
# 內存不隔離 # Cpython解釋器下的全局解釋器鎖
# 在同一個進程中的多個線程在同一時刻只能有一個線程訪問CPU
# 多線程無法形成並行
# 鎖的線程 # 什麽時候才會有到CPU
# 程序計算的時候
# IO阻塞
# 是不會用到CPU的 # Jpython解釋器就沒有全局解釋器鎖
# pypy解釋沒有全局解釋器鎖 # 4cpu
# 起四個進程
# 進程裏起線程 5threading 模塊

import os
import time
from threading import Thread

def func():
    time.sleep(1)
    print(123,os.getpid())


print(123,os.getpid())
for  i in range(10):
    # func()
    Thread(target=func).start()

View Code

40 進程池 回調函數 線程 thrrading模塊