python多進程基礎詳解

更新時間：2021年10月09日 14:44:23 作者：七層漢堡王

這篇文章主要介紹了Python多進程基礎,結合實例形式分析了Python多進程原理、開啟使用進程、進程隊列、進程池等相關概念與使用方法,需要的朋友可以參考下

進程

什么是進程
進程指的是一個程序的運行過程,或者說一個正在執(zhí)行的程序
所以說進程一種虛擬的概念,該虛擬概念起源操作系統(tǒng)

一個CPU 同一時刻只能執(zhí)行一件事

開啟一個進程

from  multiprocessing import Process
import time
def task(name):
    print('%s is running'%name)
    time.sleep(3)
    print('%s is done'%name)
# 開啟子進程的操作必須放到
# if __name__ == '__main__'的子代碼中
# 子進程不會再次加載
if __name__ == '__main__':
    p=Process(target=task,args=('小王',))
    # p=Process(target=task,kwargs={'name':'小王'})
    # print(p)
    p.start()
    # 主進程只是向操作系統(tǒng)發(fā)送了一個開啟子進程的信號
    # p.start()
    # 1.操作系統(tǒng)先申請內存空間
    # 2.把主進程的數據拷貝到子進程里面
    # 3.調用cup才能運行里面的代碼
    # 創(chuàng)造進程的開銷大
    print('主')

在這里插入圖片描述

JOIN方法

當前進程jion別的進程。當前進程就會等到別的進程執(zhí)行完畢了才會繼續(xù)開始往下執(zhí)行

在這里插入圖片描述

from multiprocessing import Process
import time

def task(name, n):
    print('%s is running' % name)
    time.sleep(n)
    print('%s is done' % name)

if __name__ == '__main__':
    start = time.time()
    p_l = []
    for i in range(1, 4):
        p = Process(target=task, args=('小王%s' % i, i))
        p_l.append(p)
        p.start()
    # 主進程等待子進程
    for p in p_l:
        p.join()
    print('主', (time.time() - start))

進程之間空間隔離

from multiprocessing import  Process
# 這個n是主進程里面的值
n = 100
def task():
    global n
    # 改的是子進程里面的全局變量
    # 主進程里面沒有改
    n = 0
if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    p.join()
    print(n)

在這里插入圖片描述

進程的常用方法

current_process 查看pid(進程id)

# 1. 進程pid:每一個進程在操作系統(tǒng)內都有一個唯一的id號,稱之為pid
from multiprocessing import Process, current_process
import time

def task():
    print('%s is running' % current_process().pid)
    time.sleep(3)
    print('%s is done' % current_process().pid)

# 開啟子進程的操作必須放到
# if __name__ == '__main__'的子代碼中
# 子進程不會再次加載
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    print('主', current_process().pid)

在這里插入圖片描述

os.getpid() 查看進程id

# os模塊也可以
from multiprocessing import Process, current_process
import time, os

def task():
    print('%s is running 爹是%s' % (os.getpid(), os.getppid()))
    time.sleep(3)
    print('%s is done爹是%s' % (os.getpid(), os.getppid()))

# 開啟子進程的操作必須放到
# if __name__ == '__main__'的子代碼中
# 子進程不會再次加載
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    # 誰把主進程創(chuàng)造出來的
    #   用pycharm就是pycharm創(chuàng)造的
    print('主%s爹是%s' % (os.getpid(), os.getppid()))

在這里插入圖片描述

進程其他方法和屬性

from multiprocessing import Process,current_process
import time,os
def task():
    print('%s is running 爹是%s'%(os.getpid(),os.getppid()))
    time.sleep(30)
    print('%s is done爹是%s'%(os.getpid(),os.getppid()))
# 開啟子進程的操作必須放到
# if __name__ == '__main__'的子代碼中
# 子進程不會再次加載
if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    # 誰把主進程創(chuàng)造出來的
    # 用pycharm就是pycharm創(chuàng)造的
    # 進程的名字
    print(p.name)
    # 殺死子進程
    p.terminate()
    # 需要時間
    time.sleep(0.1)
    #  判斷子進程是否存活
    print(p.is_alive())
    print('主%s爹是%s'%(os.getpid(),os.getppid()))

