線程、協程（下）

時間  2019-11-11
標籤 線程 简体版
原文   原文鏈接

 

  • 隨着以前咱們學習的多線程和多進程，可是咱們知道不管是建立多進程仍是建立多線程來解決問題，都要消耗必定的時間來建立進程、建立線程、以及管理他們之間的切換。隨着咱們對於效率的追求不斷提升，基於單線程來實現併發又成爲一個新的課題，即只用一個主線程（很明顯可利用的cpu只有一個）狀況下實現併發。這樣就能夠節省建立線進程所消耗的時間。爲此咱們須要先回顧下併發的本質：切換+保存狀態，cpu正在運行一個任務，會在兩種狀況下切走去執行其餘的任務（切換由操做系統強制控制）：html

    • 一種狀況是該任務發生了阻塞
    • 一種狀況是該任務計算的時間過長

    1555746805999

    在介紹進程理論時，說起進程的三種執行狀態，而線程纔是執行單位，因此也能夠將上圖理解爲線程的三種狀態 。node

    一：其中第二種狀況並不能提高效率，只是爲了讓cpu可以雨露均沾，實現看起來全部任務都被「同時」執行的效果，若是多個任務都是純計算的，這種切換反而會下降效率。python

    　　爲此咱們能夠基於yield來驗證。yield自己（tonodo最第一版本就是yield實現）就是一種在單線程下能夠保存任務運行狀態的方法，咱們來簡單複習一下：程序員

     
     
     
    ​x
     
     
     
      
    #1 yiled能夠保存狀態，yield的狀態保存與操做系統的保存線程狀態很像，可是yield是代碼級別控制的，更輕量級
    #2 send能夠把一個函數的結果傳給另一個函數，以此實現單線程內程序之間的切換
    ​
    #串行執行
    import time
    def consumer(res):
        '''任務1:接收數據,處理數據'''
        pass
    def producer():
        '''任務2:生產數據'''
        res=[]
        for i in range(10000000):
            res.append(i)
        return res
    start=time.time()
    #串行執行
    res=producer()
    consumer(res) #寫成consumer(producer())會下降執行效率
    stop=time.time()
    print(stop-start) #1.5536692142486572
    ​
    ​
    #基於yield併發執行
    import time
    def consumer():
        '''任務1:接收數據,處理數據'''
        while True:
            x=yield
    def producer():
        '''任務2:生產數據'''
        g=consumer()
        next(g)
        for i in range(10000000):
            g.send(i)
    ​
    start=time.time()
    #基於yield保存狀態,實現兩個任務直接來回切換,即併發的效果
    #PS:若是每一個任務中都加上打印,那麼明顯地看到兩個任務的打印是你一次我一次,即併發執行的.
    producer()
    ​
    stop=time.time()
    print(stop-start) #2.0272178649902344
     

    二：第一種狀況的切換。在任務一遇到io狀況下，切到任務二去執行，這樣就能夠利用任務一阻塞的時間完成任務二的計算，效率的提高就在於此。web

     
     
      
    xxxxxxxxxx
     
     
     
      
    import time
    def consumer():
        '''任務1:接收數據,處理數據'''
        while True:
            x=yield
    ​
    def producer():
        '''任務2:生產數據'''
        g=consumer()
        next(g)
        for i in range(10000000):
            g.send(i)
            time.sleep(2)
    ​
    start=time.time()
    producer()  #併發執行,可是任務producer遇到io就會阻塞住,並不會切到該線程內的其餘任務去執行
    ​
    stop=time.time()
    print(stop-star)
    ​
    #對於單線程下，咱們不可避免程序中出現io操做，但若是咱們能在本身的程序中（即用戶程序級別，而非操做系統級別）控制單線程下的多個任務能在一個任務遇到io阻塞時就切換到另一個任務去計算，這樣就保證了該線程可以最大限度地處於就緒態，即隨時均可以被cpu執行的狀態，至關於咱們在用戶程序級別將本身的io操做最大限度地隱藏起來，從而能夠迷惑操做系統，讓其看到：該線程好像是一直在計算，io比較少，從而更多的將cpu的執行權限分配給咱們的線程。
     

  • 協程的本質就是在單線程下，由用戶本身控制一個任務遇到io阻塞了就切換另一個任務去執行，以此來提高效率。爲了實現它，咱們須要找尋一種能夠同時知足如下條件的解決方案：編程

     
     
      
    xxxxxxxxxx
     
     
     
      
    #1. 能夠控制多個任務之間的切換，切換以前將任務的狀態保存下來，以便從新運行時，能夠基於暫停的位置繼續執行。
    #2. 做爲1的補充：能夠檢測io操做，在遇到io操做的狀況下才發生切換
     

    1555747988330

    •  
       
        
      xxxxxxxxxx
       
       
       
        
      一、協程(本質是一條線程,操做系統不可見)
      二、是有程序員操做的,而不是由操做系統調度的
      三、多個協程的本質是一條線程,因此多個協程不能利用多核
      # 出現的意義 : 多個任務中的IO時間能夠共享,當執行一個任務遇到IO操做的時候,
            # 能夠將程序切換到另外一個任務中繼續執行
            # 在有限的線程中,實現任務的併發,節省了調用操做系統建立\銷燬線程的時間
            # 而且協程的切換效率比線程的切換效率要高
            # 協程執行多個任務可以讓線程少陷入阻塞,讓線程看起來很忙
            # 線程陷入阻塞的次數越少,那麼可以搶佔CPU資源就越多,你的程序效率看起來就越高
      總結：
            # 1.開銷變小了
            # 2.效率變高了
       

     

