多進程，守護進程，鎖

一：多進程

import os
import time
from multiprocessing import Process
def func(args,args2):
    print(args,args2)#打印參數
    time.sleep(3)
    print('子進程 :', os.getpid())  #查看子進程進程號
    print('子進程的父進程 :', os.getppid())#查看子進程的父進程，多了一個p
    print(12345)

if __name__ == '__main__':
    p = Process(target=func,args=('參數','參數2'))   # 註冊
    # p是一個進程對象,尚未啓動進程
    p.start()       # 開啓了一個子進程
    print('*'*10)
    print('父進程 :',os.getpid()) # 查看當前進程的進程號
    print('父進程的父進程 :',os.getppid()) # 查看當前進程的父進程

# 進程的生命週期
    # 主進程
    # 子進程
    # 開啓了子進程的主進程 :
        # 主進程本身的代碼若是長,等待本身的代碼執行結束,
        # 子進程的執行時間長,主進程會在主進程代碼執行完畢以後等待子進程執行完畢以後 主進程才結束

打印結果： 先打印主進程，而後打印子進程。主進程結束執行子進程。

**********
父進程 : 3832
父進程的父進程 : 2556
參數 參數2
子進程 : 5416
子進程的父進程 : 3832
12345

 

二：多進程的中的幾個方法（多進程便可指子進程，父進程這兩個進程，也可指多個實例化兩個進程）

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('====== : 運行完了')

這樣就是正常打印，主進程執行完畢執行子進程

hahahaha
====== : 運行完了
**********
********************

 

若是加上join以後，是感知一個子進程的結束,將異步的程序改成同步。也就是等待子進程結束後主進程關閉

打印結果：

hahahaha
**********
********************
====== : 運行完了

若是子進程是一個while循環的死循環，那麼主進程就一直不會關閉。

import os
import time
from multiprocessing import Process

def func():
    while True:
        print('子進程開始')
        time.sleep(1)
        print('***我還在運行')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True
    p.start()
    p.join()
    print('程序結束')

打印結果：

子進程開始
***我還在運行
子進程開始
***我還在運行

老是在子進程這裏循環

 

小總結：

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爲子進程的名稱

 

進程常見關鍵字

1 p.start()：啓動進程，並調用該子進程中的p.run() 
2 p.run():進程啓動時運行的方法，正是它去調用target指定的函數，咱們自定義類的類中必定要實現該方法  
3 p.terminate():強制終止進程p，不會進行任何清理操做，若是p建立了子進程，該子進程就成了殭屍進程，
使用該方法須要特別當心這種狀況。若是p還保存了一個鎖那麼也將不會被釋放，進而致使死鎖
4 p.is_alive():若是p仍然運行，返回True
5 p.join([timeout]):主線程等待p終止（強調：是主線程處於等的狀態，而p是處於運行的狀態）。
timeout是可選的超時時間，須要強調的是，p.join只能join住start開啓的進程，而不能join住run開啓的進程

 

開啓多個子進程

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,i))
        p_lst.append(p)
        p.start()
    for p in p_lst:p.join()   # 以前的全部進程必須在這裏都執行完才能執行下面的代碼
    print([i for i in os.walk(r'F:\python10期\day37\day37')])

# 同步 0.1 * 500  = 50
# 異步 500 0.1    = 0.1
# 多進程寫文件
# 首先往文件夾中寫文件
# 向用戶展現寫入文件以後文件夾中全部的文件名

解析：他會在全部進程結束以後才能完成下面的print。

 

開啓多個子進程的第二種方式：

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方法中是在子進程中執行的代碼

這種方式須要第必定義一個類，讓他繼承process,第二種是傳參，須要初始化，而後是定義一個run方法，由於定義run方法以後才能執行start，而後在實例化二個對象。分別執行。

打印結果：

6356
MyProcess-1
1
2
3136
MyProcess-2
3
4

由於此進程是異步，因此process1和process2不肯定誰最早打印，隨機。super是執行process全部方法。