守護進程，進程互斥鎖，通訊，生產者消費者模型

守護進程

         1.守護進程

             守護進程其實就是一個子進程

             守護=》伴隨

             守護進程會伴隨主進程的代碼運行完畢後而死掉

 

         2.爲什麼守護進程

             關鍵字就兩個：

                進程：

                    當父進程須要將一個任務併發出去執行，須要將該任務放到一個子進程裏

                守護：

                    當該子進程內的代碼在父進程代碼運行完畢後就沒有存在的意義了，就應該將該子進程設置爲守護進程，會在父進程代碼結束後死掉

 

         3.使用

             p.daemon = True

 

互斥鎖

# 互斥所：能夠將要執行任務的部分代碼（只涉及到修改共享數據的代碼）變成串行

# join：是要執行任務的全部代碼總體串行

from multiprocessing import Process, Lock
import json
import os
import time
import random


def check():
    time.sleep(1)  # 模擬網絡延遲
    with open('db.txt', 'rt', encoding='utf-8') as f:
        dic = json.load(f)
    print('%s 查看到剩餘票數[%s]' % (os.getpid(), dic['count']))


def get():
    with open('db.txt', 'rt', encoding='utf-8') as f:
        dic = json.load(f)
    time.sleep(2)
    if dic['count'] > 0:
        dic['count'] -= 1
        time.sleep(random.randint(1,3))
        with open('db.txt', 'wt', encoding='utf-8') as f:
            json.dump(dic, f)
        print('%s 購票成功' % os.getpid())
    else:
        print('%s 沒有餘票' % os.getpid())


def task(mutex):
    check()

    mutex.acquire()  # 互斥所不能連續的acquire，必須是release之後才能從新acquire
    get()
    mutex.release()

    # with mutex:  # 與上述效果相同
    #     get()


if __name__ == '__main__':
    mutex = Lock()
    for i in range(10):
        p = Process(target=task, args=(mutex,))
        p.start()

View Code

IPC：

進程間的通訊，有兩種實現方式

1.pipe

2.queue：pipe + 鎖

  

  

from multiprocessing import Queue

 

q = Queue(3) # 先進先出

 注意：

1.隊列佔用的是內存空間

2.不該該往隊列中放大數據，應該只存放數據量較小的消息

掌握的

q.put([1])

print(q.get())

 

瞭解的

q.put('first',block=True,timeout=3)

print(q.get(block=True,timeout=3))

q.put(4,block=False,) # 隊列滿了直接拋出異常，不會阻塞

q.put_nowait('first') #q.put('first',block=False,)

 

 

1.什麼是生產者消費者模型

    生產者：比喻的是程序中負責產生數據的任務

    消費者：比喻的是程序中負責處理數據的任務

 

    生產者 --》共享的介質（隊列）《-- 消費者

 

2.爲什麼用

    實現了生產者與消費者的解耦和，生產者能夠不停地生產，消費者也能夠不停地消費

    從而平衡了生產者的生產能力與消費者的消費能力，提高了程序總體運行的效率

 

    何時用？

        當咱們的進程中存在明顯的兩類任務，一類負責產生數據，另一類負責處理數據

        當時就應該考慮使用生產者消費者模型來提高程序的效率

from multiprocessing import JoinableQueue, Process
import time
import random


def producer(name, food, q):
    for i in range(3):
        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))
        q.task_done()


if __name__ == '__main__':
    q = JoinableQueue()
    # 生產者們
    p1 = Process(target=producer,args=('egon','包子',q))
    p2 = Process(target=producer, args=('楊軍', '泔水', q,))
    p3 = Process(target=producer, args=('猴老師', '翔', q,))
    # 消費者們
    c1 = Process(target=consumer, args=('Alex', q,))
    c2 = Process(target=consumer, args=('wupeiqidsb', q,))
    c1.daemon = True
    c2.daemon = True

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()

    q.join() # 等待隊列被取乾淨
    # q.join() 結束意味着
    # 主進程的代碼運行完畢--->(生產者運行完畢)+隊列中的數據也被取乾淨了->消費者沒有存在的意義