目錄一、多任務編程二、進程三、os.fork創建進程3.1、進程ID和退出函數四、孤兒和僵尸4.1、孤兒進程4.2、僵尸進程4.3、如何避免僵尸進程的產生五、Multiprocessing創建進程5.1、multiprocessing進程屬性六、進程池七、進程間通信(IPC)7.1、管道通信(Pipe)7.2、消息隊列7.3、共享內存7.4、信號量(信號燈集)一、多任務編程

意義：充分利用計算機的資源提高程序的運行效率

定義：通過應用程序利用計算機多個核心，達到同時執行多個任務的目的

實施方案： 多進程、多線程

并行：多個計算機核心并行的同時處理多個任務

并發：內核在多個任務間不斷切換，達到好像內核在同時處理多個任務的運行效果

進程：程序在計算機中運行一次的過程

程序：是一個可執行文件，是靜態的，占有磁盤，不占有計算機運行資源

進程：進程是一個動態的過程描述，占有CPU內存等計算機資源的，有一定的生命周期

同一個程序的不同執行過程是不同的進程，因為分配的計算機資源等均不同

父子進程 : 系統中每一個進程(除了系統初始化進程)都有唯一的父進程,可以有0個或多個子進程。父子進程關系便于進程管理。

二、進程

CPU時間片：如果一個進程在某個時間點被計算機分配了內核，我們稱為該進程在CPU時間片上。

PCB(進程控制塊)：存放進程消息的空間

進程ID(PID)：進程在操作系統中的唯一編號，由系統自動分配

進程信息包括：進程PID，進程占有的內存位置，創建時間，創建用戶. . . . . . . .

進程特征：

進程是操作系統分配計算機資源的最小單位 每一個進程都有自己單獨的虛擬內存空間 進程間的執行相互獨立，互不影響

進程的狀態

1、三態

就緒態：進程具備執行條件，等待系統分配CPU 運行態：進程占有CPU處理器，處于運行狀態 等待態：進程暫時不具備運行條件，需要阻塞等待，讓出CPU

2、五態（增加新建態和終止態）

新建態：創建一個新的進程，獲取資源的過程 終止態：進程結束釋放資源的過程

查看進程樹：pstree

查看父進程PID：ps -ajx

linux查看進程命令：ps -aux

有一列為STAT為進程的狀態

D 等待態 （不可中斷等待）（阻塞） S 等待態 （可中斷等待）（睡眠） T 等待態 （暫停狀態） R 運行態 （就緒態運行態） Z 僵尸態 + 前臺進程（能在終端顯示出現象的） < 高優先級 N 低優先級 l 有多線程的 s 會話組組長三、os.fork創建進程

pid = os.fork()　

功能：創建一個子進程

返回值：創建成功在原有的進程中返回子進程的PID，在子進程中返回0；創建失敗返回一個負數

父子進程通常會根據fork返回值的差異選擇執行不同的代碼（使用if結構）

import os from time import sleeppid = os.fork()if pid < 0: print('創建進程失敗')#子進程執行部分elif pid == 0: print('新進程創建成功')#父進程執行部分else: sleep(1) print('原來的進程')print('程序執行完畢')# 新進程創建成功# 原來的進程# 程序執行完畢 子進程會復制父進程全部代碼段(包括fork前的代碼)但是子進程僅從fork的下一句開始執行 父進程不一定先執行(進程之間相互獨立，互不影響) 父子進程各有自己的屬性特征，比如：PID號PCB內存空間 父進程fork之前開辟的空間子進程同樣擁有，但是進程之間相互獨立，互不影響．

父子進程的變量域

import os from time import sleep a = 1pid = os.fork()if pid < 0: print('創建進程失敗')elif pid == 0: print('子進程') print('a = ',a) a = 10000 print('a = ',a)else: sleep(1) print('父進程') print('parent a :',a) # a = 1# 子進程# a = 1# a = 10000# 父進程# parent a : 13.1、進程ID和退出函數

os.getpid()獲取當前進程的PID號

