在作業系統中程序是資源分配的最小單位, 執行緒是cpu排程的最小單位。
協程：是單執行緒下的併發，又稱微執行緒，纖程。英文名coroutine。一句話說明：協程是一種使用者態的輕量級執行緒，即協程是由使用者程式自己控制排程的。也就是說程式設計師用**來控制切換.
參考：
# 程序 啟動多個程序 程序之間是由作業系統負責呼叫
# 執行緒 啟動多個執行緒 真正被cpu執行的最小單位實際是執行緒
# 開啟乙個執行緒 建立乙個執行緒 暫存器 堆疊
# 關閉乙個執行緒
# 協程
# 本質上是乙個執行緒
# 能夠在多個任務之間切換來節省一些io時間
# 協程中任務之間的切換也消耗時間,但是開銷要遠遠小於程序執行緒之間的切換
# 實現併發的手段
import time
def consumer():
while true:
x = yield
time.sleep(1)
print('處理資料 :',x)
def producer():
c = consumer()
next(c)
for i in range(10):
time.sleep(1)
print('生產資料:',i)
c.send(i)
# 這個生產者消費者模型 模擬了程式的來回切換， 但是不能規避io時間
producer()
使用pip3 install greenlet 和 pip3 install gevent 安裝好模組，繼續：
# 真正的協程模組就是使用greenlet完成的切換
from greenlet import greenlet
def eat():
print('eating start')
g2.switch() # 切換到g2
print('eating end')
g2.switch()
def play():
print('playing start')
g1.switch() # 切換到g1
print('playing end')
g1 = greenlet(eat) # 委託給g1
g2 = greenlet(play)
g1.switch()
greenlet可以實現協程，不過每一次都要人為的去指向下乙個該執行的協程，顯得太過麻煩。python還有乙個比greenlet更強大的並且能夠自動切換任務的模組gevent
參考：# 協程是一種使用者態的輕量級執行緒，即協程是由使用者程式自己控制排程的。
import time
import gevent
def eat():
print('eating start')
# time.sleep(1) # gevent 不能感知到time.sleep時間
gevent.sleep(1)
print('eating end')
def play():
print('playing start')
gevent.sleep(1)
print('playing end')
g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()
gevent的正確方式：
## 匯入這句，將所有模組中的阻塞io都打成乙個包。就可以感知 time.sleep
from gevent import monkey;monkey.patch_all()
import time
import gevent
import threading
def eat():
print(threading.current_thread().getname()) # dummy 假的，虛擬的。
print(threading.current_thread())
print('eating start')
time.sleep(1.2)
print('eating end')
def play():
print(threading.current_thread().getname())
print(threading.current_thread())
print('playing start')
time.sleep(1)
print('playing end')
g1 = gevent.spawn(eat) # 註冊到協程，遇到io將自動切換
g2 = gevent.spawn(play)
# g1.join()
# g2.join()
gevent.joinall([g1,g2])
print('master')
# 程序和執行緒的任務切換由作業系統完成
# 協程任務之間的切換由程式(**)完成,只有遇到協程模組能識別的io操作的時候,程式才會進行任務切換,實現併發的效果
同步和非同步：
# 同步 和 非同步
from gevent import monkey;monkey.patch_all()
import time
import gevent
def task(n):
time.sleep(1)
print(n)
def sync():
for i in range(5):
task(i)
def async():
g_lst =
for i in range(5):
g = gevent.spawn(task,i)
gevent.joinall(g_lst) # for g in g_lst:g.join()
sync() # 同步
async() # 非同步
爬蟲時使用協程併發
# 協程 : 能夠在乙個執行緒中實現併發效果的概念
# 能夠規避一些任務中的io操作
# 在任務的執行過程中,檢測到io就切換到其他任務
# 多執行緒 被弱化了
# 協程 在乙個執行緒上 提高cpu 的利用率
# 協程相比於多執行緒的優勢 切換的效率更快
# 爬蟲的例子
# 請求過程中的io等待
from gevent import monkey;monkey.patch_all()
import gevent
from urllib.request import urlopen # 內建的模組
def get_url(url):
response = urlopen(url)
content = response.read().decode('utf-8')
return len(content)
g1 = gevent.spawn(get_url,'')
g2 = gevent.spawn(get_url,'')
g3 = gevent.spawn(get_url,'')
g4 = gevent.spawn(get_url,'')
g5 = gevent.spawn(get_url,'')
gevent.joinall([g1,g2,g3,g4,g5])
print(g1.value)
print(g2.value)
print(g3.value)
print(g4.value)
print(g5.value)
ret = get_url('')
print(ret)
python併發 協程
在作業系統中程序是資源分配的最小單位,執行緒是cpu排程的最小單位。協程 是單執行緒下的併發，又稱微執行緒，纖程。英文名coroutine。一句話說明 協程是一種使用者態的輕量級執行緒，即協程是由使用者程式自己控制排程的。也就是說程式設計師用 來控制切換.參考 程序 啟動多個程序 程序之間是由作業系...
python 併發程式設計 協程 協程介紹
協程 是單執行緒下的併發，又稱微執行緒，纖程。英文名coroutine。一句話說明什麼是執行緒 協程是一種使用者態的輕量級執行緒，即協程是由使用者程式自己控制排程的 需要強調的是 1.python的執行緒屬於核心級別的，即由作業系統控制排程 如單執行緒遇到io或執行時間過長就會被迫交出cpu執行許可...
Python 併發程式設計（協程）
本章節主要介紹，使用單執行緒實現併發，即只用乙個主線程 很明顯可利用cpu只有乙個 為此我們需要先回顧下併發的本質 切換 儲存狀態 ps 在介紹程序理論時，提及程序的三種執行狀態，而執行緒才是執行單位，所以也可以將上圖理解為執行緒的三種狀態 單執行緒下併發稱為 協程 特點 缺點 gevent 是乙個...