python--進程初識詳解

進程:通俗理解一個運行的程序或者軟件,進程是操做系統資源分配的基本單位

1.一、導入進程模塊
import multiprocessing

1.二、Process進程類的語法結構以下：

Process([group[, target[, name[,args[,kwargs]]]]])

group: --指定進程組，目前只能使用None
target: --執行的目標任務名
name: --進程名字
args: --以元組方式給執行任務傳參
kwargs: --以字典方式給執行任務傳參

Process建立 的實例對象的經常使用方法：

start(), 啓動子進程實例（建立子進程）
join(timeout), 是否等待子進程執行結束，或等待多少秒
terminate(), 無論任務是否完成，當即終止進程

Process建立的實例對象的經常使用屬性：

name 當前進程的別名，默認爲Process-N,N爲從1開始遞增的整數。
pid 當前進程的pid（進程號）

 

1、多進程完成多任務代碼

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 """
 4 python進程
 5 """
 6 import multiprocessing
 7 import time
 8 
 9 def run_proc():
10     """
11     子進程要執行的代碼
12     :return:
13     """
14     while True:
15         print("---2---")
16         time.sleep(1)
17 
18 if __name__ == "__main__":
19     #建立子進程
20     sub_process = multiprocessing.Process(target=run_proc)
21     #啓動子進程
22     sub_process.start()
23     while True:
24         print("----1----")
25         time.sleep(1)

代碼執行結果：

 

2、獲取進程pid

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 """
 4 獲取進程pid
 5 """
 6 
 7 import multiprocessing
 8 import time
 9 import os
10 
11 def work():
12     #查看當前進程
13     current_process = multiprocessing.current_process()
14     print("work:", current_process)
15     #獲取當前進程的編號
16     print("work進程編號:", current_process.pid, os.getpid())
17     #獲取父進程的編號
18     print("work父進程的編號：", os.getppid())
19     for i in range(10):
20         print("工做中....")
21         time.sleep(0.2)
22         #擴展，根據進程編號殺死對應的進程
23         os.kill(os.getpid(), 9)
24 
25 if __name__ == "__main__":
26     #查看當前進程
27     current_process = multiprocessing.current_process()
28     print("main:", current_process)
29     #獲取當前里程的編號
30     print("main進程的編號：", current_process.pid)
31 
32     #建立子進程
33     sub_process = multiprocessing.Process(target=work)
34     #啓動進程
35     sub_process.start()
36 
37     #主進程執行打印信息操做
38     for i in range(5):
39         print("我在主進程中執行....")
40         time.sleep(0.2)

代碼執行結果：

 

3、進程的基本狀態及狀態之間的關係

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 """
 4 給子進程指定的函數傳遞參數
 5 """
 6 
 7 import multiprocessing
 8 
 9 #定義一個用於顯示信息的方法
10 def show_info(name, age):
11     print("name:", name, "; age:", age)
12 
13 if __name__ == "__main__":
14     sub_process = multiprocessing.Process(target=show_info, args=("yusheng_liang", 20))
15     #啓動進程
16     sub_process.start()

代碼執行結果：

 

4、進程之間不共享全局變量