返回值：返回PID號

os.getppid()獲取父類進程的進程號

返回值：返回PID號

import ospid = os.fork()if pid < 0: print('Error')elif pid == 0: print('Child PID:', os.getpid()) # 26537 print('Get parent PID:', os.getppid()) # 26536else: print('Get child PID:', pid) # 26537 print('Parent PID:', os.getpid()) # 26536

os._exit(status)退出進程

參數：進程的退出狀態整數

sys.exit([status])退出進程

參數：默認為0　整數則表示退出狀態；符串則表示退出時打印內容

sys.exit([status])可以通過捕獲SystemExit異常阻止退出

import os,sys# os._exit(0) # 退出進程try: sys.exit('退出')except SystemExit as e: print('退出原因：',e) # 退出原因： 退出四、孤兒和僵尸4.1、孤兒進程

父進程先于子進程退出，此時子進程就會變成孤兒進程

孤兒進程會被系統指定的進程收養，即系統進程會成為該孤兒進程新的父進程。孤兒進程退出時該父進程會處理退出狀態

4.2、僵尸進程

子進程先與父進程退出，父進程沒有處理子進程退出狀態，此時子進程成為僵尸進程

僵尸進程已經結束，但是會滯留部分PCB信息在內存，大量的僵尸會消耗系統資源，應該盡量避免

4.3、如何避免僵尸進程的產生

父進程處理子進程退出狀態

pid, status = os.wait()

功能：在父進程中阻塞等待處理子進程的退出

返回值：pid 退出的子進程的PID號

status 子進程的退出狀態

import os, syspid = os.fork()if pid < 0: print('Error')elif pid == 0: print('Child process', os.getpid()) # Child process 27248 sys.exit(1)else: pid, status = os.wait() # 阻塞等待子進程退出 print('pid : ', pid)# pid : 27248 # 還原退出狀態 print('status:', os.WEXITSTATUS(status)) # status: 1 while True: pass

創建二級子進程

父進程創建子進程等待子進程退出 子進程創建二級子進程，然后馬上退出 二級子進程成為孤兒，處理具體事件

import osfrom time import sleepdef fun1(): sleep(3) print('第一件事情')def fun2(): sleep(4) print('第二件事情')pid = os.fork()if pid < 0: print('Create process error')elif pid == 0: # 子進程 pid0 = os.fork() # 創建二級進程 if pid0 < 0:print('創建二級進程失敗') elif pid0 == 0: # 二級子進程fun2() # 做第二件事 else: # 二級進程os._exit(0) # 二級進程退出else: os.wait() fun1() # 做第一件事# 第一件事情# 第二件事情

通過信號處理子進程退出

原理: 子進程退出時會發送信號給父進程,如果父進程忽略子進程信號, 則系統就會自動處理子進程退出。

方法: 使用signal模塊在父進程創建子進程前寫如下語句 :

import signal

signal.signal(signal.SIGCHLD,signal.SIG_IGN)

特點 : 非阻塞,不會影響父進程運行。可以處理所有子進程退出

五、Multiprocessing創建進程

步驟：

需要將要做的事情封裝成函數 multiprocessing.Process創建進程，并綁定函數 start啟動進程 join回收進程

p = multiprocessing.Process(target, [name], [args], [kwargs])

創建進程對象

參數：

target ： 要綁定的函數名 name ： 給進程起的名稱 （默認Process-1） args：元組用來給target函數傳參 kwargs :字典用來給target函數鍵值傳參

p.start()

功能： 啟動進程 自動運行terget綁定函數。此時進程被創建

p.join([timeout])

功能： 阻塞等待子進程退出，最后回收進程

參數： 超時時間

multiprocessing的注意事項：

使用multiprocessing創建進程子進程同樣復制父進程的全部內存空間，之后有自己獨立的空間，執行上互不干擾 如果不使用join回收可能會產生僵尸進程 一般父進程功能就是創建子進程回收子進程，所有事件交給子進程完成 multiprocessing創建的子進程無法使用ptint

