玩轉python進程使用，知識點講解與代碼演示

1.進程與線程的區別？

1.1形象來區分

• 進程，能夠完成多任務，比如 在一臺電腦上能夠同時運行多個QQ
• 線程，能夠完成多任務，比如 一個QQ中的多個聊天窗口

1.2.原理區分

1. 進程是系統進行資源分配和調度的一個獨立單位，所謂的進程就是“運行的程序+需要的資源”
2. 線程是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源.

1.3兩者之間的關係

• 一個程序至少有一個進程,一個進程至少有一個線程.
• 線程的劃分尺度小於進程(資源比進程少)，使得多線程程序的併發性高。
• 進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，從而極大地提高了程序的運行效率
• 線線程不能夠獨立執行，必須依存在進程中

2.python中進程的實現

     python中的multiprocessing模塊就是跨平臺版本的多進程模塊，提供了一個Process類來代表一個進程對象，這個對象可以理解爲是一個獨立的進程，可以執行另外的事情

2.1python中多進程或多線程實現多任務模式

尖叫提示：如果是在window下執行多線程代碼，必須要將實際執行的代碼封裝到if __name__ == "__main__":中去執行 ，不然肯定會報錯，具體原因可以參考我的博客：https://blog.csdn.net/qq_26442553/article/details/94595715

import threading
import time
import multiprocessing

def test1():
    while True:
        print("1--------")
        time.sleep(1)

def test2():
    while True:
        print("2--------")
        time.sleep(1)
def main():
 #    t1 = threading.Thread(target=test1)
 #    t2 = threading.Thread(target=test2)
 #    t1.start()
 #    t2.start()

    p1 = multiprocessing.Process(target=test1)  #用法和多線程差不多
    p2 = multiprocessing.Process(target=test2)
    p1.start()
    p2.start()
#創建子進程時，只需要傳入一個執行函數和函數的參數，創建一個Process實例，用start()方法啓動

if __name__ == "__main__":
    main()
'''
1--------
2--------
1--------
2--------
1--------
2--------
1--------
2--------
'''

2.2Process類的常見方法介紹

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

• target：如果傳遞了函數的引用，可以任務這個子進程就執行這裏的代碼
• args：給target指定的函數傳遞的參數，以元組的方式傳遞
• kwargs：給target指定的函數傳遞命名參數
• name：給進程設定一個名字，可以不設定
• group：指定進程組，大多數情況下用不到

Process創建的實例對象的常用方法：

• start()：啓動子進程實例（創建子進程）
• is_alive()：判斷進程子進程是否還在活着
• join([timeout])：是否等待子進程執行結束，或等待多少秒
• terminate()：不管任務是否完成，立即終止子進程

 Process創建的實例對象的常用屬性：

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

import time

def test(a, b, c, *args, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

def main():
    print("----in 主進程 pid=%d---父進程pid=%d----" % (os.getpid(), os.getppid()))  #顯示進程號
    p = multiprocessing.Process(target=test, args=(11, 22, 33, 44, 55, 66, 77, 88), kwargs={"mm":11})
    p.start()

if __name__ == "__main__":
    main()
'''
----in 主進程 pid=9796---父進程pid=15924----
11
22
33
(44, 55, 66, 77, 88)
{'mm': 11}
'''

2.3進程間不共享全局變量，區別於線程

import multiprocessing
import os
import time

nums = [11, 22, 33]  #這裏是可變對象的全局變量，所以在函數中修改其值時不用global聲明

def test():
    for i in range(33,36):
        nums.append(i)
        print("在進程中1中nums=%s" % str(nums))
        time.sleep(3)

def test2():
    print("在進程中2中nums=%s" % str(nums))

def main():
    print("----in 主進程 pid=%d---父進程pid=%d----" % (os.getpid(), os.getppid()))
    p1 = multiprocessing.Process(target=test)
    p1.start()

    # time.sleep(1)
    p1.join() #保證讓p1執行完，再執行p2

    p2 = multiprocessing.Process(target=test2)
    p2.start()

if __name__ == "__main__":
    main()
'''結果顯示，p1雖然執行完了，但是p2還是修改前的值。

----in 主進程 pid=12292---父進程pid=15924----
在進程中1中nums=[11, 22, 33, 33]
在進程中1中nums=[11, 22, 33, 33, 34]
在進程中1中nums=[11, 22, 33, 33, 34, 35]
在進程中2中nums=[11, 22, 33]'''

3.進程間的通信實現

      Process之間有時需要通信,python中使用multiprocessing模塊的Queue實現多進程之間的數據傳遞，Queue本身是一個消息列隊程序。

1.初始化Queue()對象時（例如：q=Queue()），若括號中沒有指定最大可接收的消息數量，或數量爲負值，那麼就代表可接受的消息數量沒有上限（直到內存的盡頭）；

2.如果block使用默認值，且沒有設置timeout（單位秒），消息列隊如果爲空，此時程序將被阻塞（停在讀取狀態），直到從消息列隊讀到消息爲止，如果設置了timeout，則會等待timeout秒，若還沒讀取到任何消息，則拋出"Queue.Empty"異常；

3.如果block值爲False，消息列隊如果爲空，則會立刻拋出"Queue.Empty"異常；

• Queue.get_nowait()：相當Queue.get(False)；

• Queue.put(item,[block[, timeout]])：將item消息寫入隊列，block默認值爲True；

4.如果block使用默認值，且沒有設置timeout（單位秒），消息列隊如果已經沒有空間可寫入，此時程序將被阻塞（停在寫入狀態），直到從消息列隊騰出空間爲止，如果設置了timeout，則會等待timeout秒，若還沒空間，則拋出"Queue.Full"異常；

5.如果block值爲False，消息列隊如果沒有空間可寫入，則會立刻拋出"Queue.Full"異常；

• Queue.put_nowait(item)：相當Queue.put(item, False)；

from multiprocessing import Queue

q=Queue(3) #初始化一個Queue對象，裏面的數字表示最大接受消息數量
q.put("消息1") 
q.put("消息2")
#Queue.get([block[, timeout]])：獲取隊列中的一條消息，然後將其從列隊中移除，block默認值爲True；
print(q.get()) #消息1,因爲對列是先入先出。 
q.put("消息1") 
print(q.full())  # False Queue.full()：如果隊列滿了，返回True,反之False；
q.put("消息3")
print(q.full()) #True
print(q.empty()) #False Queue.empty()：如果隊列爲空，返回True，反之False ；

#因爲消息列隊已滿下面的try都會拋出異常，第一個try會等待2秒後再拋出異常，第二個Try會立刻拋出異常
try:
    q.put("消息4",True,2)
except:
    print("消息列隊已滿，現有消息數量:%s"%q.qsize())  #Queue.qsize()：返回當前隊列包含的消息數量；

try:
    q.put_nowait("消息4")
except:
    print("消息列隊已滿，現有消息數量:%s"%q.qsize())

#推薦的方式，先判斷消息列隊是否已滿，再寫入
if not q.full():
    q.put_nowait("消息4")

#讀取消息時，先判斷消息列隊是否爲空，再讀取
if not q.empty():
    for i in range(q.qsize()):
        print(q.get_nowait())
'''
消息1
False
True
消息列隊已滿，現有消息數量:3
消息列隊已滿，現有消息數量:3
消息2
消息1
消息3
'''