协程

 

协程，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程。

在单线程实现并发的效果就是协程，yield,线程之间上下文切换是在cpu寄存器中。

 

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

 

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

 

 协程不需要锁，因为它是在一个线程里实现的

协程的好处：

  • 无需线程上下文切换的开销
  • 无需原子操作锁定及同步的开销方便切换控制流，简化编程模型
  • "原子操作(atomic operation)是不需要synchronized"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。
  • 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

 缺点：

  • 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
  • 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

使用yield实现协程操作例子　

# -*-coding:utf-8-*-
# Author:sunhao
import time
def consumer(name):
    print("%s准备吃包子了"%name)
    while True:
        baozi=yield

        print('包子[%s]来了，被%s吃了'%(baozi,name))


# c1=consumer('lily')
# c1.__next__()
#
# c1.send('韭菜')

def producer(name):
    c=consumer('A')
    c2=consumer('B')
    c.__next__()
    c2.__next__()
    print('%s开始做包子了'%name)
    for i in range(10):
        time.sleep(1)
        print('做了两个包子')
        c.send(i)
        c2.send(i)
        time.sleep(1)

producer('Tom')
yield实现多并发

协程必须符合以下条件：

  1. 必须在只有一个单线程里实现并发
  2. 修改共享数据不需加锁
  3. 用户程序里自己保存多个控制流的上下文栈
  4. 一个协程遇到IO操作自动切换到其它协程

 

Greenlet

greenlet是封装好了的协程

# -*-coding:utf-8-*-
# Author:sunhao

import greenlet

def test1():
    print(12)
    gr2.switch()
    print(34)
    gr2.switch()


def test2():
    print(56)
    gr1.switch()
    print(78)



gr1 = greenlet.greenlet(test1)  # 启动一个协程

gr2=greenlet.greenlet(test2)

gr1.switch()
手动切换IO操作

 

Gevent

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

# -*-coding:utf-8-*-
# Author:sunhao

import gevent


def func1():
    print('\033[31;1m李闯在跟海涛搞...\033[0m')
    gevent.sleep(2)
    print('\033[31;1m李闯又回去跟继续跟海涛搞...\033[0m')


def func2():
    print('\033[32;1m李闯切换到了跟海龙搞...\033[0m')
    gevent.sleep(1)
    print('\033[32;1m李闯搞完了海涛，回来继续跟海龙搞...\033[0m')


gevent.joinall([
    gevent.spawn(func1),
    gevent.spawn(func2),

])
gevent IO切换

 遇到IO阻塞时会自动切换任务 

# -*-coding:utf-8-*-
# Author:sunhao

import urllib,gevent,time

from urllib import request
from gevent import monkey


monkey.patch_all() # 把当前程序的所有的IO操作给单独的做上标记

def f(url):
    print('GET: %s' % url)
    resp = request.urlopen(url)
    data = resp.read()
    f=open('url.html','wb')
    f.write(data)
    f.close()
    print('%d bytes received from %s.' % (len(data), url))

time_start=time.time()

gevent.joinall([
    gevent.spawn(f, 'https://www.python.org/'),
    gevent.spawn(f, 'https://www.yahoo.com/'),
    gevent.spawn(f, 'http://www.cnblogs.com/alex3714/articles/5248247.html'),
])

print("time：",(time.time()-time_start))
爬虫

通过gevent实现单线程下的多socket并发 

# -*-coding:utf-8-*-
# Author:sunhao

import gevent,time,socket

from gevent import monkey

monkey.patch_all()


def server(port):

    s=socket.socket()
    s.bind(('127.0.0.1',port))

    s.listen(5)
    while True:

        conn,addr=s.accept()
        gevent.spawn(handle_request,conn)

def handle_request(conn):

    try:
        while True:

            data=conn.recv(1024)
            print("recv:",data)
            conn.send(data)
            if not data:
                conn.shutdown(socket.SHUT_WR)

    except Exception as e:
        print(e)

    finally:
        conn.close()


if __name__ == '__main__':
    server(8001)
socket多并发