python启动多个进程_Python程序中的进程操作--—--开启多进程
Python程序中的進程操作--—--開啟多進程
之前我們已經了解了很多進程相關的理論知識，了解進程是什么應該不再困難了，剛剛我們已經了解了，運行中的程序就是一個進程。所有的進程都是通過它的父進程來創建的。因此，運行起來的python程序也是一個進程，那么我們也可以在程序中再創建進程。多個進程可以實現并發效果，也就是說，當我們的程序中存在多個進程的時候，在某些時候，就會讓程序的執行速度變快。以我們之前所學的知識，并不能實現創建進程這個功能，所以我們就需要借助python中強大的模塊。
一、multiprocess模塊
仔細說來，multiprocess不是一個模塊而是python中一個操作、管理進程的包。 之所以叫multi是取自multiple的多功能的意思,在這個包中幾乎包含了和進程有關的所有子模塊。由于提供的子模塊非常多，為了方便大家歸類記憶，我將這部分大致分為四個部分：創建進程部分，進程同步部分，進程池部分，進程之間數據共享。
二、multiprocess中process模塊
process模塊是一個創建進程的模塊，借助這個模塊，就可以完成進程的創建。
Process([group [, target [, name [, args [, kwargs]]]]])，由該類實例化得到的對象，表示一個子進程中的任務(尚未啟動)
強調：
需要使用關鍵字的方式來指定參數
args指定的為傳給target函數的位置參數，是一個元組形式，必須有逗號
參數介紹：
group參數未使用，值始終為None
target表示調用對象，即子進程要執行的任務
args表示調用對象的位置參數元組，args=(1,2,'randy',)
kwargs表示調用對象的字典，kwargs={'name':'randy','age':18}
name為子進程的名稱
3.1 方法介紹
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開啟的進程
3.2 屬性介紹
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字符的字符串。這個鍵的用途是為涉及網絡連接的底層進程間通信提供安全性，這類連接只有在具有相同的身份驗證鍵時才能成功(了解即可)
3.3 在windows中使用process模塊注意事項
在Windows操作系統中由于沒有fork(linux操作系統中創建進程的機制)，在創建子進程的時候會自動 import 啟動它的這個文件，而在 import 的時候又執行了整個文件。因此如果將process()直接寫在文件中就會無限遞歸創建子進程報錯。所以必須把創建子進程的部分使用if __name__ =='__main__' 判斷保護起來，import 的時候，就不會遞歸運行了。
四、使用process模塊創建進程
在一個python進程中開啟子進程，start方法和并發效果。
4.1在python創建子進程方式一
import time
from multiprocessing import Process
def f(name):
print("進程開始")
time.sleep(1) # 子進程進入堵塞狀態，結束后，進入就緒狀態，等待拿到cpu的使用權
print("進程結束")
time.sleep(1)
"""
創建進程這個print語句會執行兩次, 原因是創建進程首先執行了當前程序的代碼，則會執行一次
接著創建進程就是復制了一份代碼，在子進程中還會在執行一次，所以就會執行打印兩次
"""
print('進程測試')
if __name__ == '__main__':
# args表示傳遞的參數
"""
創建一個進程，他會將主進程的代碼復制一份到另外的一個程序，
而當前的主程序和子程序為異步狀態，整個的程序會等待所有的主
進程和子進程運行完畢之后，才結束當前的程序
"""
p = Process(target=f, args=('bob',))
p.start()
time.sleep(1)
print('執行主進程的內容了')
進程測試
進程測試
進程開始2
進程結束2
主進程
4.2 在python中創建子進程方式二
from multiprocessing import Process
import time
class Task(Process):
def __init__(self, name):
# self.name = name # 這樣賦值添加屬性,在super()__init__時候有重新初始化了,所以要在init下面修改值
super().__init__()
self.name = name
def run(self):
print(f"子進程的名稱{self.name}")
time.sleep(0.03)
print("子進程結束")
if __name__ == '__main__':
p = Task('randy')
p.start() # 想操作系統， 發送開啟子進程的請求
print("主進程")
主進程
子進程的名稱randy
子進程結束
4.3 python中子進程和主進程的內存空間是隔離的
from multiprocessing import Process
import time
x = 10
def task():
global x
print(f"子進程修改之前{x}")
x = 100
print(f"子進程修改之后x: {x}")
if __name__ == '__main__':
p = Process(target=task)
p.start()
time.sleep(0.5)
print(f"全局x的值： {x}")
子進程修改之前10
子進程修改之后x: 100
全局x的值： 10
python中子進程和主進程的內存空間是隔離的
4.4 join方法使用
from multiprocessing import Process
import time
def task(x):
print(f"{x}進程開始")
time.sleep(3)
print(f"{x}進程結束")
"""
創建進程這個print語句會執行兩次, 原因是創建進程首先執行了當前程序的代碼，則會執行一次
接著創建進程就是復制了一份代碼，在子進程中還會在執行一次，所以就會執行打印兩次
"""
print('進程測試')
if __name__ == '__main__':
p1 = Process(target=task, args=(1, ))
p1.start()
# join會阻塞住主進程在等待子進程結束，然后在執行join下面的代碼(內部會調用wait)
p1.join()
print("主進程")
# p1 = Process(target=task, args=(1, ))
# p1.start()
# p2 = Process(target=task, args=(2, ))
# p2.start()
# p1.join()
# p2.join()
4.5 join多個進程時間統計
# 實現并行
from multiprocessing import Process
import time
def task(x):
print(f"{x}進程開始")
time.sleep(x)
print(f"{x}進程結束")
"""
創建進程這個print語句會執行兩次, 原因是創建進程首先執行了當前程序的代碼，則會執行一次
接著創建進程就是復制了一份代碼，在子進程中還會在執行一次，所以就會執行打印兩次
"""
print('進程測試')
if __name__ == '__main__':
p1 = Process(target=task, args=(1, ))
p2 = Process(target=task, args=(2, ))
p3 = Process(target=task, args=(3, ))
# 開始時間
start = time.time()
p1.start()
p2.start()
p3.start()
# join會阻塞住主進程在等待子進程結束，然后在執行join下面的代碼(內部會調用wait)
p1.join()
p2.join()
p3.join()
end = time.time()
"""
程序運行的時間為3s多，主要是因為創建的三個子進程會同時啟動
會以時間最長的進程為基準，
"""
print("程序運行時間%s" %(end-start)) # 程序運行時間3.5375335216522217
# 實現串行
from multiprocessing import Process
import time
def task(x):
print(f"{x}進程開始")
time.sleep(x)
print(f"{x}進程結束")
"""
創建進程這個print語句會執行兩次, 原因是創建進程首先執行了當前程序的代碼，則會執行一次
接著創建進程就是復制了一份代碼，在子進程中還會在執行一次，所以就會執行打印兩次
"""
print('進程測試')
if __name__ == '__main__':
p1 = Process(target=task, args=(1, ))
p2 = Process(target=task, args=(2, ))
p3 = Process(target=task, args=(3, ))
# 開始時間
start = time.time()
# 實現串行，線程會一個一個的執行線程，一個線程執行完之后才會執行下一個線程
p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
end = time.time()
"""
程序運行的時間為6s多，主要是因為創建的三個子進程會同時啟動
會以時間最長的進程為基準，
"""
print("程序運行時間%s" %(end-start)) # 程序運行時間7.236638784408569
程序運行時間3.5375335216522217
程序運行時間7.236638784408569
#詳細解析如下：
#進程只要start就會在開始運行了,所以p1-p4.start()時,系統中已經有四個并發的進程了
#而我們p1.join()是在等p1結束,沒錯p1只要不結束主線程就會一直卡在原地,這也是問題的關鍵
#join是讓主線程等,而p1-p4仍然是并發執行的,p1.join的時候,其余p2,p3,p4仍然在運行,等#p1.join結束,可能p2,p3,p4早已經結束了,這樣p2.join,p3.join.p4.join直接通過檢測，無需等待
# 所以4個join花費的總時間仍然是耗費時間最長的那個進程運行的時間
4.6 多個進程同時運行
from multiprocessing import Process
import time
def task(x):
print(f"{x}進程開始")
time.sleep(x)
print(f"{x}進程結束")
print('進程測試')
if __name__ == '__main__':
start = time.time()
p_list = []
# 創建并啟動線程
for i in range(1,5):
p = Process(target=task, args=(i, ))
p.start()
p_list.append(p)
# 使用join方法
for p in p_list:
p.join()
end = time.time()
print("程序運行時間%s" %(end-start))
4.7 查看主進程和子進程的進程號
from multiprocessing import Process,current_process
import time
import os
def task():
print("進程開始")
time.sleep(0.2)
# 在子進程查看自己的pid
print(f'在子進程中查看自己的pid: {current_process().pid}')
print(f'在子進程中查看自己的pid: {os.getpid()}')
# 在子進程中查看父進程pid
print(f'在子進程中查看父進程pid: {os.getppid()}')
print("進程結束")
if __name__ == '__main__':
p = Process(target=task)
p.start()
print(f"在主進程中查看子進程的pid：{p.pid}")
print(f'主進程的pid: {os.getpid()}')
print(f'主進程中父進程pid: {os.getppid()}')
"""
在window中的進程創建查看pid號他的順序是從小到大排序,主線程pid大于子線程的pid
os.getpid() 獲取當前進程的pid
os.getppid() 獲取當前進程的父進程
子進程對象.pid 獲取當前進程的子進程的pid
"""
進階，多個進程同時運行(注意，子進程的執行順序不是根據啟動順序決定的)
4.8 process中常用的屬性
from multiprocessing import Process,current_process
import time
import os
def task():
print("進程開始")
time.sleep(0.2)
# 在子進程查看自己的pid
print(f'在子進程中查看自己的pid: {current_process().pid}')
print("進程結束")
if __name__ == '__main__':
p = Process(target=task)
p.start()
# 1 查看進程的名稱
print(p.name)
# 2 判斷進程是否還存在
print(p.is_alive())
time.sleep(3)
print(p.is_alive())
# 3 告訴操作系統結束之后關閉所有進程
p2 = Process(target=task)
p2.start()
p2.terminate()
print("terminate: ", p2.is_alive())
p2.join()
print("terminate: ", p2.is_alive())
五、守護進程
會隨著主進程的結束而結束。
主進程創建守護進程
其一：守護進程會在主進程代碼執行結束后就終止
其二：守護進程內無法再開啟子進程,否則拋出異常：AssertionError: daemonic processes are not allowed to have children
注意：進程之間是互相獨立的，主進程代碼運行結束，守護進程隨即終止。
5.1 守護進程的啟動
import os
import time
from multiprocessing import Process
class Myprocess(Process):
def __init__(self,person):
super().__init__()
self.person = person
def run(self):
print(os.getpid(),self.name)
print('%s正在和女主播聊天' %self.person)
p=Myprocess('哪吒')
p.daemon=True # 一定要在p.start()前設置,設置p為守護進程,守護進程中禁止p創建子進程,并且父進程代碼執行結束,p即終止運行
p.start()
time.sleep(10) # 在sleep時查看進程id對應的進程ps -ef|grep id
print('主')
5.2主進程代碼執行結束守護進程立即結束
from multiprocessing import Process
def foo():
print(123)
time.sleep(1)
print("end123")
def bar():
print(456)
time.sleep(3)
print("end456")
p1=Process(target=foo)
p2=Process(target=bar)
p1.daemon=True
p1.start()
p2.start()
time.sleep(0.1)
print("main-------") # 打印該行則主進程代碼結束,則守護進程p1應該被終止.#可能會有p1任務執行的打印信息123,因為主進程打印main----時,p1也執行了,但是隨即被終止
六、socket聊天并發實例
6.1 使用多進程是新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:
# 注意在這里不能使用input進行交互信息，因為是在子進程中輸入的，所以你輸入不對
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()
6.1 使用多進程是新socket聊天并發-client端
import socket
client = socket.socket()
client.connect(("127.0.0.1", 8888))
while True:
msg = input("請輸入信息")
if msg == 'q':
break
client.send(msg.encode('utf-8'))
data = client.recv(1024)
print(data)
import socket
client = socket.socket()
client.connect(("127.0.0.1", 8888))
while True:
msg = input("請輸入信息")
if msg == 'q':
break
client.send(msg.encode('utf-8'))
data = client.recv(1024)
print(data)
總結
以上是生活随笔為你收集整理的python启动多个进程_Python程序中的进程操作--—--开启多进程的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： nodejs变量
- 下一篇： SQL盲注及python脚本编写