在這里插入圖片描述

守護進程

本質就是一個"子進程",該"子進程"的生命周期<=被守護進程的生命周期
當被守護的進程執(zhí)行完了。它也會被殺死

# 主進程運行完了，子進程沒有存在的意義
# 皇帝和太監(jiān)不是同生，但是是同死
from  multiprocessing import Process
import time
def task(name):
    print('%s活著'%name)
    time.sleep(3)
    print('%s正常死亡'%name)
if __name__ == '__main__':
    p1=Process(target=task,args=('老太監(jiān)',))
    # 聲明子進程為守護進程
    p1.daemon = True
    p1.start()
    time.sleep(1)
    print('皇帝正在死亡')

在這里插入圖片描述

互斥鎖

進程之間內存空間互相隔離，怎樣實現共享數據
進程之間內存數據不共享,但是共享同一套文件系統(tǒng),所以訪問同一個文件,是沒有問題的,
而共享帶來的是競爭，競爭帶來的結果就是錯亂，如何控制，就是加鎖處理

'''
搶票
    查票
    購票
互斥鎖：
    在程序中進行加鎖處理
    必須要釋放鎖下一個鎖才能獲取，所以程序在合適的時候必須要有釋放鎖
所以用文件來處理共享數據
    1.速度慢
    2.必須有互斥鎖
'''
import json
import time,random
from multiprocessing import Process,Lock
# 查票
def search(name):
    with open('db.json','rt',encoding='utf-8')as f:
        dic = json.load(f)
    # 模擬查票時間
    time.sleep(1)
    print('%s 查看到余票為 %s'%(name,dic['count']))
# 購票
# 第二個get子進程不會是第一個get子進程修改后count的結果
# 加互斥鎖，把這一部分并發(fā)變成串行，
# 但是犧牲了效率，保證了數據安全
def get(name):
    with open('db.json','rt',encoding='utf-8')as f:
        dic = json.load(f)
    if dic['count']>0:
        dic['count']-=1
        time.sleep(random.randint(1,3))
        with open('db.json', 'wt', encoding='utf-8')as f:
            json.dump(dic,f)
            print('%s 購票成功'%name)
    else:
        print('%s 查看到沒有票了'%name)
def task(name,mutex):
    # 并發(fā)
    search(name)
    # 串行
    # 加互斥鎖
    mutex.acquire()
    get(name)
    # 釋放互斥鎖
    mutex.release()
# if __name__ == '__main__':
#     for i in range(10):
#         p=Process(target=task,args=('路人%s'%i,))
#         p.start()
#         #  join只能將進程的任務整體變成串行
#         # 互斥鎖可以局部串行
#         p.join()
#         # 數據安全，是指讀的時候無所謂，寫的（改的）時候必須安全
#         # 寫的時候是串行，讀的時候并發(fā)
# 加鎖
if __name__ == '__main__':
    # 主進程加鎖
    mutex=Lock()
    for i in range(10):
        # 鎖傳入子進程
        p=Process(target=task,args=('路人%s'%i,mutex))
        p.start()
        #  join只能將進程的任務整體變成串行
        # 互斥鎖可以局部串行
        # p.join()
        # 數據安全，是指讀的時候無所謂，寫的（改的）時候必須安全
        # 寫的時候是串行，讀的時候并發(fā)

db.json 中只有10張票。如果沒有加鎖。則可能會出現票唄多賣的情況

進程間通信(IPC機制)

'''
速度快
鎖問題解決
ipc機制
    進程彼此之間互相隔離，要實現進程間通信（IPC），
    multiprocessing模塊支持兩種形式：隊列和管道，這兩種方式都是使用消息傳遞的
    共享內存空間
    隊列=管道+鎖
'''
from  multiprocessing import Queue
# 占用的內存，最好小數據，消息數據，下載地址
# Queue(限制隊列里面的個數)
# 先進先出
q=Queue(3)
# 添加
q.put('a')
q.put('b')
q.put({'x':2})
print('籃子滿了')
# 隊列滿了，相當于鎖了
# q.put({'x':2})
# 提取
print(q.get())
print(q.get())
print(q.get())
# # 隊列為空，等待加入，也會阻塞，相當于鎖了
print('隊列為空')
print(q.get())

