大聊Python----多線程

Python里的多線程是假的多線程，不管有多少核，同一時間只能在一個核中進行操作！利用Python的多線程，只是利用CPU上下文切換的優勢，看上去像是並發，其實只是個單線程，所以說他是假的單線程。

那么什么時候用多線程呢？

首先要知道：

　　●io操作不占用CPU

　　●計算操作占CPU，像2+5=5

Python的多線程不適合CPU密集操作型的任務，適合io密集操作型的任務，例如:SocketServer

如果現在再有CPU密集操作型的任務，那該怎么辦呢？

首先說，多進程的進程之間是獨立的，然后注意了，python的線程用的是系統的原生線程，python的進程也是用系統的原生進程，那原生進程是由操作系統維護的，說白了python只是利用C原生代碼庫的接口咵嚓起了個進程，真正的進程管理還是由操作系統來完成的，那么操作系統本身有GIL全局解釋器鎖嗎?答案是沒有的，且兩個進程之間的數據是完全獨立的，不能互相訪問，所以不需要鎖的概念，所以不存在GIL概念，所以在這種情況下，每個進程至少會有一個線程，如果現在我的操作系統是八核的，我起八個進程，然后每個進程里面都有一個線程，那么就相當於八線程了，八個線程跑在八核上，那么就相當於利用多核了，那么問題就解決了！

唯一的壞處是八個線程之間的數據是不能共享的，獨立的！利用這種方法可以折中的解決多核運算的問題！ 

先看一段簡單的多進程的程序：

import multiprocessing
import time

def run(name):
    time.sleep(2)
    print('hello', name)

if __name__ == '__main__':
    for i in range(10):
        p = multiprocessing.Process(target=run, args=('bob%s'%i,))
        p.start()
  

程序的執行結果為：

hello bob0
hello bob1
hello bob3
hello bob2
hello bob5
hello bob9
hello bob7
hello bob8
hello bob4
hello bob6

那么，如果我想取我的進程號，那該怎么取呢？

from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid()) # 父進程ID 
    print('process id:', os.getpid())  # 自己進程的ID
    print("\n\n")

def f(name):
    info('\033[31;1mfunction f\033[0m')
    print('hello', name)

if __name__ == '__main__':
    info('\033[32;1mmain process line\033[0m')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

程序執行的結果為：

main process line
module name: __main__
parent process: 5252
process id: 6576

function f
module name: __mp_main__
parent process: 6576
process id: 2232

hello bob

其實這幅圖片的意思是，每一個子進程都是由他父進程啟動的。

進程間通訊

我們說兩個進程之間的內存之間是相互獨立的，那么這兩個進程能夠進行通信嗎？說A進程向訪問B進程的數據，能訪問嗎？肯定是不可以訪問的！但是，我就是想訪問，也就是兩個獨立的內存想互相訪問，那該怎么辦呢？

有那么幾種方式，但是呢！萬變不離其宗，也即是說你必須找到一個中間件，有那么幾種中間件，那么先來看看是哪幾種

第一種Queues

使用方法跟threading里的queue差不多

from multiprocessing import Process, Queue

def f(q):
    q.put([42, None, 'hello'])

if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())  # prints "[42, None, 'hello']"
    p.join()

我們看這兩個進程，父進程的q是怎么傳給子進程的？我們來討論一下

現在我們是不是認為數據共享了，兩個進程共享了一個q，其實不是的，其實是相當於克隆了一個q，然后在父進程里創建個子進程，也就是父進程把自己的q克隆了一份交給了子進程，子進程這個時候往這個q里面放了一份數據，父進程能夠獲取到 。那么這么說就不對了，那克隆了一個q，也就是兩個q了，B往q里放了一個數據，那么與另一個q，也就是A的q也就沒關系了，噯，按說是這個樣子的，但是實際上呢，它是不是想實現個數據的共享啊，就相當於把A這個q里的數據序列化了，序列化到了一個中間的位置，而中間位置有一個翻譯，他把這個數據反序列化給A，放在了A的q里，那么也就是實現了所謂的數據共享了。

程序執行的結果為：

[42, None, 'hello']

第二種Pipes

Pipe（）函數返回一個由管道連接的連接對象，默認情況下是雙工（雙向）。 例如：

from multiprocessing import Process, Pipe

def f(conn):
    conn.send("父親，安好？")  # 兒子發
    print("son receive:",conn.recv())
    conn.close()


