python中進程間通信詳細介紹

"""
pipe.py 管道通信
註意
1. multiprocessing 中管道通信隻能用於有親緣關系進程中
2. 管道對象在父進程中創建,子進程通過父進程獲取
"""
from multiprocessing import Process, Pipe

# 創建 管道
fd1, fd2 = Pipe()
def app1():
    print('1 啟動應用1,請登錄')
    print('2 請求app2授權')
    fd1.send('app1 請求登錄')
    data = fd1.recv()
    print('5 ??',data)
    if data:
        print('6 登錄成功:', data)


def app2():
    print('2.5')
    # 阻塞等待讀取管道內容
    data = fd2.recv()
    print('3 app2', data)
    fd2.send(('Dave', '123'))
    print('4 app2,發送完畢')


if __name__ == '__main__':
    print(-5)
    p1 = Process(target=app1)
    print(-4)
    p2 = Process(target=app2)
    print(-3)
    p1.start()
    print(-2)
    p2.start()
    print(-1)
    p1.join()
    print(0)
    p2.join()
    print('運行結束')
"""
運行結果
(base) [root@VM-0-12-centos pipe]# python pipe.py
-5
-4
-3
-2
-1
1 啟動應用1,請登錄
2 請求app2授權
2.5
3 app2 app1 請求登錄
4 app2,發送完畢
5 ?? ('Dave', '123')
6 登錄成功: ('Dave', '123')
0
運行結束

"""

"""
quque_test.py 消息隊列演示
註意: 消息隊列符合先進先出原則
"""

# 創建消息隊列
from multiprocessing import Queue, Process
from random import randint

# 以下模擬 雙色球
# 創建消息隊列
q = Queue(5)

def handle():
    print(5)
    for i in range(6):
        q.put(randint(1, 33))
    q.put(randint(1, 16))

def request():
    print(6)
    l = [q.get() for i in range(6)]
    l.sort()
    l.append(q.get())
    print(7,l)

if __name__ == '__main__':
    print(0)
    p1 = Process(target=handle)
    print(1)
    p2 = Process(target=request)
    print(2)
    p1.start()
    print(3)
    p2.start()
    print(4)
    p1.join()
    p2.join()
    print(8)
    print('程序結束')

from multiprocessing import Value,Array

obj = Value(ctype,data)
功能: 開辟共享內存
參數: ctype 表示共享內存空間類型 'i' 'f' 'c'
	data 共享內存空間初始數據
返回值: 共享內存對象

obj.value 對象屬性的修改查看即對共享內存讀寫

obj = Array(ctype,data)
功能: 開辟共享內存
參數: ctype 表示共享內存空間類型 'i' 'f' 'c'
	data 整數表示開辟空間的大小,其數據表示開辟空間
返回值: 共享內存對象

Array共享內存讀寫:通過遍歷obj可以得到每個值,直接通過索引可以修改

* 可以使用obj.value 直接打印共享內存中的字節串

"""
value.py 開辟單一共享內存空間
註意:共享內存隻能有一個值
"""

from multiprocessing import Value,Array,Process


import time
import random
ctype = 'i'
data = 5000
# 創建共享內存
money = Value(ctype,data)

# 操作共享內存
def man():
    for i in range(30):
        time.sleep(0.1)
        money.value += random.randint(1,1000)
        print('man',money.value)

def girl():
    for i in range(30):
        time.sleep(0.1)
        money.value -= random.randint(1,800)
        print('girl', money.value)

if __name__ == '__main__':
    p1 = Process(target=man)
    p2 = Process(target=girl)
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print('程序結束',money.value)

"""
array.py 開辟單一共享內存空間
註意:共享內存隻能有一個值
"""

from multiprocessing import Array,Process


ctype = 'i'
data = [1,2,3,4]
# 創建共享內存
# shm = Array(ctype,data)

# 表示初始值 [0,0,0,0,0]
shm = Array(ctype,5)


def fun():
    for i in shm:
        print(i)
    shm[1] = 1000
if __name__ == '__main__':
    p1 = Process(target=fun)
    p1.start()
    p1.join()
    print('程序結束',shm[1])

from multiprocessing import Semaphore

sem = Semaphore(num)
功能: 創建信號量對象
參數: 信號量的初始值
返回值: 信號量對象

sem.acquire() 信號量減1 當信號量為0時阻塞
sem.release() 信號量加1
sem.get_value() 獲取信號量數量

"""
信號量.py 信號量演示
思路: 信號量數量相當於資源,執行任務必須消耗資源
"""
import os
from multiprocessing import Semaphore
from multiprocessing import Process
from time import sleep

num = 3
sem = Semaphore(num)


# 任務函數
def handle():
    sem.acquire()  # sem -1
    print("%s 開始執行任務" % os.getpid())
    sleep(3)
    print("%s 執行任務完畢" % os.getpid())
    sem.release()  # sem +1


if __name__ == '__main__':
    ths = []
    for i in range(10):
        p = Process(target=handle)
        p.start()
        ths.append(p)

    for p in ths:
        p.join()
    print('程序結束')