1.程序q

  程序呢就相當於一個房子，執行緒就相當於是房子裡面在工作的人，那麼一個房子的空間對於房子裡面的人來說是共享的，

現在是多程序，也就是說有許多房子，很顯然這個房子的空間只屬於這個房子，不會屬於其他房子，那你應該明白我想說什麼了，（一個程序裡面資源是共享的，不同程序之間是相當於不同的程式，你QQ的訊息微信能度的到嘛？很顯然嘛，肯定是不能的，但是啊條件就來了，我擦我現在程式開了多程序，想讓兩個程序之間的資料互動怎麼辦？）

　　解決這一問題的關鍵就要看你怎麼理解程序這個概念了，現在別人qq發給你的東西你要在微信上發出去，怎麼辦，當然是先存到手機裡面啊，然後在發出啊，對了。那麼我們的程序queue就是這麼一個過程，先把資料序列化存下來，然後在使用。相當於拷貝了一份

from multiprocessing import Queue, Process
import os

def f(qq):
    qq.get()
    qq.put(6)


if __name__ == '__main__':
    q = Queue()
    q.put(1)
    q.put(2)
    p = Process(target=f, args=(q,))
    p.start()
    p.join()
    print(q.qsize())

2.執行緒不能給程序傳q，所以執行緒queue的東西其他程序不能使用

3.程序q當作變數傳入，其實不是傳入，而是克隆進去了。其實是兩個q只不過序列化了，因為程序通訊不能在記憶體裡面操作，實際上是兩個q不是一個共享q，要注意中間狀態

*******************************************pipe********

pipe 相當於是一個管道在使用他之前我們需要把管道的頭和尾打通，也就是生成兩個物件，然後把一個物件當作引數傳到程序裡面就可以了

from multiprocessing import Process,Pipe
import os
def f(liu):
    print('
 
wocao pid:',os.getpid())
    liu.send('wocao',)

if __name__ == '__main__':
    print('start ')
    Parent_coon, child_coon = Pipe()
    p = Process(target=f,args=(child_coon,))
    p.start()
    cc = Parent_coon.recv()
    p.join()
    print(cc)

4.manage資料共享 pipe

with Manager() as manger:
    d = manger.dict()
    l = manger.list()

那麼manage呢就是簡化了的特定的用來在程序之間互動的一個東西，他可以支援列表字典元組變數等等。

如上我們就生成了一個程序互動的字典與列表，使用他需要把他當作引數傳入進去即可

# _*_coding:utf-8_*_
# /usr/bin/env python3
# Author：book Miki

# 程序之間資料互動用一箇中間狀態的queue，也就是經程序queue


from multiprocessing import Queue, Process, Manager  # 匯入一個程序queue
import threading
import queue
import os

def f(d,l):
    d['name'] = 'liu'
    d[1] = 3
    l.append(os.getpid())
    print(l)

if __name__ == '__main__':
    with Manager() as manger:
        d = manger.dict()
        l = manger.list()
        process_list = []
        for i in range(10):
            P = Process(target=f, args=(d, l))
            P.start()
            process_list.append(P)
        for i in process_list:
            i.join()

        print(d)
        print(l)

5. 程序鎖 程序為什麼需要鎖呢？ 因為啊 所有程序都在共享同一快螢幕，所以需要鎖，我們在main裡面生成鎖的例項，當作引數傳進去

同一份pipe程式碼我們加上鎖之後就變成了

from multiprocessing import Process,Pipe, Lock
import os
def f(l,liu):
    l.acquire()
    print('wocao pid:',os.getpid())
    liu.send('wocao',)
    l.release()
if __name__ == '__main__':
    print('start ')
    lock = Lock()
    Parent_coon, child_coon = Pipe()
    p = Process(target=f, args=(lock, child_coon))
    p.start()
    cc = Parent_coon.recv()
    p.join()
    print(cc)

程序池的概念就是說同一時間允許多少個程序在執行
在window上啟動多程序就必須使用

if __name__ == '__main__':
並且pool要在其裡面
pool 裡面沒有開啟開程序的語句，只有apply 序列 apply_async並行這兩個， 後者多了一個回撥也就是 callback 有了回撥，開程序的那個函式的返回值，將會作為引數傳入回撥的函式裡面

# _*_coding:utf-8_*_
# /usr/bin/env python3
# Author：book Miki


from multiprocessing import Process,Pool,freeze_support
import time
import os

def f(i):
    time.sleep(2)
    print('this process pid is :', os.getpid())
    return i+100


def bag(ar):
    print('-->exec done: ', ar, os.getpid())


if __name__ == '__main__':
    # freeze_support()
    print(os.getpid())
    pool = Pool(5)

    for i in range(10):
        pool.apply_async(func=f,args=(i,), callback=bag)


    print('end')
    pool.close()
    pool.join()

序列的直接開就可以了，沒有回撥哦。回撥的程序的pid號是主函式的pid號。也就是說回撥函式是在主函式裡面執行的哦。