進程、線程、協程

時間 2019-12-01

標籤進程線程简体版

原文原文鏈接

進程與線程

進程與線程的關係

進程：
優勢：同時利用多個cpu，可以同時進行多個操做
缺點：耗費資源（從新開闢內存空間）

線程：
優勢：共享內存，IO操做的時候，創造併發操做
缺點：搶佔資源

進程不是越多越好，cpu個數 = 進程個數

線程也不是越多越好，具體案例具體分析，請求上下文切換耗時

計算機中執行任務的最小單元：線程

IO操做利用cpu

GIL 全局解釋鎖

IO密集型（不用cpu）：
多線程

計算密集型（用cpu）：
多進程

進程和線程的目的：提升執行效率
1，截止目前寫的程序：單進程單線程，主進程、主線程
2，自定義線程：
　　　　主進程
　　　　子進程html

線程

建立線程python

import time
import threading

def f0():
    pass
def f1(a1,a2):
    time.sleep(10)
    f0()

t = threading.Thread(target=f1,args=(123,111,))
t.setDaemon(True)  #默認是False表示等待，True後就表示不等待
t.start()
t = threading.Thread(target=f1,args=(123,111,))
t.setDaemon(True)
t.start()
t = threading.Thread(target=f1,args=(123,111,))
t.setDaemon(True)
t.start()

#t.setDaemon(True)  表示不等待
#t.setDaemon(False)  表示等待

threading模塊

threading 模塊經過對 thread 進行二次封裝，提供了更方便的 api 來處理線程。程序員

import threading
import time

def worker(num):
    time.sleep(1)
    print("Thread %d" % num)
    return

for i in range(20):
    t = threading.Thread(target=worker, args=(i,), name="t.%d" % i)  #括號內部的：函數名，參數，線程起名
    t.start()

thread方法
1）t.start() : 激活線程，api

2）t.getName() : 獲取線程的名稱安全

3）t.setName() ：設置線程的名稱多線程

4）t.name : 獲取或設置線程的名稱併發

5）t.is_alive() ：判斷線程是否爲激活狀態app

6）t.isAlive() ：判斷線程是否爲激活狀態async

7）t.setDaemon()：設置爲後臺線程或前臺線程（默認：False）;經過一個布爾值設置線程是否爲守護線程，必須在執行start()方法以後纔可使用。
若是是後臺線程，主線程執行過程當中，後臺線程也在進行，主線程執行完畢後，後臺線程不論成功與否，均中止；
若是是前臺線程，主線程執行過程當中，前臺線程也在進行，主線程執行完畢後，等待前臺線程也執行完成後，程序中止ide

8）t.isDaemon() ：判斷是否爲守護線程

9）t.ident ：獲取線程的標識符。線程標識符是一個非零整數，只有在調用了start()方法以後該屬性纔有效，不然它只返回None。

10）t.join()：等待執行逐個執行每一個線程，執行完畢後繼續往下執行，該方法使得多線程變得無心義

11）t.run()：線程被cpu調度後自動執行線程對象的run方法

線程鎖

線程鎖 threading.RLock

import threading
import time

globals_num = 0

lock = threading.RLock()

def Func():
    lock.acquire()  #得到鎖
    global globals_num  #聲明全局變量
    globals_num += 1
    time.sleep(1)
    print(globals_num)
    lock.release()  #釋放鎖

for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

threading.RLock和threading.Lock 的區別

threading.Lock

import threading
lock = threading.Lock()    #Lock對象
lock.acquire()
lock.acquire()  #產生了死瑣。
lock.release()
lock.release()

threading.RLock

import threading
rLock = threading.RLock()  #RLock對象
rLock.acquire()
rLock.acquire()    #在同一線程內，程序不會堵塞。
rLock.release()
rLock.release()
# 使用RLock，那麼acquire和release必須成對出現，
# 即調用了n次acquire，必須調用n次的release才能真正釋放所佔用的瑣。
# threading.Lock與threading.RLock差異

Event模塊

