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

異步的 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