1、協程

  • 協程並非實際存在的實體，它的本質就是一個線程的多個部分，比線程的單位更小————協程、纖程，一個線程中能夠開啓多個協程，在執行程序的過程當中遇到IO操做就凍結當前位置的狀態,去執行其餘任務，在執行其餘任務過程當中會不斷的檢測上一個凍結的任務是否IO結束,若是IO結束了，就繼續從凍結的位置開始執行,
  • 協程的特色：凍結當前程序/任務的執行狀態————技能解鎖能夠規避IO操做的時間
  • 單純的切換 仍是要耗費一些時間的 記住當前執行的狀態，可是節省內存
 
 
  
xxxxxxxxxx
 
 
 
  
#凍結狀態之生成器
def func():
    print(1)
    yield 'aaa'
    print(2)
    yield 'bbb'
    print(3)
    yield 'ccc'
g = func()
next(g)  #1
​
#列表
def func():
    x = yield 1
    print(x)
    yield 2
​
g = func()
print(next(g))
print(g.send('aaa'))
​
#1
#aaa
#2
 

  • 協程：是單線程下的併發，又稱微線程，纖程。英文名Coroutine。一句話說明什麼是線程：協程是一種用戶態的輕量級線程，即協程是由用戶程序本身控制調度的。windows

    • 須要強調的是：數組

       
       
        
      xxxxxxxxxx
       
       
       
        
      #1. python的線程屬於內核級別的，即由操做系統控制調度（如單線程遇到io或執行時間過長就會被迫交出cpu執行權限，切換其餘線程運行）
      #2. 單線程內開啓協程，一旦遇到io，就會從應用程序級別（而非操做系統）控制切換，以此來提高效率（！！！非io操做的切換與效率無關）
       

    • 對比操做系統控制線程的切換，用戶在單線程內控制協程的切換：多線程

       
       
        
      xxxxxxxxxx
       
       
       
        
      優勢：
          #1. 協程的切換開銷更小，屬於程序級別的切換，操做系統徹底感知不到，於是更加輕量級
          #2. 單線程內就能夠實現併發的效果，最大限度地利用cpu
      缺點：
          #1. 協程的本質是單線程下，沒法利用多核，能夠是一個程序開啓多個進程，每一個進程內開啓多個線程，每一個線        程內開啓協程
          #2. 協程指的是單個線程，於是一旦協程出現阻塞，將會阻塞整個線程
          
      總結協程特色：
          一、必須在只有一個單線程裏實現併發
          二、修改共享數據不需加鎖
          三、用戶程序裏本身保存多個控制流的上下文棧
          四、附加：一個協程遇到IO操做自動切換到其它協程（如何實現檢測IO，yield、greenlet都沒法實現，就用到了gevent模塊（select機制））
       

       

2、greenlet模塊

  • 簡介：併發

    Greenlet是python的一個C擴展，來源於Stackless python，旨在提供可自行調度的‘微線程’， 即協程。generator實現的協程在yield value時只能將value返回給調用者(caller)。 而在greenlet中，target.switch（value）能夠切換到指定的協程（target）， 而後yield value。greenlet用switch來表示協程的切換，從一個協程切換到另外一個協程須要顯式指定。

    • greenlet 實現狀態切換

       
       
        
      xxxxxxxxxx
       
       
       
        
      from greenlet import greenlet
      def eat(name):
          print('%s eat 1' %name)
          g2.switch('egon')
          print('%s eat 2' %name)
          g2.switch()
      def play(name):
          print('%s play 1' %name)
          g1.switch()
          print('%s play 2' %name)
      ​
      g1=greenlet(eat)
      g2=greenlet(play)
      g1.switch('egon')#能夠在第一次switch時傳入參數，之後都不須要
       

    • 單純的切換（在沒有io的狀況下或則沒有重複開闢內存空間的操做），反而會下降程序的執行速度

      #順序執行
import time
def f1():
    res=1
    for i in range(100000000):
        res+=i
def f2():
    res=1
    for i in range(100000000):
        res*=i

