主程序和子程序

執行結果：

一旦程序建立後，程序就由作業系統排程

程式碼解析：

子程序與父程序

所以主程序的父程序就是pycharm

args傳參

一個引數

兩個引數

join作用（建立多個執行緒）：

不一定哪個程序先執行，10個程序的執行順序不固定

程式碼延伸：
 

from multiprocessing import Process
import time
import os
def func(filename,content):
   with open(filename,'w') as f:
       f.write(content*10*'*')
if __name__ =='__main__':
    p_list=[]
    for i in range(10):
        p = Process(target=func, args=('info%s'%i,i))
        p_list.append(p)
        p.start()
        # p.join() 如果加有這句，就會變為同步
    [p.join() for p in p_list]  # 之前的所有程序必須在這裡執行完畢才能執行下面的程式碼
    # p0.join()
    # p1.join()
    # p2.join()#即使p2執行緒已經結束，可以執行此程式碼，若p0.p1還沒有結束，則需要等到他們結束才能執行此程式碼
    # p3.join()



    print([i for i in os.walk(r'E:\pythoncode\網路程式設計\day6-併發程式設計')])

# 同步 0.1*500 = 50
# 非同步 500 0.1  =0.1
# 多程序寫檔案
# 首先往檔案中寫檔案
# 向用戶展示寫入檔案之後資料夾中所有的檔名
 

開啟多個程序（寫檔案）：

from multiprocessing import Process
import time
import os
def func(filename,content):
   with open(filename,'w') as f:
       f.write(content*10*'*')
if __name__ =='__main__':
    p_list=[]
    for i in range(10):
        p = Process(target=func, args=('info%s'%i,i))
        p_list.append(p)
        p.start()
        # p.join() 如果加有這句，就會變為同步
    [p.join() for p in p_list]  # 之前的所有程序必須在這裡執行完畢才能執行下面的程式碼
    print([i for i in os.walk(r'E:\pythoncode\網路程式設計\day6-併發程式設計')])

# 同步 0.1*500 = 50
# 非同步 500 0.1  =0.1
# 多程序寫檔案
# 首先往檔案中寫檔案
# 向用戶展示寫入檔案之後資料夾中所有的檔名
 

執行結果：

開啟多個執行緒的第二種方式：

from multiprocessing import Process
import os
# 第一種方式
# p=Process(target=,args)
# p.start()
#第二種
# 自定義類 繼承Process類
# 必須實現一個run方法，run方法是在子程序中執行的程式碼

class MyProcess(Process):
    def __init__(self,arg1,arg2):
        super().__init__()   #繼承
        self.arg1=arg1
        self.arg2=arg2
    def run(self):
        print(self.pid)
        print(self.name)
        print(self.arg1)
        print(self.arg2)
        print(os.getpid())
    def start(self):
        self.run()
if __name__ =='__main__':
    print('主程序pid：',os.getpid())
    p1=MyProcess(1,2)
    p1.start()
    p2=MyProcess(3,4)
    p2.start()
 

執行結果：

多程序之間的資料隔離

# 程序與程序之間
from multiprocessing import Process
import os
def func():
    global n  # 宣告一個全部變數
    n=0        # 重新定義一個n
    print('pid:%s'%os.getpid(),n)
if __name__ =='__main__':
    n=100
    p=Process(target=func)
    p.start()
    p.join()
    print('主程序：',os.getpid(),n)

執行結果：

對這個資料隔離不太懂

守護程序

#守護程序
#子程序--》守護程序

from multiprocessing import Process
import time
def func():
    while True:
        time.sleep(0.5)
        print('我還活著')

def func2():
    print(' func2 start')
    time.sleep(8)
    print('func2 finished')

if __name__=='__main__':
    p=Process(target=func)
    p.daemon=True
    p.start()
    p2 = Process(target=func2)
    p2.start()
    p2.terminate()  #結束一個子程序
    print(p2.is_alive())
    time.sleep(2)
    print(p2.is_alive())
    i=0
    while i<4:
        print('socketserver')
        time.sleep(1)
        i+=1

# 守護程序會隨著 主程序的程式碼 執行完畢 而 結束

執行結果：

鎖機制

from multiprocessing import Process,Lock
import json
import time
def show(i):
    with open('ticket') as f:
        dic=json.load(f)
        print('第%s個人還有%s張票'%(i,dic['ticket']))

def buy_ticket(lock,i):
    lock.acquire()
    with open('ticket') as f:
        dic = json.load(f)
        time.sleep(0.1)
    if dic['ticket']>0:
        dic['ticket'] -= 1
        print('\033[32m第%s個人買到票了\033[0m' % i)
    else:
        print('\033[31m第%s個人沒有買到票了\033[0m' % i)
    with open('ticket','w') as f:
        json.dump(dic,f)
    lock.release()


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

執行結果：

錯誤案例：

from multiprocessing import Process
def func():
    num=input('>>>')
    print(num)

if __name__ =='__main__':
    Process(target=func).start()

# 發生錯誤是因為現在這個控制檯是主程序的控制檯，而輸入操作是子執行緒開啟的，所以在主控制檯不可以輸入，所以報錯