笔记-协程

笔记-Python-协程

 

1.      简介

协程（微线程，Coroutine）。

server的发展如下：

IO密集型应用: 多进程->多线程->事件驱动->协程

CPU密集型应用:多进程-->多线程

多进程对应多CPU，多线程对应多核CPU，事件驱动和协程则是充分挖掘单核能力。

异步事件驱动模型中，把会导致阻塞的操作转化为一个异步操作，主线程负责发起这个异步操作，并处理这个异步操作的结果。由于所有阻塞的操作都转化为异步操作，理论上主线程的大部分时间都是在处理实际的计算任务，少了多线程的调度时间，所以这种模型的性能通常会比较好。总的说来，当单核cpu性能提升，cpu不在成为性能瓶颈时，采用异步server能够简化编程模型，也能提高IO密集型应用的性能。

1.1.    协程优点

为什么要用协程?

效率，效率，效率，重要的事情说三遍！

为什么协程的效率高？

一个线程执行，没有线程切换开销；

因为只有一个线程，不需要多线程的锁机制；

2.      python的协程实现

python对协程的支持是通过generator来实现的。

def consumer():

    r = ''

    while True:

        n = yield r

        if not n:

            return

        print('[CONSUMER] Consuming %s...' % n)

        r = '200 OK'

 

def produce(c):

    c.send(None)

    n = 0

    while n < 5:

        n = n + 1

        print('[PRODUCER] Producing %s...' % n)

        r = c.send(n)

        print('[PRODUCER] Consumer return: %s' % r)

    c.close()

 

c = consumer()

produce(c)

 整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。

上面的例子中，整个过程没有锁的出现，还能保证数据安全，还可以控制顺序，优雅的实现了并发，甩多线程几条街

线程叫微进程，而协程又叫微线程。协程拥有自己的寄存器上下文和栈，因此能保留上一次调用的状态。

3.      gevent模块

Python环境下使用协程一般调用是gevent模块，其基本原理是：

当一个greenlet遇到IO操作时，就会自动切换到其他的greenlet,等IO操作完成，再切换回来，这样就保证了总有greenlet在运行，而不是等待。

3.1.    基本使用

import requests

import gevent

import time

def foo(url):

 

    response=requests.get(url)

    response_str=response.text

 

    print('get data %s'%len(response_str))

 

s=time.time()

gevent.joinall([gevent.spawn(foo,"https://itk.org/"),

                gevent.spawn(foo, "https://www.github.com/"),

                gevent.spawn(foo, "https://zhihu.com/"),])

 

# foo("https://itk.org/")

# foo("https://www.github.com/")

# foo("https://zhihu.com/")

print(time.time()-s)

3.2.    协程池：

from gevent.pool import Pool

pool = Pool(2)

g1 = pool.spwan(get_page,'www.baidu.com')

g2 = pool.spwan(get_page,'www.baidu2.com')

g3 = pool.spwan(get_page,'www.baidu3.com')

gevent.joinall([g1,g3,g2,])

print(g1.value,g2.value)

 

4.      进程，线程，协程的不同

1. 进程

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。

1. 线程

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。

1. 协程

协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

 

区别：

1. 进程多与线程比较

线程是指进程内的一个执行单元,也是进程内的可调度实体。线程与进程的区别:

1) 地址空间:线程是进程内的一个执行单元，进程内至少有一个线程，它们共享进程的地址空间，而进程有自己独立的地址空间

2) 资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源

3) 线程是处理器调度的基本单位,但进程不是

4) 二者均可并发执行

5) 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口，但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制

1. 协程多与线程进行比较

1) 一个线程可以多个协程，一个进程也可以单独拥有多个协程，这样python中则能使用多核CPU。

2) 线程进程都是同步机制，而协程则是异步

3) 协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态

 

6.对协程的理解

所有的改变都是有目的的！

一开始为了执行多任务，出现了并发，可以是多CPU并行，也可以是单CPU时间分片；

多任务会涉及到一个问题：切换。切换涉及到上下文，状态保存；为此，有了进程；

多进程对应多CPU，即并行；

 

多任务的基本面是处理能力远远超出需求，如果一个CPU只能满足基本使用要求，不会有多任务需求的出现；

那么新的问题是，CPU空跑，处理比I/O快，因此有了I/O阻塞，相似的还有时钟阻塞；

为解决CPU空跑，就要切换任务，进程切换开销比较高；怎么办，线程；

（当然减少人的等待时间也是多任务的目的，但是处理方法是相同的，多任务+切换任务）

 

在特定情况下切换线程还是开销太高。。。

如果时钟阻塞，线程切换功能不需要，在进程里写一个逻辑流调度，既可以利用到并发，又可以避免

反复系统调用，还有进程切换的开销，这就是用户态线程，分分钟给你上千个逻辑流；

 

从上面可以看到，实现一个用户态线程有两个必须处理的问题：一是阻塞式I/O，二是由于缺乏时钟阻塞，

进程需要自己有调度线程的能力。

如果一种实现使得每个线程需要自己通过调用某个方法，主动交出控制权。那么我们就称这种用户态线程

是协作式的，即协程。

本质上协程就是用户空间下的线程。

当然改变一般都是有代价的，上述每一步发展过程都有意味着通用性降低和稳定性降低。

5.      相关概念

异步编程：

IO模型：

进程，线程：

python yield语句：