threading.Event 線程間通訊的機制
Event.wait([timeout]) ：堵塞線程，直到Event對象內部標識位被設爲True或超時（若是提供了參數timeout）。
Event.set() ：將標識位設爲Ture
Event.clear() ：將標識位設爲False。
Event.isSet() ：判斷標識位是否爲Ture。

import threading

def do(event):
    print('start')
    event.wait()
    print('execute')

event_obj = threading.Event()
for i in range(10):
    t = threading.Thread(target=do, args=(event_obj,))
    t.start()

event_obj.clear()
inp = input('input:')
if inp == 'true':
    event_obj.set()

queue模塊

Queue 就是隊列，它是線程安全的

隊列的特性：先進先出

import queue

q = queue.Queue(maxsize=0)  #構造一個先進先出的隊列，maxsize指定隊列長度，爲0時，表示隊列長度無限。

q.join()  #等到隊列爲None的時候，再執行別的操做
q.qsize()  #返回隊列的大小（不可靠）
q.empty()  #當隊列爲空的時候，返回True 不然返回False(不可靠)
q.full()  #當隊列滿的時候，返回True，不然返回False（不可靠）


q.put(item, block=True, timeout=None)  #將item放入Queue尾部，item必須存在，能夠參數block默認爲True,表示當隊列滿時，會等待隊列給出可用位置
                                       #爲Flase時爲非阻塞，此時若是隊列已經滿，會引起queue.Full異常。能夠選參數timeout，表示會阻塞的時間，
                                       #若是隊列沒法給出放入item的位置，則引起queue.Full異常。
q.get(block=True, timeout=None)  #等  移除並返回隊列頭部的一個值，可選參數block默認爲True，表示獲取值的時候，若是隊列爲空，則阻塞，爲False時，不阻塞，
                                   #若此時隊列爲空，則引起 queue.Empty異常。可選參數timeout，表示會阻塞設置的時候，事後，若是隊列爲空，則引起Empty異常。
q.put_nowait(item)  #等效put(item,block=False)
q.get_nowait()  #不等   等效於 get(item,block=False)

生產者，消費者

生產者將數據依次存入隊列，消費者依次從隊列中取出數據。

實例

import queue
import threading

message = queue.Queue(10)

def producer(i):
    while True:
        message.put(i)

def consumer(i):
    while True:
        msg = message.get()
        print(msg)

for i in range(12):
    t = threading.Thread(target=producer, args=(i,))
    t.start()

for i in range(10):
    t = threading.Thread(target=consumer, args=(i,))
    t.start()

進程

建立進程

from multiprocessing import Process
import time

li = []

def foo(i):
    li.append(i)
    print('say hi ', li)

if __name__ == "__main__":
    for i in range(10):
        p = Process(target=foo, args=(i,))
        p.start()

multiprocessing模塊

multiprocessing是python的多進程管理包，和threading.Thread相似。直接從側面用subprocesses替換線程使用GIL的方式，因爲這一點，multiprocessing模塊可

以讓程序員在給定的機器上充分的利用CPU。

在multiprocessing中，經過建立Process對象生成進程，而後調用它的start()方法，

from multiprocessing import Process

def f(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))  #括號裏的兩個值，調用函數  給函數傳一個參數
    p.start()  # 激活線程
    p.join()   #至關於‘wait’等待

進程間的數據共享

進程各自持有一份數據，默認沒法共享數據

from multiprocessing import Process
from multiprocessing import Manager

import time

li = []

def foo(i):
    li.append(i)
    print('say hi',li)

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=foo,args=(i,))
        p.start()

    print('ending',li)

兩種共享方法：

方法一：Array（）

from multiprocessing import Process, Array
temp = Array('i', [11, 22, 33, 44])

def Foo(i):
    temp[i] = 100+i
    for item in temp:
        print(i, '----->', item)
if __name__ == '__main__':
    for i in range(2):
        p = Process(target=Foo, args=(i,))
        p.start()

方法二：manage.dict()

from multiprocessing import Process,Manager

def Foo(i,dic):
    dic [i] = 100+i
    print(len(dic))