start=time.time()
f1()
f2()
stop=time.time()
print('run time is %s' %(stop-start))    #10.985628366470337

#切換
from greenlet import greenlet
import time
def f1():
    res=1
    for i in range(100000000):
        res+=i
        g2.switch()
def f2():
    res=1
    for i in range(100000000):
        res*=i
        g1.switch()

start=time.time()
g1=greenlet(f1)
g2=greenlet(f2)
g1.switch()
stop=time.time()
print('run time is %s' %(stop-start))   # 52.763017892837524

#greenlet只是提供了一種比generator更加便捷的切換方式，當切到一個任務執行時若是遇到io，那就原地阻塞，仍然是沒有解決遇到IO自動切換來提高效率的問題。
#單線程裏的這20個任務的代碼一般會既有計算操做又有阻塞操做，咱們徹底能夠在執行任務1時遇到阻塞，就利用阻塞的時間去執行任務2。。。。如此，才能提升效率，這就用到了Gevent模塊

    • greenlet不是創造協程的模塊，它是用來作多個協程任務切換的，它究竟是怎麼實現切換的呢？

      from greenlet import greenlet
def func():
    print(123)
 
def func2():
    print(456)
 
g1 = greenlet(func)  # 實例化
g2 = greenlet(func2)
g1.switch()  # 開始運行,它會運行到下一個switch結束。不然一直運行  結果：123

#複雜點的交叉切換
from greenlet import greenlet
def test1():
    print 12
    gr2.switch()  #能夠把switch理解爲水龍頭的開關，g2開
    print 34
 
def test2():
    print 56
    gr1.switch()   #g1開
    print 78
 
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

#執行結果
#12
#56
#34
#當建立一個greenlet時，首先初始化一個空的棧， switch到這個棧的時候，會運行在greenlet構造時傳入的函數（首先在test1中打印 12）， 若是在這個函數（test1）中switch到其餘協程（到了test2 打印34），那麼該協程會被掛起，等到切換回來（在test2中切換回來 打印34）。當這個協程對應函數執行完畢，那麼這個協程就變成dead狀態。
#注意：上面沒有打印test2的最後一行輸出 78，由於在test2中切換到gr1以後掛起，可是沒有地方再切換回來。這個可能形成泄漏，後面細說

    • greenlet的缺點：1.手動切換；2.不能規避I/O操做(睡眠)

    3、gevent模塊

    • Gevent 是一個第三方庫，能夠輕鬆經過gevent實現併發同步或異步編程，在gevent中用到的主要模式是Greenlet, 它是以C擴展模塊形式接入Python的輕量級協程。 Greenlet所有運行在主程序操做系統進程的內部，但它們被協做式地調度。

    • 用法介紹

      g1=gevent.spawn(func,1,,2,3,x=4,y=5)  #建立一個協程對象g1，spawn括號內第一個參數是函數名，如eat，後面能夠有多個參數，能夠是位置實參或關鍵字實參，都是傳給函數eat的

g2=gevent.spawn(func2)

g1.join() #等待g1結束

g2.join() #等待g2結束

#或者上述兩步合做一步：gevent.joinall([g1,g2])

g1.value  #拿到func1的返回值

    • gevent遇到io主動切換

      from gevent import monkey;monkey.patch_all()  #這裏的猴子是能夠抓取下面的全部阻塞，如time
import threading
import gevent
import time
def eat():
    print(threading.current_thread().getName())
    print('eat food 1')
    time.sleep(2)   #遇到io主動切換到play
    print('eat food 2')

def play():
    print(threading.current_thread().getName())
    print('play 1')
    time.sleep(1)
    print('play 2')

g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print('主')

#結果
DummyThread-1   #dummy 假的；仿製品，因此能夠知道是假進程
eat food 1
DummyThread-2
play 1
play 2
eat food 2
主

    • 詳細解讀gevent

      img

      import gevent
def eat():
    print('eating1')
    print('eating2')
g1 = gevent.spawn(eat)  #建立一個協程對象g1

#結果：爲空，不會執行，由於沒有遇到阻塞

import gevent
def eat():
    print('eating1')
    print('eating2')
g1 = gevent.spawn(eat)  #建立一個協程對象g1
g1.join()  #等待g1結束
#結果：eating1   eating2

#當使用time時，gevent並抓不到這個阻塞
import time
import gevent
def eat():
    print('eating1')
    time.sleep(1)
    print('eating2')
 
def play():
    print('playing1')
    time.sleep(1)
    print('playing2')
 
g1 = gevent.spawn(eat)  #建立一個協程對象g1
g2 = gevent.spawn(play)
g1.join()  #等待g1結束
g2.join()

#執行輸出：
#eating1
#eating2
#playing1
#playing2

