程序（二）：程序開啟方式與多程序
目錄
multiprocess模組
之前我們已經瞭解了很多程序相關的理論知識，瞭解程序是什麼應該不再困難了，剛剛我們已經瞭解了，執行中的程式就是一個程序。所有的程序都是通過它的父程序來建立的。因此，執行起來的python程式也是一個程序，那麼我們也可以在程式中再建立程序。多個程序可以實現併發效果，也就是說，當我們的程式中存在多個程序的時候，在某些時候，就會讓程式的執行速度變快。以我們之前所學的知識，並不能實現建立程序這個功能，所以我們就需要藉助python中強大的模組。
multiprocess.process模組
process模組介紹
Process([group [, target [, name [, args [, kwargs]]]]])，由該類例項化得到的物件，表示一個子程序中的任務（尚未啟動）
強調：
1. 需要使用關鍵字的方式來指定引數
2. args指定的為傳給target函式的位置引數，是一個元組形式，必須有逗號
引數介紹：
1 group引數未使用，值始終為None
2 target表示呼叫物件，即子程序要執行的任務
3 args表示呼叫物件的位置引數元組，args=(1,2,'egon',)
4 kwargs表示呼叫物件的字典,kwargs={'name':'egon','age':18}
5 name為子程序的名稱
方法介紹：
p.start()：啟動程序，並呼叫該子程序中的p.run()
p.run():程序啟動時執行的方法，正是它去呼叫target指定的函式，我們自定義類的類中一定要實現該方法
p.terminate():強制終止程序p，不會進行任何清理操作，如果p建立了子程序，該子程序就成了殭屍程序，使用該方法需要特別小心這種情況。如果p還儲存了一個鎖那麼也將不會被釋放，進而導致死鎖
p.is_alive():如果p仍然執行，返回True
p.join([timeout]):主執行緒等待p終止（強調：是主執行緒處於等的狀態，而p是處於執行的狀態）。timeout是可選的超時時間，需要強調的是，p.join只能join住start開啟的程序，而不能join住run開啟的程序
屬性介紹：
p.daemon：預設值為False，如果設為True，代表p為後臺執行的守護程序，當p的父程序終止時，p也隨之終止，並且設定為True後，p不能建立自己的新程序，必須在p.start()之前設定
p.name:程序的名稱
p.pid：程序的pid
p.exitcode:程序在執行時為None、如果為–N，表示被訊號N結束(瞭解即可)
p.authkey:程序的身份驗證鍵,預設是由os.urandom()隨機生成的32字元的字串。這個鍵的用途是為涉及網路連線的底層程序間通訊提供安全性，這類連線只有在具有相同的身份驗證鍵時才能成功（瞭解即可）
在windows中使用process模組的注意事項：
在Windows作業系統中由於沒有fork(linux作業系統中建立程序的機制)，在建立子程序的時候會自動 import 啟動它的這個檔案，而在 import 的時候又執行了整個檔案。因此如果將process()直接寫在檔案中就會無限遞迴建立子程序報錯。所以必須把建立子程序的部分使用if __name__ ==‘__main__’ 判斷保護起來，import 的時候 ，就不會遞迴運行了。
使用process模組建立程序
在一個python程序中開啟子程序，start方法和併發效果。
#在python中啟動的第一個子程序
import time
from multiprocessing import Process
def f(name):
print('hello', name)
print('我是子程序')
if __name__ == '__main__':
p = Process(target=f, args=('bob',))
p.start()
time.sleep(1)
print('執行主程序的內容了')
# join()
import time
from multiprocessing import Process
def func(arg1,arg2):
print('*'*arg1)
time.sleep(5)
print('*'*arg2)
if __name__ == '__main__':
p = Process(target=func,args=(10,20))
p.start()
print('hahahaha')
p.join() # 是感知一個子程序的結束,將非同步的程式改為同步
print('====== : 執行完了')#檢視主程序和子程序的程序號
import os
from multiprocessing import Process
def f(x):
print('子程序id ：',os.getpid(),'父程序id ：',os.getppid())
return x*x
if __name__ == '__main__':
print('主程序id ：', os.getpid())
p_lst = []
for i in range(5):
p = Process(target=f, args=(i,))
p.start()
進階-多程序
多個程序同時執行（注意，子程序的執行順序不是根據啟動順序決定的）
#多個程序同時執行
import time
from multiprocessing import Process
def f(name):
print('hello', name)
time.sleep(1)
if __name__ == '__main__':
p_lst = []
for i in range(5):
p = Process(target=f, args=('bob',))
p.start()
p_lst.append(p)
#join()
import os
import time
from multiprocessing import Process
def func(filename,content):
with open(filename,'w') as f:
f.write(content*10*'*')
if __name__ == '__main__':
p_lst = []
for i in range(10):
p = Process(target=func,args=('info%s'%i,0))
p_lst.append(p)
p.start()
for p in p_lst:p.join() # 之前的所有程序必須在這裡都執行完才能執行下面的程式碼
print([i for i in os.walk(r'E:\python10\day37')])
利用類開啟程序
除了上面這些開啟程序的方法，還有一種以繼承Process類的形式開啟程序的方式
import os
from multiprocessing import Process
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)
if __name__ == '__main__':
p1 = MyProcess(1,2)
p1.start()
p2 = MyProcess(3,4)
p2.start()
# 自定義類 繼承Process類
# 必須實現一個run方法,run方法中是在子程序中執行的程式碼程序之間的資料隔離問題
import os
from multiprocessing import Process
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)
結果----》
pid : 8964 0
5908 100守護程序
會隨著主程序的結束而結束。
主程序建立守護程序
其一：守護程序會在主程序程式碼執行結束後就終止
其二：守護程序內無法再開啟子程序,否則丟擲異常：AssertionError: daemonic processes are not allowed to have children
注意：程序之間是互相獨立的，主程序程式碼執行結束，守護程序隨即終止
# 子程序 -- > 守護程序
import time
from multiprocessing import Process
def func():
while True:
time.sleep(0.2)
print('我還活著')
def func2():
print('in func2 start')
time.sleep(8)
print('in func2 finished')
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True # 設定子程序為守護程序
p.start()
p2 = Process(target=func2)
p2.start()
p2.terminate() # 結束一個子程序
time.sleep(1)
print(p2.is_alive()) # 檢驗一個程序是否還活著
print(p2.name)
# i = 0
# while i<5:
# print('我是socket server')
# time.sleep(1)
# i+=1
# 守護程序 會 隨著 主程序的程式碼執行完畢 而 結束
# 在主程序內結束一個子程序 p.terminate()
# 結束一個程序不是在執行方法之後立即生效,需要一個作業系統響應的過程
# 檢驗一個程序是否活著的狀態 p.is_alive()
# p.name p.pid 這個程序的名字和程序號socket聊天併發例項
#使用多程序實現socket聊天併發-server
from socket import *
from multiprocessing import Process
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)
def talk(conn,client_addr):
while True:
try:
msg=conn.recv(1024)
if not msg:break
conn.send(msg.upper())
except Exception:
break
if __name__ == '__main__': #windows下start程序一定要寫到這下面
while True:
conn,client_addr=server.accept()
p=Process(target=talk,args=(conn,client_addr))
p.start()
#client端
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))
while True:
msg=input('>>: ').strip()
if not msg:continue
client.send(msg.encode('utf-8'))
msg=client.recv(1024)
print(msg.decode('utf-8'))
多程序中的其他方法
#程序物件的其他方法:terminate,is_alive
from multiprocessing import Process
import time
import random
class Myprocess(Process):
def __init__(self,person):
self.name=person
super().__init__()
def run(self):
print('%s正在和網紅臉聊天' %self.name)
time.sleep(random.randrange(1,5))
print('%s還在和網紅臉聊天' %self.name)
p1=Myprocess('張三')
p1.start()
p1.terminate()#關閉程序,不會立即關閉,所以is_alive立刻檢視的結果可能還是存活
print(p1.is_alive()) #結果為True
print('開始')
print(p1.is_alive()) #結果為False
#程序物件的其他屬性:pid和name
class Myprocess(Process):
def __init__(self,person):
self.name=person # name屬性是Process中的屬性，標示程序的名字
super().__init__() # 執行父類的初始化方法會覆蓋name屬性
#self.name = person # 在這裡設定就可以修改程序名字了
#self.person = person #如果不想覆蓋程序名，就修改屬性名稱就可以了
def run(self):
print('%s正在和網紅臉聊天' %self.name)
# print('%s正在和網紅臉聊天' %self.person)
time.sleep(random.randrange(1,5))
print('%s正在和網紅臉聊天' %self.name)
# print('%s正在和網紅臉聊天' %self.person)
p1=Myprocess('張三')
p1.start()
print(p1.pid) #可以檢視子程序的程序id