隊列被取完了后面的q.get() 會阻塞直到有新的元素。所以程序不會結束

在這里插入圖片描述

JoinableQueue 來實現生產消費者

JoinableQueue#task_done()方法當隊列里面沒有元素會結束線程

'''
小王和小周每人生產10分包子和土豆絲
小戴和小楊一直吃，當隊列里面沒有食物時。終結進程
'''
import time, random
from multiprocessing import Process, JoinableQueue

def producer(name, food, q):
    for i in range(10):
        res = '%s%s' % (food, i)
        # 模擬生產數據的時間
        time.sleep(random.randint(1, 3))
        q.put(res)
        print('廚師%s生成了%s' % (name, res))

def consumer(name, q):
    while True:
        # 訂單都沒了還在等，隊列里面空了
        res = q.get()
        # 模擬處理數據的時間
        time.sleep(random.randint(1, 3))
        print('吃貨%s吃了%s' % (name, res))
        # 1每次完成隊列取一次，往q.join() ，取干凈了q.join()運行完
        q.task_done()

# 多個生產者和消費者
if __name__ == '__main__':
    q = JoinableQueue()
    # 生產者
    p1 = Process(target=producer, args=('小王', '包子', q))
    p3 = Process(target=producer, args=('小周', '土豆絲', q))
    # 消費者
    c1 = Process(target=consumer, args=('小戴', q))
    c2 = Process(target=consumer, args=('小楊', q))
    # #3.守護進程的作用: 主進程死了，消費者子進程也跟著死
    #     #把消費者變成守護進程
    c1.daemon = True
    c2.daemon = True
    p1.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()
    p3.join()
    # 2消費者task_done給q.join()發(fā)信號
    q.join()
    print('主')
    # 生產者運行完？1,2
    # 消費者運行完？1,2

當隊列為空時，不會傻傻等待而是結束進程

在這里插入圖片描述

總結

本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注腳本之家的更多內容！

您可能感興趣的文章:

python定時復制遠程文件夾中所有文件
這篇文章主要為大家詳細介紹了python定時復制遠程文件夾中所有文件，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2019-04-04
Python機器學習之底層實現KNN
今天給大家?guī)淼氖顷P于Python機器學習的相關知識,文章圍繞著Python底層實現KNN展開,文中有非常詳細的解釋及代碼示例,需要的朋友可以參考下
2021-06-06
numpy多級排序lexsort函數的使用
本文主要介紹了numpy多級排序lexsort函數的使用，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2023-03-03
Python入門教程(二十)Python的Lambda表達式
這篇文章主要介紹了Python入門教程(二十)Python的Lambda表達式,lambda表達式是一行的函數。它們在其他語言中也被稱為匿名函數,lambda表達式非常有用，可以讓代碼簡單，簡潔,需要的朋友可以參考下
2023-04-04
Python列表reverse()函數使用方法詳解
這篇文章主要詳細介紹了Python列表reverse()函數使用方法，文章通過代碼示例講解的非常詳細，對我們的學習或工作有一定的幫助,需要的朋友可以參考下
2023-07-07
對python多線程中互斥鎖Threading.Lock的簡單應用詳解
今天小編就為大家分享一篇對python多線程中互斥鎖Threading.Lock的簡單應用詳解，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2019-01-01
Python OpenCV實現圖像模板匹配詳解
提供一個模板圖像，一個目標圖像，且滿足模板圖像是目標圖像的一部分，從目標圖像中尋找特定的模板圖像的過程，即為模板匹配。本文將詳細講解如何利用Python OpenCV實現圖像模板匹配，需要的可以參考一下
2022-04-04
ansible動態(tài)Inventory主機清單配置遇到的坑
這篇文章主要介紹了ansible動態(tài)Inventory主機清單配置遇到的坑,需要的朋友可以參考下
2020-01-01
使用Pyhton集合set()實現成果查漏的例子
今天小編就為大家分享一篇使用Pyhton集合set()實現成果查漏的例子，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2019-11-11
Linux環(huán)境下安裝python3
這篇文章介紹了Linux環(huán)境下安裝python3的方法，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2022-07-07