Python基礎——多線程、多進程（0523）

1、多進程 的 共享內存——Value  和  Array

      通常的變量在進程之間是無法進行通信的，multiprocessing提供了Value和Array模塊，他們能夠在不通的進程中共同使用。

      主進程的內存空間中建立共享的內存，也就是Value和Array兩個對象。對象Value被設置成爲雙精度數(d), 並初始化爲0.0。而Array則相似於C語言中的數組，有固定的類型(i, 也就是整數)。

from multiprocessing import Process,Value,Array
def f(n, a,m):
    n.value = 3.1415927
    m = 5
    for i in range(4):
        a[i] = -a[i]    #定義數組,取反
    print(m)
if __name__ == '__main__':
    num = Value('d', 0.0)        #共享內存  雙精度
    arr = Array('i', range(4))   #共享內存  至關於數組  整形
    m = 10   #全局變量
    p = Process(target=f, args=(num, arr, m))  #定義進程
    p.start()
    p.join()

    print(num.value)
    print(arr[:])
    print(m)

運行結果：

2、Python多進程中提供了強大的 Manage 專門用於數據共享。其支持的類型很是多，包括，Value， Array，list，dict， Queue, Lock等。

from multiprocessing import Process, Manager
def func(dt, lt):
    for i in range(5):
        key = 'arg' + str(i)
        dt[key] = i * i
    lt += range(11, 16)
if __name__ == "__main__":
    manager = Manager()
    dt = manager.dict()
    lt = manager.list()
    p = Process(target=func, args=(dt, lt))
    p.start()
    p.join(timeout=3)
    print(dt)
    print(lt)

運行結果

3、進程池

Pool能夠提供指定數量的進程，供用戶調用，當有新的請求提交到pool中時，若是池尚未滿，那麼就會建立一個新的進程用來執行該請求；但若是池中的進程數已經達到規定最大值，那麼該請求就會等待，直到池中有進程結束，纔會建立新的進程。

一、進程池非阻塞  

import time
import multiprocessing

def fun(msg):
    print("#########start#### {0}".format(msg))
    time.sleep(3)
    print("#########end###### {0}".format(msg))

if __name__ == '__main__':
    print("start main")
    pool = multiprocessing.Pool(processes=3)  #定義進程池，定義最大鏈接數爲3
    for i in range(1, 7):
        msg = "hello {0}".format(i)
        pool.apply_async(fun, (msg,))  # 執行時間6s+
        # pool.apply(fun, (msg,))   6*3=18+#執行時間
    pool.close()  #在調用join以前，要先調用close，不然會報錯，close執行完不會有新的進程加入到pool
    pool.join()   #join 是等待全部的子進程結束
    print("end main")

運行結果

二、阻塞  與  非阻塞  的區別：

pool.apply_async 非阻塞，定義的進程池最大數的同時執行

pool.apply 一個進程結束，釋放回進程池，開始下一個進程

—————————————————第二部分——多線程——————————————————

1、多線程

一、Python中提供了 threading模塊  來進行多線程的操做。

二、實現多線程的兩種方式：

① 將要執行的方法做爲參數傳給Thread的構造方法 （和多進程相似）

   t = threading.Thread(target=action, args=(i,))

示例：

class MyThread(threading.Thread):
    def __init__(self, arg):
        super(MyThread, self).__init__()#注意：必定要顯式的調用父類的初始化函數。
        self.arg = arg
    def run(self):#定義每一個線程要運行的函數
        time.sleep(5)
        with open('{0}.txt'.format(self.arg), 'wb') as f:
            f.write(str(self.arg))
        print 'the arg is:%s\r' % self.arg

運行結果

②經過繼承的方式

    從Thread繼承，並重寫run() 

import threading

import time


class Hello(threading.Thread):
    def __init__(self, args):
        super(Hello, self).__init__()
        self.args = args

    def run(self):
        print("開始子進程 {0}".format(self.args))
        time.sleep(1)
        print("結束子進程 {0}".format(self.args))

if __name__ == '__main__':

    a = 1
    print("start main")
    t1 = Hello(1)
    t2 = Hello(2)
    t1.start()
    t2.start()
    print("end main")

運行結果

三、線程是應用程序中工做的最小單元。