Day36 of learning python --协程

1.协程的由来

　　进程是资源分配的最小单位，线程是CPU调度的最小单位。但是无论是创建多进程还是创建多线程来解决问题，都要消耗一定的时间来创建进程、创建线程、以及管理他们之间的切换。

因此，我们，基于单线程来实现并发，即只用一个主线程(很明显可利用的CPU只有一个)情况下实现并发。这样就可以节省创建进程所消耗的时候。并发的本质是：切换+保存状态

CPU去切换执行其他的任务的情况是：1.时间片已经到 2.任务发生了阻塞 3.原来任务计算的时间过长。

 所以，我们利用yeild来实现单线程并发，yield本身就是一种在单线程下可以保存任务状态的方法。

#1 yiled可以保存状态，yield的状态保存与操作系统的保存线程状态很像，但是yield是代码级别控制的，更轻量级
#2 send可以把一个函数的结果传给另外一个函数，以此实现单线程内程序之间的切换

yield的用法： 一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起来像函数调用，但不会执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）才开始执行。
虽然执行流程仍按函数的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。
带有 yield 的函数，Python 解释器会将其视为一个 generator，调用 该函数(比如：fab(5) ）不会执行 fab 函数，而是返回一个 iterable 对象！

但是我们单纯使用yield来切换程序时，反而会降低运行的速率。如下

#串行执行
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) #0.8066320419311523



#基于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) #8.019175052642822

  因此，对于单线程来说，当遇到IO或者是其他阻塞时，我们可以切换到另一个任务执行。这样就能提高效率了。但是yield不能遇到IO阻塞去执行另一个任务。所以，协程的本质上就是在单线程下，由用户自己控制一个任务遇到IO阻塞了就切换到另一个任务去执行，以此来提升效率。

#1. 可以控制多个任务之间的切换，切换之前将任务的状态保存下来，以便重新运行时，可以基于暂停的位置继续执行。
#2. 作为1的补充：可以检测io操作，在遇到io操作的情况下才发生切换

 　　对于单线程，我们不可避免程序中出现IO操作，但如果我们能在自己的程序中（非操作系统级别）控制单线程下的多个任务能在一个任务遇到IO阻塞就切换到另一个任务去计算，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被CPU执行地状态，相当于我们在用户程序级别

将自己的IO操作最大限度地隐藏起来，从而可以迷惑操作系统。让其看到：该线程好像是一直在计算，io比较少，从而更多的将cpu的执行权限分配给我们的线程。

2.协程的介绍

　　协程：是单线程下的并发，又称微线程。协程是一种用户态的轻量级线程，即协程随是由用户程序自己控制调度的。

#1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

 协程的优点：

1）协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到。2）单线程内就可以实现并发的效果，最大限度地利用了CPU。

协程的缺点：

1）协程的本质是单线程，无法利用多核。不过可以一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程。2）协程一旦出现阻塞，将会阻塞整个线程。

协程的总特点：

1）只能在一个线程内实现并发

2）修改共享数据不需要加锁，因为协程本质上是在一个线程内的。

3）用户程序里自己保存多个控制流的上下文栈。

4）一个协程遇到IO操作自动切换到其它协程，需要用到gevent模块(select机制)。

3.Gevent模块

安装模块：pip/pip3 install gevent

Gevent是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent主要用到的模式是Greenlet。

使用操作：

g1 = gevent.spawn(func,*args,**kwargs)，创建一个协程对象。
g1.join()   #等待g1介绍

gevent.joinall([g1,g2])   # 等待g1,g2结束

g1.value   #拿到func的返回值

 Gevent的使用

from gevent import monkey;monkey.patch_all()

import gevent
import time
def eat():
    print('eat food 1')
    time.sleep(2)
    print('eat food 2')

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

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

 　　当要使用协程gevent模块时，需要打补丁用来识别IO阻塞，比如time.sleep()，或者socket()等，from gevent import monkey;monkey.patch_all()，且必须在time，socket模块之前；

from gevent import monkey;monkey.patch_all()
import gevent
import time # IO时间
import threading
def eat():
    print(threading.current_thread().getName())
    print('eating start')
    time.sleep(1)
    print('eating end')

def play():
    print(threading.current_thread().getName()) #Dummy,假的，虚拟的  查看当前的协程的名字
    print('playing start')
    time.sleep(1)
    print('playing end')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()
结果：
DummyThread-1
eating start
DummyThread-2
playing start
eating end
playing end

4.Gevent的同步和异步

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

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

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

def async1():
    g_lst = []
    for i in range(20):
        g = gevent.spawn(task)
        g_lst.append(g)
    gevent.joinall(g_lst)

sync()
async1()
# 进程和线程的状态切换由操作系统完成（时间片），而协程任务之间的切换由程序(代码)完成，
# 只有遇到协程模块识别的IO操作时候，程序才回去切。由greenlet的swithch()来完成切（遇到IO就切，异步操作）

 5.使用Gevent来爬虫

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

def get_page(url):
    print('GET:%s' % url)
    response = requests.get(url)
    if response.status_code == 200:
        print('%d bytes received from %s'%(len(response.text),url))


start = time.time()

gevent.joinall([
    gevent.spawn(get_page,'https://www.python.org/'),
    gevent.spawn(get_page,'https://www.github.com/'),
    gevent.spawn(get_page,'https://www.sogou.com/')
])

stop = time.time()

print('run time:%s'%(stop-start))

get_page('https://www.python.org/')
get_page('https://www.github.com/')
get_page('https://www.sogou.com/')

run_time = time.time() - stop
print('同步使用的时间：%s'%(run_time))

 6.使用Gevent实现单线程的socket并发

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

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

sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

while 1:
    conn,addr = sk.accept()
    gevent.spawn(talk,conn)
sk.close()

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))

ret =sk.recv(1024).decode('utf-8')
print(ret)
msg = input('>>>').encode('utf-8')
sk.send(msg)

sk.close()