多任務_進程

進程以及狀態

1.進程
程序：例如xxx.py這是程序，是一個靜態的

進程：一個程序運行起來後，代碼+用到的資源 稱之爲進程，它是操作系統分配資源的基本單元。

不僅可以通過線程完成多任務，進程也是可以的

2.進程的狀態
工作中，任務數往往大於cpu的核數，即一定有一些任務正在執行，而另外一些任務在等待cpu進行執行，因此導致了有了不同的狀態

就緒態：運行的條件都已經慢去，正在等在cpu執行
執行態：cpu正在執行其功能
等待態：等待某些條件滿足，例如一個程序sleep了，此時就處於等待態

進程的創建-multiprocessing

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

2個while循環一起執行

#-*- coding:utf-8 -*-
from multiprocessing import Process
import time


def run_proc():
    """子進程要執行的代碼"""
    while True:
        print("----2----")
        time.sleep(1)


if __name__=='__main__':
    p = Process(target=run_proc)
    p.start()
    while True:
        print("----1----")
        time.sleep(1)

說明
創建子進程時，只需要傳入一個執行函數和函數的參數，創建一個Process實例，用start()方法啓動

進程pid

#-*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time

def run_proc():
    """子進程要執行的代碼"""
    print('子進程運行中，pid=%d...' % os.getpid())  # os.getpid獲取當前進程的進程號
    print('子進程將要結束...')

if __name__ == '__main__':
    print('父進程pid: %d' % os.getpid())  # os.getpid獲取當前進程的進程號
    p = Process(target=run_proc)
    p.start()

Process語法結構如下：

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（進程號）

給子進程指定的函數傳遞參數

#-*- coding:utf-8 -*-
from multiprocessing import Process
import os
from time import sleep


def run_proc(name, age, **kwargs):
    for i in range(10):
        print('子進程運行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
        print(kwargs)
        sleep(0.2)

if __name__=='__main__':
    p = Process(target=run_proc, args=('test',18), kwargs={"m":20})
    p.start()
    sleep(1)  # 1秒中之後，立即結束子進程
    p.terminate()
    p.join()

運行結果:

子進程運行中，name= test,age=18 ,pid=45097...
{'m': 20}
子進程運行中，name= test,age=18 ,pid=45097...
{'m': 20}
子進程運行中，name= test,age=18 ,pid=45097...
{'m': 20}
子進程運行中，name= test,age=18 ,pid=45097...
{'m': 20}
子進程運行中，name= test,age=18 ,pid=45097...
{'m': 20}

進程間不同享全局變量

#-*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time

nums = [11, 22]

def work1():
    """子進程要執行的代碼"""
    print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    for i in range(3):
        nums.append(i)
        time.sleep(1)
        print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))

def work2():
    """子進程要執行的代碼"""
    print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))

if __name__ == '__main__':
    p1 = Process(target=work1)
    p1.start()
    p1.join()

    p2 = Process(target=work2)
    p2.start()

運行結果:

in process1 pid=11349 ,nums=[11, 22]
in process1 pid=11349 ,nums=[11, 22, 0]
in process1 pid=11349 ,nums=[11, 22, 0, 1]
in process1 pid=11349 ,nums=[11, 22, 0, 1, 2]
in process2 pid=11350 ,nums=[11, 22]

進程和線程的對比

定義的不同

進程是系統進行資源分配和調度的一個獨立單位.

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

區別

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

進程間通信-Queue

Process之間有時需要通信，操作系統提供了很多機制來實現進程間的通信。

Queue的使用

可以使用multiprocessing模塊的Queue實現多進程之間的數據傳遞，Queue本身是一個消息列隊程序，首先用一個小實例來演示一下Queue的工作原理：

#coding=utf-8
from multiprocessing import Queue
q=Queue(3) #初始化一個Queue對象，最多可接收三條put消息
q.put("消息1") 
q.put("消息2")
print(q.full())  #False
q.put("消息3")
print(q.full()) #True

#因爲消息列隊已滿下面的try都會拋出異常，第一個try會等待2秒後再拋出異常，第二個Try會立刻拋出異常
try:
    q.put("消息4",True,2)
except:
    print("消息列隊已滿，現有消息數量:%s"%q.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())

運行結果:

False
True
消息列隊已滿，現有消息數量:3
消息列隊已滿，現有消息數量:3
消息1
消息2
消息3

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

Queue.qsize()：返回當前隊列包含的消息數量；

Queue.empty()：如果隊列爲空，返回True，反之False ；

Queue.full()：如果隊列滿了，返回True,反之False；

Queue.get([block[, timeout]])：獲取隊列中的一條消息，然後將其從列隊中移除，block默認值爲True；

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

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

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

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

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

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

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

Queue實例

我們以Queue爲例，在父進程中創建兩個子進程，一個往Queue裏寫數據，一個從Queue裏讀數據：

from multiprocessing import Process, Queue
import os, time, random

#寫數據進程執行的代碼:
def write(q):
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

#讀數據進程執行的代碼:
def read(q):
    while True:
        if not q.empty():
            value = q.get(True)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break

if __name__=='__main__':
    # 父進程創建Queue，並傳給各個子進程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 啓動子進程pw，寫入:
    pw.start()    
    # 等待pw結束:
    pw.join()
    # 啓動子進程pr，讀取:
    pr.start()
    pr.join()
    # pr進程裏是死循環，無法等待其結束，只能強行終止:
    print('')
    print('所有數據都寫入並且讀完')

運行結果：