协程

协程介绍

在单线程执行的情况下，如果要实现并发的效果，只需要CPU在不同的时间运行不同的线程即可。

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

在单线程下，程序不可避免的会出现IO操作，如果我们在自己的程序中（用户程序级别，而非操作系统级别）控制单线程下的多个任务在遇到IO操作时，自动切换为另一个任务去执行计算，就最大程度的保证线程随时都是可以被CPU执行的状态，这样操作系统就认为该线程一直在执行计算任务，IO任务很少，从而将更多的CPU资源分配给线程。

协程的本质

在单线程下，用户自己控制一个任务遇到IO阻塞就切换到另一个任务去执行，以此来提升效率。
为了实现这种方式，我们需要寻找同时满足以下条件的解决方案：

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

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

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

协程的特点

优点如下：

• 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
• 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点如下：

• 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
• 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程的特点：

1.必须在只有一个单线程里实现并发。
2.修改和共享数据不需要加锁
3.用户程序里自己保存多个控制流的上下文栈
4.一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

Greenlet 模块

安装模块

pip3 install greenlet

Greenlet模块主要用于实现同一个线程中不同任务之间的来回切换，这里切换时认为控制的，Greenlet并不能实现遇到IO之后自动切换。
实现代码如下：

from greenlet import greenlet


def eat(name):
    print('%s eat 1 ' % name)
    g2.switch('tom')  # 将任务切换到g2，也就是paly函数进行执行
    print('%s eat 2 ' % name)
    g2.switch()  # 再次将任务切回g2


def play(name):
    print('%s play 1' % name)
    g1.switch()  # 将任务切回g1
    print('%s play 2' % name)


g1 = greenlet(eat)  # 生成一个greenlet对象
g2 = greenlet(play)

g1.switch('bob')  # 启动任务 eat

输出结果：

bob eat 1 
tom play 1
bob eat 2 
tom play 2

gevent模块

gevent 模块可以实现遇到IO之后自动进行切换，在使用之前需要安装gevent

pip3 install gevent

gevent模块的使用

使用gevent模块，在遇到gevent.sleep时自动切换,这里只限于gevent方法：

import gevent          # 导入Gevent模块
import time

def eat(name):
    print('%s eat 1 ' % name)
    gevent.sleep(2)
    print('%s eat 2 ' % name)



def play(name):
    print('%s play 1' % name)
    gevent.sleep(2)
    print('%s play 2' % name)

g1=gevent.spawn(eat,'tom')
g2=gevent.spawn(play,'bob')

# g1.join()
# g2.join()
gevent.joinall([g1,g2])

输出结果：

tom eat 1 
bob play 1
tom eat 2 
bob play 2

gevent模块识别其他IO

通过对gevent模块打补丁，可以扩展其识别其他的IO行为，这种方式才是经常使用的方式：

from gevent import monkey;monkey.patch_all()  # 给Gevent模块打补丁，让它能识别其他的IO操作
import gevent          # 导入Gevent模块
import time

def eat(name):
    print('%s eat 1 ' % name)
    # gevent.sleep(2)
    time.sleep(2)       # 导入补丁之后可以识别time模块中的sleep行为
    print('%s eat 2 ' % name)



def play(name):
    print('%s play 1' % name)
    # gevent.sleep(2)
    time.sleep(2)
    print('%s play 2' % name)

g1=gevent.spawn(eat,'tom')
g2=gevent.spawn(play,'bob')

# g1.join()
# g2.join()
gevent.joinall([g1,g2])

单线程内实现并发

使用单线程的方式实现客户端和服务端的交互：

# 服务端

from gevent import monkey,spawn;monkey.patch_all()
from socket import *
from threading import Thread,current_thread

def comunicate(conn):
    print('子线程: %s' %current_thread().getName())
    while True:
        try:
            data = conn.recv(1024)
            if not data: break
            conn.send(data.upper())
        except ConnectionResetError:
            break
    conn.close()

def server(ip,port):
    print('主线程：%s' %current_thread().getName())
    server = socket(AF_INET,SOCK_STREAM)
    server.bind((ip,port))
    server.listen(5)

    while True:
        conn,addr = server.accept()
        print(addr)

        spawn(comunicate,conn)

    server.close()

if __name__=='__main__':
    g=spawn(server,'127.0.0.1',8080)
    g.join()


# 客户端

from socket import *
from threading import current_thread,Thread

def client():

    client=socket(AF_INET,SOCK_STREAM)
    client.connect(('127.0.0.1',8080))

    while True:

        client.send(('%s say hello' %current_thread().getName()).encode('utf-8'))
        data=client.recv(1024)
        print(data.decode('utf-8'))
    client.close()

if __name__ == '__main__':
    for i in range(500):    # 使用500个线程并发请求服务端
        t=Thread(target=client)
        t.start()