import multiprocessing as mp from time import sleep import osa = 1def fun(): sleep(2) print('子進程事件',os.getpid()) global a a = 10000 print('a = ',a)p = mp.Process(target = fun) # 創建進程對象p.start() # 啟動進程sleep(3)print('這是父進程')p.join() # 回收進程print('parent a:',a)# 子進程事件 5434# a = 10000# 這是父進程# parent a: 1Process(target)5.1、multiprocessing進程屬性

p.name ：進程名稱

p.pid ：對應子進程的PID號

p.is_alive()：查看子進程是否在生命周期

p.daemon： 設置父子進程的退出關系

如果等于True則子進程會隨父進程的退出而結束，就不用使用 join()，必須要求在start()前設置

六、進程池

引言：如果有大量的任務需要多進程完成，而任務周期又比較短且需要頻繁創建。此時可能產生大量進程頻繁創建銷毀的情況，消耗計算機資源較大，這個時候就需要進程池技術

進程池的原理：創建一定數量的進程來處理事件,事件處理完進程不退出而是繼續處理其他事件,直到所有事件全都處理完畢統一銷毀。增加進程的重復利用,降低資源消耗。

1．創建進程池，在池內放入適當數量的進程

from multiprocessing import Pool

Pool(processes)創建進程池對象

參數：進程數量 返回 ：指定進程數量，默認根據系統自動判定

2．將事件封裝函數，放入到進程池

pool.apply_async(fun,args,kwds)將事件放入進程池執行

參數：

fun 要執行的事件函數 args 以元組為fun傳參 kwds 以字典為fun傳參

返回值 ：返回一個事件對象 通過get()屬性函數可以獲取fun的返回值

3．關閉進程池

pool.close()：關閉進程池，無法再加入事件

4．回收進程

pool.join()：回收進程池

from multiprocessing import Poolfrom time import sleep,ctimepool = Pool(4) # 創建進程池# 進程池事件def worker(msg): sleep(2) print(msg) return ctime()# 向進程池添加執行事件for i in range(4): msg = 'Hello %d'%i # r 代表func事件的一個對象 r = pool.apply_async(func=worker,args=(msg,))pool.close() # 關閉進程池pool.join() # 回收進程池# Hello 3# Hello 2# Hello 0# Hello 1七、進程間通信(IPC)

由于進程間空間獨立，資源無法共享，此時在進程間通信就需要專門的通信方法。

進程間通信方法 ： 管道 消息隊列 共享內存 信號信號量 套接字

7.1、管道通信(Pipe)

通信原理：在內存中開辟管道空間，生成管道操作對象，多個進程使用同一個管道對象進行讀寫即可實現通信　

from　multiprocessing import Pipe

fd1, fd2 = Pipe(duplex = True)

功能：創建管道 參數：默認表示雙向管道，如果為False 表示單向管道 返回值：表示管道兩端的讀寫對象；如果是雙向管道均可讀寫；如果是單向管道fd1只讀 fd2只寫

fd.recv()

功能 : 從管道獲取內容 返回值:獲取到的數據，當管道為空則阻塞

fd.send(data)

功能: 向管道寫入內容 參數: 要寫入的數據

注意：

multiprocessing中管道通信只能用于父子關系進程中 管道對象在父進程中創建，子進程通過父進程獲取

from multiprocessing import Pipe, Processfd1, fd2 = Pipe() # 創建管道，默認雙向管道def fun1(): data = fd1.recv() # 從管道獲取消息 print('管道２傳給管道１的數據', data) inpu = '跟你說句悄悄話' fd1.send(inpu)def fun2(): fd2.send('肥水不流外人天') data = fd2.recv() print('管道１傳給管道２的數據', data)p1 = Process(target=fun1)P2 = Process(target=fun2)p1.start()P2.start()p1.join()P2.join()# 管道２傳給管道１的數據 肥水不流外人天# 管道１傳給管道２的數據 跟你說句悄悄話7.2、消息隊列

