并发编程【六】协程

协程

 

什么是协程

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。、

需要强调的是：

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

对比操作系统控制线程的切换，用户在单线程内控制协程的切换

优点如下：

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

缺点如下：

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

总结协程特点：

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

greenlet模块

为了实现同一线程内不同方法中任务可以来回切换；别人写的第三方模块；安装 ：pip3 install greenlet

rom greenlet import greenlet

def eat():               # 1
    print('111')         # 6
    g2.switch()          # 7
    print('333')         # 10
    g2.switch()          # 11
def sleep():             # 2
    print('222')         # 8
    g1.switch()          # 9
    print('444')         # 12
g1 = greenlet(eat)       # 3
g2 = greenlet(sleep)     # 4
g1.switch()              # 5

greenlet状态切换

进程：计算机中资源分配的最小单位
线程：计算机中cpu调度的最小单位
操作系统负责调度线程,对于操作系统来说,可见的最小单位就是线程；
线程的开销比进程虽然小的多,但是开启/关闭线程仍然需要开销

协程：本质是一条线程,操作系统不可见,是由程序员操作的,而不是由操作系统调度的；

出现的意义：多个任务中的IO时间可以共享，当执行一个任务遇到IO操作的时候，可以将程序切换到另一个任务中继续执行，在有限的线程中，实现任务的并发，节省了调用操作系统创建/销毁线程的时间，并且切成的切换效率比线程的切换效率要高，协程执行多个任务能够让线程少陷入阻塞，让线程看起来很忙，线程陷入的阻塞的次数越少，那么能够抢占cpu的资源就越多，你的程序效率就越高

gevent模块

安装：pip3 install gevent

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

#或者上述两步合作一步：gevent.joinall([g1,g2])

g1.value#拿到func1的返回值

用法

gevent只有遇到IO操作才会发生切换,且IO必须是gevent类中的；

# 遇到IO自由切换
import gevent
def eat():  # 协程任务 协程函数
    print('eat start')
    gevent.sleep(1)
    print('eat end')

def sleep(): # 协程任务 协程函数
    print('strat sleep')
    gevent.sleep(1)
    print('end sleep')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(sleep)
# gevent.sleep(1)    # 只有遇到IO操作才会切换
# g1.join()  # 阻塞,直到g1任务执行完毕
# g2.join()  # 阻塞,直到g2任务执行完毕
gevent.joinall([g1,g2]) # 等于g1.join()+g2.join()

若想使用其他IO操作需要用from gevent import monkey;monkey.patch_all()  将IO打包 ；

rom gevent import monkey
monkey.patch_all()
import time
import gevent

def eat():    # 协程任务 协程函数
    print('start eating')
    time.sleep(1)
    print('end eating')

def sleep():  # 协程任务 协程函数
    print('start sleeping')
    time.sleep(1)
    print('end sleeping')

g1 = gevent.spawn(eat)   # 创建协程
g2 = gevent.spawn(sleep)
gevent.joinall([g1,g2])  # 阻塞 直到协程任务结束

# 请求网页
url_dic = {
    '协程':'http://www.cnblogs.com/Eva-J/articles/8324673.html',
    '线程':'http://www.cnblogs.com/Eva-J/articles/8306047.html',
    '目录':'https://www.cnblogs.com/Eva-J/p/7277026.html',
    '百度':'http://www.baidu.com',
    'sogou':'http://www.sogou.com',
    '4399':'http://www.4399.com',
    '豆瓣':'http://www.douban.com',
    'sina':'http://www.sina.com.cn',
    '淘宝':'http://www.taobao.com',
    'JD':'http://www.JD.com'
}

import time
from gevent import monkey;monkey.patch_all()
from urllib.request import urlopen
import gevent

def get_html(name,url):
    ret = urlopen(url)
    content = ret.read()
    with open(name,'wb') as f:
        f.write(content)

start = time.time()
for name in url_dic:
    get_html(name+'_sync.html',url_dic[name])
ret = time.time() - start
print('同步时间 :',ret)

start = time.time()
g_l = []
for name in url_dic:
    g = gevent.spawn(get_html,name+'_async.html',url_dic[name])
    g_l.append(g)
gevent.joinall(g_l)
ret = time.time() - start
print('异步时间 :',ret)

同步异步时间对比

 

协程实现socket server并发

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

sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()
def func(conn):
    # print(999)
    while True:
        msg = conn.recv(1024).decode('utf-8')
        print(msg)
        conn.send(b'hello')
while True:
    print(888)
    conn,addr = sk.accept()
    print(000)
    g = gevent.spawn(func, conn)
因为每次连接一个客户端都会进入循环，每次都会阻塞一次 所以才能继续往下执行

server