#使用gevent的阻塞的time才能抓取
import time
import gevent
def eat():
    print('eating1')
    gevent.sleep(1)  #延時調用
    print('eating2')
 
def play():
    print('playing1')
    gevent.sleep(1)  #延時調用
    print('playing2')
 
g1 = gevent.spawn(eat)  #建立一個協程對象g1
g2 = gevent.spawn(play)
g1.join()  #等待g1結束
g2.join()
#執行輸出：
eating1
playing1
eating2
playing2

    • 猴子補丁

      若是想讓協程執行time.sleep()呢？因爲默認，協程沒法識別time.sleep()方法，須要導入一個模塊monkey
monkey patch (猴子補丁)
from gevent import monkey;monkey.patch_all()
# 它會把下面導入的全部的模塊中的IO操做都打成一個包，gevent就可以認識這些IO了
import time
import gevent
def eat():
    print('eating1')
    time.sleep(1)  #延時調用
    print('eating2')
 
def play():
    print('playing1')
    time.sleep(1)  #延時調用
    print('playing2')
 
g1 = gevent.spawn(eat)  #建立一個協程對象g1
g2 = gevent.spawn(play)
g1.join()  #等待g1結束
g2.join()
#執行輸出：
#playing1
#eating2
#eating2
#playing2

    • 結論：

      • 使用gevent模塊來執行多個函數，表示在這些函數遇到IO操做的時候能夠在同一個線程中進行切換 利用其餘任務的IO阻塞時間來切換到其餘的任務繼續執行
      • spawn來發布協程任務join負責開啓並等待任務執行結束 gevent自己不認識其餘模塊中的IO操做，可是若是咱們在導入其餘模塊以前執行from gevent import monkey;monkey.patch_all() 這行代碼，必須在文件最開頭gevent就可以認識在這句話以後導入的模塊中的全部IO操做了

  • Gevent的同步與異步

    from gevent import spawn,joinall,monkey;monkey.patch_all() 
import time
def task(pid):
    time.sleep(0.5)
    print('Task %s done' % pid) 
 
def synchronous():  # 同步
    for i in range(10):
        task(i)
 
def asynchronous(): # 異步
    g_l=[spawn(task,i) for i in range(10)]
    joinall(g_l)
    print('DONE')
     
if __name__ == '__main__':
    print('Synchronous:')
    synchronous()  #前者打印完，才執行後面
    print('Asynchronous:')
    asynchronous()
#  上面程序的重要部分是將task函數封裝到Greenlet內部線程的gevent.spawn。
#  初始化的greenlet列表存放在數組threads中，此數組被傳給gevent.joinall 函數，
#  後者阻塞當前流程，並執行全部給定的greenlet任務。執行流程只會在 全部greenlet執行完後纔會繼續向下走。

  • Gevent的應用舉例

    #爬蟲
url_dic = {
    '協程':'http://www.cnblogs.com/Eva-J/articles/8324673.html',
    '線程':'http://www.cnblogs.com/Eva-J/articles/8306047.html',
    '目錄':'https://www.cnblogs.com/Eva-J/p/7277026.html',
    '百度':'http://www.baidu.com',
    'sogou':'http://www.sogou.com',
    '4399':'http://www.4399.com',
    '豆瓣':'http://www.douban.com',
    'sina':'http://www.sina.com.cn',
    '淘寶':'http://www.taobao.com',
    'JD':'http://www.JD.com'
}
import time
from gevent import monkey;monkey.patch_all()
from urllib.request import urlopen
import gevent

def get_html(name,url):
    ret = urlopen(url)
    content = ret.read()
    with open(name,'wb') as f:
        f.write(content)

start = time.time()
for name in url_dic:
    get_html(name+'_sync.html',url_dic[name])
ret = time.time() - start
print('同步時間 :',ret)

start = time.time()
g_l = []
for name in url_dic:
    g = gevent.spawn(get_html,name+'_async.html',url_dic[name])
    g_l.append(g)
gevent.joinall(g_l)
ret = time.time() - start
print('異步時間 :',ret)

#同步時間 : 5.821720123291016
#異步時間 : 4.347508907318115

#聊天工具
#服務端
from gevent import monkey;monkey.patch_all()
import socket
import gevent
def async_talk(conn):
    try:
        while True:
            conn.send(b'hello')
            ret = conn.recv(1024)
            print(ret)
    finally:
        conn.close()
sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()
while True:
    conn,addr = sk.accept()
    gevent.spawn(async_talk,conn)
sk.close()

#客服端
import socket
from threading import Thread
def socket_client():
    sk = socket.socket()
    sk.connect(('127.0.0.1',9000))
    while True:
        print(sk.recv(1024))
        sk.send(b'bye')
    sk.close()
for i in range(500):
    Thread(target=socket_client).start()

     

4、生成器————>asyncio模塊 asyncio學習

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程