從內存中開辟隊列結構空間，多個進程可以向隊列投放消息，在取出來的時候按照先進先出順序取出

q = Queue(maxsize = 0)

創建隊列對象

maxsize ：默認表示系統自動分配隊列空間；如果傳入正整數則表示最多存放多少條消息 返回值 ： 隊列對象

q.put(data,[block,timeout])

向隊列中存入消息

data：存放消息（python數據類型） block：默認為True表示當前隊列滿的時候阻塞，設置為False則表示非阻塞 timeout：當block為True表示超時時間

返回值：返回獲取的消息

q.get([block,timeout])

從隊列取出消息

參數:block 設置是否阻塞 False為非阻塞；timeout 超時檢測 返回值: 返回獲取到的內容

q.full()：判斷隊列是否為滿

q.empty()：判斷隊列是否為空

q.qsize()：判斷當前隊列有多少消息

q.close()：關閉隊列

from multiprocessing import Process, Queuefrom time import sleepfrom random import randint# 創建消息隊列q = Queue(3)# 請求進程def request(): for i in range(2): x = randint(0, 100) y = randint(0, 100) q.put((x, y))# 處理進程def handle(): while True: sleep(1) try: x, y = q.get(timeout=2) except: break else: print('%d + %d = %d' % (x, y, x + y))p1 = Process(target=request)p2 = Process(target=handle)p1.start()p2.start()p1.join()p2.join()# 12 + 61 = 73# 69 + 48 = 1177.3、共享內存

在內存中開辟一段空間，存儲數據，對多個進程可見，每次寫入共享內存中的數據會覆蓋之前的內容，效率高，速度快

from multiprocessing import Value, Array

obj = Value(ctype,obj)

功能：開辟共享內存空間

參數：

ctype：字符串，要轉變的c的數據類型，對比類型對照表

obj：共享內存的初始化數據

返回：共享內存對象

from multiprocessing import Process,Valueimport timefrom random import randint# 創建共享內存money = Value(’i’, 5000)# 修改共享內存def man(): for i in range(30): time.sleep(0.2) money.value += randint(1, 1000)def girl(): for i in range(30): time.sleep(0.15) money.value -= randint(100, 800)m = Process(target=man)g = Process(target=girl)m.start()g.start()m.join()g.join()print('一月余額:', money.value) # 獲取共享內存值# 一月余額: 4264

obj = Array(ctype,obj)

功能：開辟共享內存

參數：

ctype：要轉化的c的類型

obj：要存入共享的數據

如果是列表將列表存入共享內存，要求數據類型一致

如果是正整數表示開辟幾個數據空間

from multiprocessing import Process, Array# 創建共享內存# shm = Array(’i’,[1,2,3])# shm = Array(’i’,3) # 表示開辟三個空間的列表shm = Array(’c’,b'hello') #字節串def fun(): # 共享內存對象可迭代 for i in shm: print(i) shm[0] = b’H’p = Process(target=fun)p.start()p.join()for i in shm: # 子進程修改，父進程中也跟著修改 print(i)print(shm.value) # 打印字節串　b’Hello’7.4、信號量(信號燈集)

通信原理：給定一個數量對多個進程可見。多個進程都可以操作該數量增減,并根據數量值決定自己的行為。

from multiprocessing import Semaphoresem = Semaphore(num)

創建信號量對象

參數 : 信號量的初始值 返回值 : 信號量對象

sem.acquire()將信號量減1 當信號量為0時阻塞

sem.release()將信號量加1

sem.get_value()獲取信號量數量

from multiprocessing import Process, Semaphoresem = Semaphore(3) # 創建信號量，最多允許３個任務同時執行def rnewu(): sem.acquire() # 每執行一次減少一個信號量 print('執行任務.....執行完成') sem.release() # 執行完成后增加信號量for i in range(3): # 有３個人想要執行任務 p = Process(target=rnewu) p.start() p.join()

以上就是詳解python網絡進程的詳細內容，更多關于python網絡進程的資料請關注好吧啦網其它相關文章！