if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print("father receive:",parent_conn.recv())  # 父親收
    parent_conn.send("兒子，安好？")
    p.join()

程序執行后的結果為：

father receive: 父親，安好？
son receive: 兒子，安好？

Pipe（）返回的兩個連接對象代表管道的兩端。 每個連接對象都有send（）和recv（）方法（以及其他方法）。 請注意，如果兩個進程（或線程）同時嘗試讀取或寫入管道的同一端，則管道中的數據可能會損壞。 當然，同時使用管道的不同端部的過程不存在損壞的風險。

第三種Managers

Manager（）返回的管理器對象控制一個服務器進程，該進程保存Python對象並允許其他進程使用代理操作它們。

Manager（）返回的管理器將支持類型列表，dict，Namespace，Lock，RLock，Semaphore，BoundedSemaphore，Condition，Event，Barrier，Queue，Value和Array。 例如，

from multiprocessing import Process, Manager
import os

def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(os.getpid())
    print(l)

if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()  # 用專門的語法生成一個可在多個進程之間進行傳遞和共享的一個字典

        l = manager.list(range(5))  # # 用專門的語法生成一個可在多個進程之間進行傳遞和共享的一個列表，默認里有5個數據
        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()
        print(d)
        print(l)

程序執行的結果為：

[0, 1, 2, 3, 4, 2100]
[0, 1, 2, 3, 4, 2100, 7632]
[0, 1, 2, 3, 4, 2100, 7632, 5788]
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340]
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340, 5760]
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340, 5760, 7072]
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340, 5760, 7072, 7540]
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340, 5760, 7072, 7540, 3904]
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340, 5760, 7072, 7540, 3904, 7888]
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340, 5760, 7072, 7540, 3904, 7888, 7612]
{1: '1', '2': 2, 0.25: None}
[0, 1, 2, 3, 4, 2100, 7632, 5788, 6340, 5760, 7072, 7540, 3904, 7888, 7612]

進程鎖與進程池

進程鎖

進程也有一個鎖，what？進程不都獨立了嗎？不涉及同時修改同一個數據，怎么還會有鎖呢？

閑了來看看它的表現形式，幾乎和線程是一模一樣的

from multiprocessing import Process, Lock

def f(l, i):
    l.acquire()
    try:
        print('hello world', i)
    finally:
        l.release()

if __name__ == '__main__':
    lock = Lock()
    for num in range(10):
        Process(target=f, args=(lock, num)).start()

程序執行的結果為：

hello world 3
hello world 1
hello world 2
hello world 5
hello world 7
hello world 4
hello world 0
hello world 6
hello world 8
hello world 9

那這種鎖有什么作用呢？

作用其實就是防止打印在屏幕上的信息發生錯亂現象！

進程池

在上面的程序中，啟動100個進程會發現變慢了，因為起一個進程就相當克隆了一份父進程的內存數據，如果父進程占一個G的內存空間，那我起100個進程，就相當於101G了，在這種情況下，開銷是非常大的，就像起一個進程咵嚓又克隆了一個屋子，一會就把哈爾濱占滿了，所以開銷特別大，為了避免咵嚓起那么多的進程，把系統打趴下，所以這里有個進程池的限制。

進程池就是同一時間有多少進程在CPU運行。

進程池中有兩個方法：

　　▪ apply（同步執行，串行）

　　▪ apply_async（異步執行、並行）

 

from multiprocessing import Process,Pool,freeze_support
import time
import os

def Foo(i):
    time.sleep(2)
    print("in process",os.getpid())
    return i+100

def Bar(arg):
    print('-->exec done:',arg)

if __name__ == '__main__':
    freeze_support()
    pool = Pool(5)  # 允許進程池里同時放入5個進程

    for i in range(10):
        # pool.apply_async(func=Foo, args=(i,),callback=Bar)  # callback 回調
        pool.apply(func=Foo, args=(i,)) # 串行
        # pool.apply_async(func=Foo, args=(i,)) # 並行

    print('end')

    pool.close()
    pool.join()  # 進程池中進程執行完畢后再關閉，如果注釋，那么程序直接關閉。

程序的執行結果為：

in process 7824
in process 6540
in process 7724
in process 8924
in process 9108
in process 7824
in process 6540

知識點擴充：

__name__  ==  '__main__'的作用是：

手動執行關於這段代碼的程序，那么他下面的程序就會執行，如果是調用這段代碼的程序時，那么它下面的程序就不會執行