if __name__ == '__main__':
    manage = Manager()
    dic = manage.dict()  #定義字典

    for i in range(2):
        p = Process(target=Foo,args=(i,dic,))
        p.start()
        p.join()
# 輸出：
# 1
# 2




#上面代碼實現進程數據共享，與上面對比。
from multiprocessing import Process,Manager

def Foo(i,dic):
    dic [i] = 100+i
    print(len(dic))

if __name__ == '__main__':
    manage = Manager()
    dic = {}  #普通的字典

    for i in range(2):
        p = Process(target=Foo,args=(i,dic,))
        p.start()
        p.join()
# 輸出：
# 1
# 1

'c': ctypes.c_char,  'u': ctypes.c_wchar,
    'b': ctypes.c_byte,  'B': ctypes.c_ubyte,
    'h': ctypes.c_short, 'H': ctypes.c_ushort,
    'i': ctypes.c_int,   'I': ctypes.c_uint,
    'l': ctypes.c_long,  'L': ctypes.c_ulong,
    'f': ctypes.c_float, 'd': ctypes.c_double

類型對應表

類型對應表

在使用併發設計的時候最好儘量的避免共享數據，尤爲是在使用多進程的時候。若是你真有須要要共享數據，

multiprocessing提供了兩種方式：

　　1)Shared memory

from multiprocessing import Process, Value, Array

def f(n, a):
    n.value = 3.1415927
    for i in range(len(a)):
        a[i] = -a[i]

if __name__ == '__main__':
    num = Value('d', 0.0)
    arr = Array('i', range(10))

    p = Process(target=f, args=(num, arr))
    p.start()
    p.join()

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

#建立num和arr時，「d」和「i」參數由Array模塊使用的typecodes建立：　

#「d」表示一個雙精度的浮點數，

#「i」表示一個有符號的整數，這些共享對象將被線程安全處理。

2)Server process

from multiprocessing import Process, Manager

def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.reverse()  #反轉

if __name__ == '__main__':
    with Manager() as manager:  #上下文管理
        d = manager.dict()
        l = manager.list(range(10))

        p = Process(target=f, args=(d, l))
        p.start()
        p.join()

        print(d)
        print(l)

進程池

Pool類描述一個工做進程池

p = Pool(5) #一次最多執行5個進程

p.apply 每個任務是排隊進行的；進程.join()

p.apply_async 每個任務都併發進行，能夠設置回調函數；進程.無join（）；進程daemon = True

1)p.apply 每個任務是排隊進行的進程，join()

from multiprocessing import Pool
import time

def f1(a):
    time.sleep(1)
    print(a)
    return 1000
def f2(arg):
    print(arg)

if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply(func=f1, args=(i,))  #apply  每個任務是排隊進行的
        print('8888')
    pool.close()
    pool.join()

2)p.apply_async 每個任務都併發進行，能夠設置回調函數; 進程.無join();進程daemon =True

from multiprocessing import Pool
import time

def f1(a):
    time.sleep(1)
    print(a)
    return 1000
def f2(arg):
    print(arg)

if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=f1, args=(i,), callback=f2)  #apply_async 每個任務都併發進行
        print('8888')
    pool.close()
    pool.join()

協程

線程和進程的操做是由程序觸發系統接口，最後的執行者是系統；協程的操做則是程序員。

協程存在的意義：對於多線程應用，CPU經過切片的方式來切換線程間的執行，線程切換時須要耗時（保存狀態，下次繼續）。協程，則只使用一個線程，在一個線程中規定某個代碼塊執行順序。

協程的適用場景：當程序中存在大量不須要CPU的操做時（IO），適用於協程

greenlet

from greenlet import greenlet
 
 
def test1():
    print 12
    gr2.switch()
    print 34
    gr2.switch()
 
 
def test2():
    print 56
    gr1.switch()
    print 78
 
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

gevent

import gevent

def foo():
    print('Running in foo')
    gevent.sleep(0)
    print('Explicit context switch to foo again')

def bar():
    print('Explicit context to bar')
    gevent.sleep(0)
    print('Impliciit context switch back to bar')

gevent.joinall([
    gevent.spawn(foo),
    gevent.spawn(bar),
])