python笔记(协程)

一、协程
1、本质上是一个线程
2、能够在多个任务之间切换来节省一些IO时间
3、协程中任务之间的切换也消耗时间，但是开销要远远小于进程线程之间的切换，实现并发的手段

def consumer():
    while True:
        x = yield  # 生成器函数
        print('处理了数据：', x)


def producer():
    c = consumer()
    next(c)
    for i in range(4):
        print('生产了数据：', i)
        c.send(i)  # 传送数据，会执行consumer()


producer()

输出结果：

生产了数据： 0
处理了数据： 0
生产了数据： 1
处理了数据： 1
生产了数据： 2
处理了数据： 2
生产了数据： 3
处理了数据： 3

2、真正的协程模块就是使用greenlet完成的切换

from greenlet import greenlet
def eat():
    print('eating start')
    g2.switch()  # 切换到g2
    print('eating end')


def play():
    print('playing start')


g1 = greenlet(eat)
g2 = greenlet(play)
g1.switch()  # 切换到g1

输出结果

eating start
playing start

3、进程 + 线程 + 协程
5 20 500
一个进程里面有20个线程可总共开5 * 20 * 500个协程

import time
import gevent  # 感知不到time.sleep，能感知到gevent.sleep


def eat():
    print('eating start')
    # time.sleep(1)
    gevent.sleep(1)
    print('eating end')


def play():
    print('playing start')
    # time.sleep(1)
    gevent.sleep(1)
    print('playing end')


g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()

输出结果

eating start
playing start
eating end
playing end

from gevent import monkey;

monkey.patch_all()  # 可以将所有的阻塞操作打包，就可以感知到
import threading
import time
import gevent  # 感知不到time.sleep，能感知到gevent.sleep


def eat():
    print(threading.current_thread().getName())
    print(threading.current_thread())  # 可以看出是一个虚拟的线程
    print('eating start')
    time.sleep(1)
    # gevent.sleep(1)
    print('eating end')


def play():
    print(threading.current_thread().getName())
    print(threading.current_thread())
    print('playing start')
    time.sleep(2)
    # gevent.sleep(1)
    print('playing end')


g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()

输出结果：

DummyThread - 1 < _DummyThread(DummyThread - 1, started daemon 1772404630344) >
eating start
DummyThread - 2 < _DummyThread(DummyThread - 2, started daemon 1772404630600) >
playing start
eating end
playing end

进程和线程的任务切换由操作系统完成,协程任务之间切换由程序（代码）完成，只有遇到协程模块功能识别的IO操作的时候，程序才会进行任务切换，实现并发的效果

4、同步和异步

from gevent import monkey;

monkey.patch_all()
import time
import gevent


def task():
    time.sleep(1)
    print(12345)


def sync():
    for i in range(5):
        task()


def async():  # 效率很高
    g_list = []
    for i in range(10):
        g = gevent.spawn(task)
        g_list.append(g)
    gevent.joinall(g_list)


sync()
async()

5、协程更适合网络操作中（在一个线程中实现并发效果的概念）能够规避一些任务中的IO操作,在任务的执行过程中，检测到IO就切换到其他任务。
（1）爬虫的例子（请求过程中的IO等待）

from gevent import monkey;

monkey.patch_all()
import gevent
import requests

url = 'http://www.baidu.com'


def get_url(urls):
    res = requests.get(urls)
    return len(res.content.decode('utf-8'))


g1 = gevent.spawn(get_url, 'http://www.baidu.com')
g2 = gevent.spawn(get_url, 'http://www.sogou.com')
g3 = gevent.spawn(get_url, 'http://www.taobao.com')
g4 = gevent.spawn(get_url, 'http://www.hao123.com')
g5 = gevent.spawn(get_url, 'http://www.cnblogs.com')
gevent.joinall([g1, g2, g3, g4, g5])
print(g1.value)
print(g2.value)
print(g3.value)
print(g4.value)
print(g5.value)

输出结果：

2287
23446
149538
487625
41855

（2）socket server
server端：

from gevent import monkey;

monkey.patch_all()
import socket
import gevent


def talk(conn):
    conn.send(b'hello')
    print(conn.recv(1024).decode('utf-8'))
    conn.close()


sk = socket.socket()
sk.bind(('127.0.0.1', 8080))
sk.listen(5)
while True:
    conn, addr = sk.accept()
    gevent.spawn(talk, conn)
sk.close()

client端：

import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 8080))
print(sk.recv(1024).decode('utf-8'))
msg = input('>>').encode('utf-8')
sk.send(msg)
sk.close()

（1）多线程被弱化了协程
（2）在一个线程上提高CPU的利用率
（3）协程相比于多线程的优势切换的效率更快了