一、程序間通訊

        程序間通訊(IPC,InterProcess Communication)是指在不同程序之間傳播或交換資訊。

        由於每個程序的空間是互相獨立的，程序之間無法互相直接獲取彼此的資源，故引入程序間通訊來實現程序間的資源互動。

        程序間通訊方法：管道、訊息佇列、共享記憶體、訊號、訊號量、套接字。

        補充：檔案型別（檢視方法：ls -l 或 ll）
                b（塊裝置檔案）
                c（字元裝置檔案）
                d（資料夾）   
                - （普通檔案）
                l （連結檔案）    link
                s  套接字檔案
                p  管道檔案

二、管道通訊   Pipe

        在記憶體中開闢一段空間，形成管道結構，管道對多個程序可見，程序可以對管道進行讀寫操作，實現多程序之間的通訊。

        from multiprocess import Pipe  # 匯入庫

1、Pipe函式

        fd1,fd2 = Pipe(duplex = True)
        功能：建立一個管道
        引數：預設為雙向管道
                    如果設定為False，則為單向管道
        返回值：返回兩個管道流物件，表示管道的兩端
                      如果雙向管道，fd1 fd2都可以進行讀寫操作
                      如果是單向管道，則fd1只可讀，fd2只可寫

        fd.recv()
        功能：從管道讀取內容（接收訊息）
        引數：無
        返回值：讀到的內容（接收訊息）
                說明：如果管道無內容則阻塞

2、示例

from multiprocessing import Process,Pipe 
import os,time 

#如果引數為False則fd1只能recv  fd2只能send
# fd1,fd2 = Pipe(False)

#建立一個雙向管道
fd1,fd2 = Pipe()
# fd1.close()

def fun(name):
    time.sleep(3)
    #發字串到管道
    fd2.send("hello " + str(name))
    print(os.getppid(),"----",os.getpid())

jobs = []
for i in range(5):
    p = Process(target = fun,args = (i,))
    jobs.append(p)
    p.start() 

#接收子程序傳送的訊息
for i in range(5):
    data = fd1.recv()
    print(data) 

for i in jobs:
    i.join()

 

三、訊息佇列 Queue

        佇列存取規則： 先進先出

        在記憶體中開闢佇列結構空間，多個程序可以向佇列投放訊息，在取出的時候按照存入順序取出；任何擁有佇列的程序都可以存取訊息

1、Queue函式

        建立佇列
        q = Queue(maxsize = 0)
        功能 ： 建立佇列
        引數 ： maxsize  預設為0，表示根據系統分配空間儲存訊息
                                   如果傳入一個正整數，表示最多存放多少條訊息
        返回 ： 訊息佇列物件

        q.put(data, [block, timeout])
        功能： 存放訊息
        引數： data        存入的訊息 （python資料型別）
                   block       預設為True表示當佇列滿的時候阻塞
                                   設定為False則表示非阻塞
                   timeout   當block為True表示超時時間

        data = q.get([block, timeout])
        功能 ： 取出訊息
        引數 ： block     預設為True 當佇列空時阻塞
                                  設定為False表示非阻塞
                    timeout  當block為True時表示超時時間
        返回值 ： 返回獲取的訊息

        q.full()   判斷佇列是否為滿
        q.empty()  判斷佇列是否為空
        q.qsize()  判斷當前佇列有多少訊息
        q.close()  關閉佇列

2、示例

        a、函式

from  multiprocessing import Queue 
from time import sleep
#建立佇列
q = Queue(3) 

q.put(1)
print(q.full())
q.put(2)
q.put(3)
print(q.full())

# 設定超時事件為3sec
# q.put(4,True,3)

print(q.get())
print("佇列中還有%d條訊息"%q.qsize())
print(q.empty())
q.close() #關閉佇列

        b、管道收發

from multiprocessing import Process,Queue 
import time 

#建立訊息佇列
q = Queue()

def fun1():
    time.sleep(1)
    q.put("我是程序1")

def fun2():
    time.sleep(2)
    print("取訊息:",q.get())

p1 = Process(target = fun1)
p2 = Process(target = fun2)
p1.start()
p2.start()

p1.join()
p2.join()

四、共享記憶體

        在記憶體中開闢一段空間，儲存資料，對多個程序可見。每次寫入共享記憶體中的資料會覆蓋之前的內容。由於對記憶體格式化較少，所以存取速度快。

        from multiprocessing import Value,Array

1、函式

        obj = Value(ctype,obj)
        功能：開闢共享記憶體空間
        引數：ctype   字串  要轉變的c的資料型別（對照ctype表）
                    obj   共享記憶體的初始化資料
        返回：返回一個共享記憶體物件
                補充：obj.value  表示共享記憶體中的值。對其修改或者使用即可

        obj = Array(ctype,obj)
        功能： 開闢共享記憶體
        引數： ctype    要轉化的c的型別
                   obj        列表，表示要存入的資料，要求列表中數型別一致
                                正整數，表示開闢一個多大的序列空間
        返回值：返回一個共享記憶體物件
                補充：正常運算元值，讀取和賦值

2、資料型別（ctype對照表）

3、示例

        a、共享記憶體 —— value

from multiprocessing import Value,Process 
import time 
import random 

#向共享記憶體存錢
def deposite(money):
    for i in range(100):
        time.sleep(0.03)
        money.value += random.randint(1,200)
#從共享記憶體取錢
def withdraw(money):
    for i in range(100):
        time.sleep(0.02)
        money.value -= random.randint(1,150)

#建立共享記憶體物件
money = Value('i',2000)

d = Process(target = deposite,args = (money,))
w = Process(target = withdraw,args = (money,))
d.start()
w.start()
d.join()
w.join()

#檢視共享記憶體資料
print(money.value)

        b、共享記憶體 —— array

from multiprocessing import Array,Process 
import time 

def fun(shm):
    for i in shm:
        print(i)
    shm[2] = 1000

#開闢共享記憶體空間,可容納6個整數
#初始值是[1,2,3,4,5,6]
# shm = Array('i',[1,2,3,4,5,6])
#表示在共享記憶體中開闢一個包含6個整形的空間
shm = Array('i',6)

p = Process(target = fun,args = (shm,))
p.start()
p.join()
for i in shm:
    print(i)

八、附錄：目錄