注意:建立子進程實際上是對主進程進行拷貝，進程之間相互獨立，訪問的全局變量不是同一個，因此進程之間不共享全局變量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
進程之間不共享全局變量
"""
import multiprocessing
import time

#定義全局變量
my_list = list()

#定義寫入數據的方法
def write_data():
    for i in range(5):
        my_list.append(i)
        time.sleep(0.2)
    print("write_data: ", my_list)

#定義讀取數據的方法
def read_data():
    print("read_data: ", my_list)

if __name__ == "__main__":
    #建立寫入數據的進程
    write_process = multiprocessing.Process(target=write_data)
    #建立讀取數據的進程
    read_process = multiprocessing.Process(target=read_data)

    write_process.start()

    #主進程等待寫入進程執行完成之後代碼，再繼續往下執行
    write_process.join()
    read_process.start()

代碼執行結果：

 

 

5、主進程會等待全部的子進程執行完成程序再退出

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 """
 4 主進程會等待全部的子進程執行完成程序再退出
 5 """
 6 import multiprocessing
 7 import time
 8 
 9 #測試子進程是否執行完成之後主進程才能退出
10 def work():
11     for i in range(7):
12         print("工做中.....")
13         time.sleep(0.2)
14 
15 if __name__ == "__main__":
16     #建立子進程
17     work_process = multiprocessing.Process(target=work)
18     work_process.start()
19 
20     #讓主進程等待1秒鐘
21     time.sleep(1)
22     print("主進程執行完成了啦！！")
23 

代碼執行結果：

 

6、銷燬子進程的代碼

 

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 """
 4 主進程會等待全部的子進程執行完成程序再退出
 5 """
 6 import multiprocessing
 7 import time
 8 
 9 #測試子進程是否執行完成之後主進程才能退出
10 def work():
11     for i in range(7):
12         print("工做中.....")
13         time.sleep(0.2)
14 
15 if __name__ == "__main__":
16     #建立子進程
17     work_process = multiprocessing.Process(target=work)
18     work_process.start()
19 
20     #讓主進程等待1秒鐘
21     time.sleep(1)
22     print("主進程執行完成了啦！！")
23 
24     #讓子進程直接銷燬，表示終止執行，主進程退出以前，把全部的子進程直接銷燬就能夠了
25     work_process.terminate()

 

代碼執行的結果：

 

6、進程池

一、當須要建立的子進程數量很少時，能夠直接利用multiprocessing中的Process動態成生多個進程，但若是是上百甚至上千個目標，手動的去建立進程的工做量巨大，此時就能夠用到multiprocessing模塊提供的Pool方法。
二、初始化Pool時，能夠指定一個最大進程數，當有新的請求提交到Pool中時，若是池尚未滿，那麼就會建立一個新的進程用來執行該請求；但若是池中的進程數已經達到指定的最大值，那麼該請求就會等待，直到池中有進程結束，纔會用以前的進程來執行新的任務。

 

實例一：進程池同步執行任務
　　進程池同步執行任務表示進程池中的進程在執行任務的時候一個執行完成另一個才能執行，若是沒有執行完會等待上一個進程執行。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 """
 4 進程池同步實例代碼
 5 """
 6 import multiprocessing
 7 import time
 8 
 9 #複製任務
10 def work():
11     print("複製中...", multiprocessing.current_process().pid)
12     time.sleep(0.5)
13 
14 if __name__ == "__main__":
15     #建立進程池
16     #3:進程池中進程的最大個數
17     pool = multiprocessing.Pool(3)
18     #模擬大批量的任務，讓進程池去執行
19     for i in range(5):
20         #循環讓進程池執行對應的work任務
21         #同步執行任務，一個任務執行完成之後另一個任務才能執行
22         pool.apply(work)

 

實例二：進程池異步執行任務
　　進程池異步執行任務表示進程池中的進程同時執行任務，進程之間不會等待

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 """
 4 進程池異步執行任務
 5 進程池會根據任務執行狀況自動建立進程，並且儘可能少建立進程，合理利用進程池中的進程完成多任務
 6 """
 7 import multiprocessing
 8 import time
 9 
10 #複製任務
11 def work():
12     print("複製中...", multiprocessing.current_process().pid)
13     # 獲取當前進程的守護狀態
14     # 提示：使用進程池建立的進程是守護主進程的狀態，默認本身經過Process建立的進程是否是守住主進程的狀態
15     # print(multiprocessing.current_process().daemon)
16     time.sleep(0.5)
17 
18 if __name__ == "__main__":
19     #建立進程池
20     pool = multiprocessing.Pool(3)
21     #模擬大批量的任務，讓進程池去執行
22     for i in range(5):
23         # 循環讓進程池執行對應的work任務
24         # 同步執行任務，一個任務執行完成之後另一個任務才能執行
25         # pool.apply(work)
26         # 異步執行，任務執行不會等待，多個任務一塊兒執行
27         pool.apply_async(work)
28     # 關閉進程池，意思告訴主進程之後不會有新的任務添加進來
29     pool.close()
30     # 主進程等待進程池執行完成之後程序再退出
31     pool.join()