from multiprocessing import Process

def run(args):
    print(args)

if __name__==‘__main__‘:
    p1=Process(target=run,args=(‘hah‘,))
    p2 = Process(target=run, args=(‘helloh‘,))
    p3 = Process(target=run, args=(‘ego‘,))  必須加逗號

    p1.start()
    p2.start()
    p3.start()

class Myoprocess(Process):繼承進程類屬性
 
    def __init__(self,name):
        super().__init__()  繼承初始的屬性方法
        self.name=name
    def run(self):
        print(self.name)
if __name__==‘__main__‘:
    p1=Myoprocess(‘EGON‘)

    p1.start()自動調用run函數
經典類是一種沒有繼承的類，實例類型都是type類型，如果經典類被作為父類，子類調用父類的構造函數時會返回
join 是優先執行子進程，執行完畢在執行主進程，幾個子進程同時用join先並發這幾個再執行主進程
 
process_list=[p1,p2,p3,p4]
for i in process_list:
i.start()
i.join()


is_alive  terminate 關閉進程

3 p.terminate():強制終止進程p，不會立即關閉 馬上查看存活狀態可能還是存活不會進行任何清理操作，如果p創建了子進程，該子進程就成了僵屍進程，使用該方法需要特別小心這種情況。
如果p還保存了一個鎖那麽也將不會被釋放，進而導致死鎖

守護進程
p1.daemon=True  一定在start前設置
父進程結束子進程也就結束


互斥鎖、Lock

import  json,time
def search(i):
    time.sleep(1)
 
    print(‘%s等待購票‘ % i)
    return 
def buy(i):
    with open(‘piao.txt‘,‘rb‘)as f:
        dict1=f.read()
    dict1=json.loads(dict1.decode(‘utf-8‘))
    if dict1[‘yupiao‘]>=1:
        dict1[‘yupiao‘]-=1
        with open(‘piao.txt‘, ‘wb‘)as f:
            f.write(json.dumps(dict1).encode(‘utf-8‘))
            print(‘%s購票成功,余票%s‘%(i,dict1[‘yupiao‘]))
    else:
        print(‘余票不足‘)


def task(i,lock):
    search(i)
    lock.acquire()
    buy(i)
    lock.release()
if __name__==‘__main__‘:
    for i in range(1,100):
       lock=Lock()
       p1=Process(target=task,args=(i,lock))
       p1.start()

死鎖原因

def task1(l1,l2,i):
    l1.acquire()
    print("盤子被%s搶走了" % i)
    time.sleep(1)


    l2.acquire()
    print("筷子被%s搶走了" % i)
    print("吃飯..")
    l1.release()
    l2.release()


    pass

def task2(l1,l2,i):

    l2.acquire()
    print("筷子被%s搶走了" % i)

    l1.acquire()
    print("盤子被%s搶走了" % i)

    print("吃飯..")
    l1.release()
    l2.release()


if __name__ == ‘__main__‘:
    l1 = Lock()
    l2 = Lock()
    Process(target=task1,args=(l1,l2,1)).start()
    Process(target=task2,args=(l1,l2,2)).start()
這個是沒有釋放，然後被另一個堵住，另一個需要這個進程來釋放，     也有可能一個鎖兩次用

q=Queue(3)
q.put(‘sb周周‘)
q.put(‘sb總則‘)
q.put(‘sb總‘)
q.put(‘sb則‘,False)加False後滿了報異常  取不出來報異常，不加的話滿了或者空了會阻塞
print(q.get())

生產者消費者模型
用隊列實現緩沖，生產者扔給隊列，滿了阻塞，消費者處理空了等待

def eat(q,name):
    while True: 循環關閉不了進程所以給一個標誌值，發現後break，然後用串行join和守護進程來關閉，或者直接return（low）
        time.sleep(random.randint(1,3))
        res=q.get()
        if res==None:
            return 
        else:
          print(‘%s吃了第%s‘%(name,res))
     
def make(q,name,food):
    for i in range(6):
       time.sleep(random.randint(1, 3))
       res=(i,"個",food)
       q.put(res)
       print(‘%s做了第%s個%s‘%(name,i,food))
    q.put(None)

if __name__==‘__main__‘:
    q=Queue()
    p1=Process(target=make,args=(q,‘egon‘,‘熱狗‘))
    p1.daemon = True
    p1.start()

    p2 = Process(target=make, args=(q, ‘alex‘, ‘面包‘))
    p2.daemon = True
    p2.start()

    m2 = Process(target=eat, args=(q, ‘思聰‘,))

    m2.start()
    p1.join()
    p2.join()
    m2.join()
    print(‘zhu‘)

有內置的實現

def eat(q,name):
    while True:
        time.sleep(random.randint(1,3))
        res=q.get()
        print(‘%s吃了第%s‘ % (name, res))
        q.task_done()
告訴生產者拿完了

def make(q,name,food):
    for i in range(6):
       time.sleep(random.randint(1, 3))
       res=(i,"個",food)
       q.put(res)
       print(‘%s做了第%s個%s‘%(name,i,food))
    q.join()  等消費者拿完了自己結束











if __name__==‘__main__‘:
    q=JoinableQueue()
    p1=Process(target=make,args=(q,‘egon‘,‘熱狗‘))
    p1.start()

    p2 = Process(target=make, args=(q, ‘alex‘, ‘面包‘))
    p2.start()

    m2 = Process(target=eat, args=(q, ‘思聰‘,))
    m2.daemon=True 生產者等消費者拿完，結束消費者等生產者結束，主線程結束，自己結束
    m2.start()
    p1.join()
    p2.join()
    print(‘zhu‘)

進程開啟，join,進程幾個方法，互斥鎖,隊列，生產者消費者模型