Python 攜程

一、協程

　　1、又稱微線程，纖程。英文名Coroutine.一句話說明什么是協程：協程是一種用戶態的輕量級線程（相當於操作系統不知道它的存在，是用戶控制的）。

　　2、協程擁有自己的寄存器上下文和棧(代碼的必要的代碼段和)。協程調度切換時，將寄存器上下文和棧保存到其他地方，在切回來的時候，恢復先前保存的寄存器上下文和棧，因此：協程能保留上一次調用時的狀態(即所有局部狀態的一個特定組合)，每次過程重入時，就相當於進入上一次調用的狀態，換種說法：進入上一次離開時所處邏輯流的位置。

　　3、協程一定是在單線程中運行的。

二、協程的優點與缺點

　　優點：

　　1、無需線程上下文切換的開銷。

　　2、無需原子操作（最小級別的操作）鎖定及同步的開銷。

　　3、方便切換控制流，簡化編程模型。

　　4、高並發+高擴展性+低成本：一個CPU支持上萬的協程都不是問題，所以很適合用於高並發處理。

　　缺點：

　　1、無法利用多核資源：協程的本質是個單線程，它不能同時將單個CPU的多個核用上，協程需要和進程配合才能運行在多CPU上，當然我們日常所編寫的絕大部分應用都沒有這個必要，除非是cpu密集型應用。

　　2、進行阻塞(Blocking)操作(如IO時)會阻塞掉整個程序。

三、使用yield實現協程操作例子

　　1、使用yield實現的一個最簡單的協程的效果

#!/usr/bin/python
# -*- coding : utf-8 -*-
# 作者： Presley
# 時間： 2018-12-4
# 郵箱：[e-mail]
# 這是我用來練習python 協程的測試腳本

import time
import queue

def consumer(name):
    print("starting eating baozi...")
    while True:
        new_baozi = yield
        print("[%s] is eating baozi %s" %(name,new_baozi))

def producer():
    r = con.__next__()
    r = con2.__next__()
    n = 0
    while n < 5:
        n += 1
        con.send(n)
        con2.send(n)
        print("\033[32;1m[producer]\033[0m is making")

if __name__ == "__main__":
    con = consumer("c1")
    con2 = consumer("c2")


    p = producer()

　　執行結果：

C:\Users\wohaoshuai\AppData\Local\Programs\Python\Python36\python.exe E:/PythonLearn/day16/pro_consume.py
starting eating baozi...
starting eating baozi...
[c1] is eating baozi 1
[c2] is eating baozi 1
[producer] is making
[c1] is eating baozi 2
[c2] is eating baozi 2
[producer] is making
[c1] is eating baozi 3
[c2] is eating baozi 3
[producer] is making
[c1] is eating baozi 4
[c2] is eating baozi 4
[producer] is making
[c1] is eating baozi 5
[c2] is eating baozi 5
[producer] is making

Process finished with exit code 0

 　　2、greenlet

#!/usr/bin/python
# -*- coding : utf-8 -*-
# 作者： Presley
# 時間： 2018-12-4
# 郵箱：[e-mail]
# 這是我用來練習python 協程的測試腳本

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()

執行結果：

C:\Users\wohaoshuai\AppData\Local\Programs\Python\Python36\python.exe E:/PythonLearn/day16/pro_consume.py
12
56
34
78

Process finished with exit code 0

　　3、gevent

　　　　a、gevent是一個第三方庫，可以輕松通過gevent實現並發同步或異步編程，在gevent中用到的主要模式是greenlet，它是以C擴展模塊形式接入Python的輕量級協程。greenlet全部運行在主程序操作系統進程的內部，但它們被協作式地調度。

#!/usr/bin/python
# -*- coding : utf-8 -*-
# 作者： Presley
# 時間： 2018-12-1
# 郵箱：[e-mail]
# 這是我用來練習python 協程的測試腳本

import gevent

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

def bar():
    print("Explicit context to bar")
    gevent.sleep(1)
    print("Implicit context switch back to bar")

def ex():
    print("Explicit context to ex")
    gevent.sleep(1)
    print("Implicit context switch back to ex")

gevent.joinall([
    gevent.spawn(foo),  #類似產生一個協程的foo
    gevent.spawn(bar),  #產生一個協程的bar
    gevent.spawn(ex)
])

#代碼的效果為：第一個協程切換到第二個，第二個切換到第三個，然后又遇到sleep(模擬io)又切換到下一個，然后實現並發的協程的效果

　　　　執行結果

C:\Users\wohaoshuai\AppData\Local\Programs\Python\Python36\python.exe E:/PythonLearn/day16/pro_consume.py
Running in foo
Explicit context to bar
Explicit context to ex
Explicit context switch to foo again
Implicit context switch back to bar
Implicit context switch back to ex

Process finished with exit code 0

 　　b、通過協程爬取網頁實例

#!/usr/bin/python
# -*- coding : utf-8 -*-
# 作者： Presley
# 時間： 2018-12-5
# 郵箱：[e-mail]
# 這是我用來練習python 協程的測試腳本

from gevent import monkey;monkey.patch_all()
import gevent

from urllib.request import urlopen

def f(url):
    print("GET: %s"  %url)
    resp = urlopen(url)
    data = resp.read()
    print("%d bytes received from %s." %(len(data),url))

gevent.joinall([
    gevent.spawn(f,"https://www.python.org/"),
    gevent.spawn(f,"https://www.yahoo.com/"),
    gevent.spawn(f,"https://github.com"),
])

執行結果：

C:\Users\wohaoshuai\AppData\Local\Programs\Python\Python36\python.exe E:/PythonLearn/day16/pro_consume.py
GET: https://www.python.org/
GET: https://www.yahoo.com/
GET: https://github.com
80704 bytes received from https://github.com.
50008 bytes received from https://www.python.org/.
528149 bytes received from https://www.yahoo.com/.

Process finished with exit code 0

　　c、通過gevent實現單線程下的多socket並發

　　　　server端

#!/usr/bin/python
# -*- coding : utf-8 -*-
# 作者： Presley
# 時間： 2018-12-5
# 郵箱：[e-mail]
# 這是我用來練習python 協程的測試腳本


import gevent
from gevent import socket,monkey
monkey.patch_all() #python中的一種黑魔法，只要寫入一句話就自動的把python中的許多標准庫變為非阻塞的模式

def server(port):
    s = socket.socket()
    s.bind(("0.0.0.0",port))
    s.listen(5000)
    while True:
        cli,addr = s.accept()
        gevent.spawn(handle_request,cli) #執行handle_request函數，參數是cli,即客戶端實例
def handle_request(s):
    try:
        while True:
            data = s.recv(1024) #接收數據，這里設置成不阻塞
            print("recv:",data)
            s.send(data)
            if not data:
                s.shutdown(socket.SHUT_RD) #如果接收為空值，結束
    except Exception as ex:
        print(ex)
    finally:
        s.close()

if __name__ == "__main__":
    server(8001)

　　　　client端

#!/usr/bin/python
# -*- coding : utf-8 -*-
# 作者： Presley
# 時間： 2018-12-5
# 郵箱：[e-mail]
# 這是我用來練習python 協程的測試腳本

import socket

HOST = "localhost"
PORT = 8001
s = socket.socket()
s.connect((HOST,PORT))

while True:
    msg = input(">>:")
    if not msg:continue
    msg = msg.encode("utf-8")
    s.sendall(msg)
    data = s.recv(1024)
    print("Received",data.decode("utf-8"))
s.close()