• olmultiprocessing 模組建立程序

    1.需要將要執行的事情封裝為函式
    2.使用moltiprocessing模組中Process類建立程序物件
    3.通過物件屬性設定和Process的初始化函式對程序進行設定,繫結要執行的函式
    4.啟動程序,會自動執行程序繫結的函式
    5.完成程序的回收

Process()
    功能:建立程序物件
    引數:name 程序名稱  Process-1
             target 繫結函式
             args 元組 給target函式按照位置傳參
             kwargs 字典 給target函式按照鍵值對傳參

p.start()
    功能:啟動程序
    *target函式會自動執行,此時程序真正被建立
p.join([timeout])
    功能:等待回收子程序
    引數:超時時間

    *使用multiprocessing建立子程序,同樣子程序複製父程序的全部程式碼段
    父子程序各自執行互不影響,父子程序有各自的執行空間

    *如果不使用join回收子程序則子程序退出後會成為殭屍程序

    *使用multiprocessing建立子程序往往父程序只是用來建立程序回收程序
注意:
    1.如果子程序從父程序拷貝物件,物件和網路或者檔案相關聯,那麼父子程序會使用同一套物件屬性,相互有一定的關聯性
    2.如果在子程序中單獨建立物件,則和父程序完全沒有關聯

# process1.py

from multiprocessing import Process
from time import sleep


# 帶引數的程序函式
def worker(sec, name):
    for i in range(3):
        sleep(sec)
        print("I'm %s" % name)
        print("I'm working ..      ..")
p = Process(target = worker, args = (1, 'zhuli'), name = 'shuijun')

p.start()
print('Process name:', p.name)  # 程序名稱
print('Process PID', p.pid)     # 獲取程序pid號
print('Process is alive:', p.is_alive())  # 程序alive情況
p.join()


#  結果為:
#  Process name: shuijun
#  Process PID 60903
#  Process is alive: True
#  I'm zhuli
#  I'm working ....
#  I'm  zhuli
#  I'm working ....
#  I'm zhuli
#  I'm working ....
 

Process程序物件屬性

    p.start()         啟動程序
    p.join()           回收子程序

    p.is_alive()    判斷程序的生命週期狀態,處於生命週期得到True否則返回False
    p.name          程序名稱  預設為Process-1
    p.pid              程序的PID號
    p.daemon
        預設狀態False  主程序退出不會影響子程序執行
        如果設定為True,則子程序會隨著主程序結束而結束

        *要在srtart 前設定
        *一般不和join一起使用

• 建立自定義程序類

    1.繼承Process
    2.編寫自己的__init__,同時載入父類的__init__方法
    3.重寫run方法,通過生成的物件呼叫start自動執行

# clock.py
from multiprocessing import Process
import time

class ClockProcess(Process):
    def __init__(self,value):
        self.value = value
        super().__init__()

    # 重寫run方法
    def run(self):
        for i in range(5):
            print('The time is {}'.format(time.ctime()))
            time.sleep(self.value)


# 建立自定義程序類的物件
p = ClockProcess(2)
# 自動呼叫run
p.start()
p.join()

多程序
    優點:可以使用計算機多核,進行任務的併發執行,提高執行效率
        空間獨立,資料安全
        執行不受其他程序影響,建立方便
    缺點:程序的建立和消耗的系統資源較多

程序池技術
    產生原因:如果有大量任務需要多程序完成,則可能需要頻繁的建立刪除程序,給
                     計算機帶來較多的資源消耗

    原理:建立適當的程序放入程序池,用來處理待處理事件,處理完畢之後程序不銷燬,
             仍然在程序池中等待處理其他事件.程序的複用降低了資源的消耗

    使用方法:
        1.建立程序池,在池內放入適當的程序(4-8個)
        2.將事件加入到程序池等待佇列
        3.事件不斷取程序執行事件,直到所有事件執行完畢
        4.關閉程序池,回收程序

    Pool(process)
    功能:建立程序池物件
    引數:表示程序池中有多少個程序

    pool.apply_async(func,args,kwargs)
    功能:將事件放入到程序池佇列
    引數:func      事件函式
             args       以元組形式給func傳參
             kwargs  以字典形式給func傳參
    返回值:返回一個代表程序池物件
    pool.close()
    功能:o閉程序池

    pool.join()
    功能:回收程序池

    pool.map(func,iter)
    功能:將要做的事件放入程序池
    引數:func 要執行的函式
             iter    迭代物件
    返回值: 返回事件函式的返回值列表

# pool.py
from multiprocessing import Pool
from time import sleep,ctime


def worker(msg):
    sleep(2)
    print(msg)
    return ctime()

# 建立程序池
pool = Pool(processes = 4)  # 建立4個程序池
result = []
for i in range(10):
    msg = 'hello %d' % i
    # 將事件放入程序池對列中等待執行
    r = pool.apply_async(func = worker, args = (msg,))
    result.append(r)
# 關閉程序池
pool.close()
# 回收程序池
pool.join()
for i in result:
    print(i.get())  #獲取事件函式的返回值


# hello 0
# hello 1
# hello 3
# hello 2
# hello 6
# hello 5
# hello 4
# hello 7
# hello 8
# hello 9
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:04 2018
# Thu Sep 13 20:01:04 2018