协程

简介: 协程 协程:是单线程下的并发,又称微线程,纤程。英文名Coroutine。一句话说明什么是线程:协程是一种用户态的轻量级线程,即协程是由用户程序自己控制调度的。 对比操作系统控制线程的切换,用户在单线程内控制协程的切换 优点如下: #1.

协程

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

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

优点如下:

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

缺点如下:

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

总结协程特点:

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

greenlet   模块

import time
def func1():
    print(123)
    g2.switch()
    time.sleep(1)
    print('abc')

def func2():
    time.sleep(1)
    print(456)
    g1.switch()    
g1 = greenlet(func1)   # 实例化
g2 = greenlet(func2)   # 实例化
g1.switch() # 开始运行
在这个模块中,每当sleep的时候就模拟了程序遇到了I/O 这时候程序就自动切换switch 但是这个切换还是不够智能,只能是通过switch来切换

 

这时候我们就引用了另一个模块Gevent模块

一些用法

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的返回值

 

from gevent import monkey;monkey.patch_all()
# 它会把下面导入的所有的模块中的IO操作都打成一个包,gevent就能够认识这些IO了
import time
import gevent
# 使用gevent模块来执行多个函数,表示在这些函数遇到IO操作的时候可以在同一个线程中进行切换
# 利用其他任务的IO阻塞时间来切换到其他的任务继续执行
# spawn来发布协程任务
# join负责开启并等待任务执行结束
# gevent本身不认识其他模块中的IO操作,但是如果我们在导入其他模块之前执行from gevent import monkey;monkey.patch_all()
# gevent就能够认识在这句话之后导入的模块中的所有IO操作了
from threading import currentThread
def eat():
    print('eating1',currentThread())
    time.sleep(1)
    print('eating2')

def play():
    print('playing1',currentThread())
    time.sleep(1)
    print('playing2')
g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()   # start 且等待g执行完毕
g2.join()

 

 

# 协程 实际上 是一个线程
# 执行了多个任务 遇到IO就切换

from gevent import monkey;monkey.patch_all()
# 切换   yield greenlet
# 遇到IO gevent :检测到IO,能够使用greenlet实现自动切换
import time
import gevent

def func():
    print('eating')  # 执行
    time.sleep(0.1)   # 遇到IO
    print('eating2')
    time.sleep(0.1)
    print('eating3')
g = gevent.spawn(func)  # 协程任务开启
time.sleep(0.1)           # 阻塞 遇到IO
# g.join()                  # 阻塞 遇到IO
# 如果你开启一个协程,你的主线程中没有足够的时间让你执行协程的任务
# 内部执行switch的行文,能够保证你的协程不结束之前,主线程不结束
#打印结果为‘eating’
这段代码把join()注释掉也可以执行时因为在gevent这个模块中,主线程遇到了I/O阻塞了,所以会自动切换到协程中去,而到协程中打印了一个eating后又遇到阻塞,所以又切换到主线程,所以代码执行完毕。

 

目录
相关文章
|
4月前
|
存储 Java API
ntyco协程的理解
ntyco协程的理解
34 0
|
25天前
|
前端开发 程序员 调度
探索协程在 C++ 中的实现方式
探索协程在 C++ 中的实现方式
103 2
|
7月前
|
数据采集 缓存 调度
协程小练习
协程小练习
|
3月前
|
C++
C/C++协程学习笔记
C/C++协程学习笔记
|
3月前
|
存储 前端开发 rax
协程学习笔记
协程学习笔记
35 0
|
3月前
|
存储 前端开发 rax
协程学习笔记 NtyCo/libgo
协程学习笔记 NtyCo/libgo
33 0
|
5月前
|
存储 Ubuntu 调度
协程框架NtyCo的实现
协程框架NtyCo的实现
60 1
|
5月前
|
存储 关系型数据库 MySQL
协程框架nty_co
协程框架nty_co
|
10月前
|
数据采集 调度 开发者
协程这么好,那它能完全代替线程吗?
协程这么好,那它能完全代替线程吗?
116 0
协程这么好,那它能完全代替线程吗?
|
10月前
|
安全
c++20 协程(coroutine)
c++20 协程(coroutine)
171 0