python之协程

简介:

  协程,又称微线程,纤程。英文名Coroutine。协程是一种用户态的轻量级线程。

  所谓用户态就是说协程是由用户来控制的,CPU不认识协程,协程是跑在线程中的。

  协程拥有自己的寄存器上下文栈。协程调试切换时,将寄存器上下文栈保存到其他地方,在切回来时,恢复先前保存的寄存器上下文栈。

  因此,协程能保留上一次调用时的状态(即所有局部状态的一个特定组合),每次过程重入时,就相当于进入上一次调用的状态,也就是进入上一次离开时所处逻辑流的位置。

  线程切换时会将上下文和栈保存到CPU的寄存器中。


  协程的标准定义,即符合以下所有条件就能称之为协程

  1.在单线程里实现并发

  2.修改共享数据不需要加锁

  3.用户程序里自己保存多个控制流的上下文栈

  4.一个协程遇到IO操作自动切换到其它协程


  协程的好处:

  无需线程上下文切换的开销

  无需原子操作锁定及同步的开销

    原子操作是指不会被线程调度机制打断的操作;这种操作一旦开始,就一直运行到结束

  方便切换控制流,简化编程模型

  高并发+高扩展性+低成本:一个CPU支持上万的协程都行,很适合用于高并发处理

  协程的缺点:

  无法利用多核资源:

    协程的本质是个单线程,它不能同时将单个CPU的多个核用上

    协程需要和进程配合才能运行在多CPU上。

  进行阻塞(Blocking)操作(如IO)时会阻塞掉整个程序


  使用yield实现协程的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/python
#Author:sean
 
import  time
 
def  consumer(name):
     print ( "--->start eating baozi..." )
     while  True :
         new_baozi  =  yield
         print ( "[%s] is eating baozi %s" %  (name,new_baozi))
         # time.sleep(2)
def  producter():
     =  tom.__next__()
     =  jerry.__next__()
     =  0
     while  n <  5 :
         + =  1
         tom.send(n)
         jerry.send(n)
         print ( "\033[32;1m[producter]\033[0m is making baozi %s" %  n)
 
if  __name__  = =  '__main__' :
     tom  =  consumer( "tom" )
     jerry  =  consumer( "jerry" )
     =  producter()


  如何在单线程下实现并发效果?

  答案是遇到IO操作就切换,因为IO操作耗时比较长


  协程之所以能处理高并发,其实就是把IO操作给干掉了,就是一遇到IO操作就切换。

  这样的话整个程序就变成了只有CPU在运算。

  一遇到IO操作就切换,那么到底什么时候再切回去呢?

  答案是当IO操作结束后就切回去。

  那么问题又来了,python怎么来监测IO操作是否结束呢?带着这个问题先来看看几个例子


  greenlet模块:

    greenlet是一个封装好的协程,通过switch方法手动进行切换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python
#Author:sean
 
from  greenlet  import  greenlet
 
def  func1():
     print ( "haha11" )
     gr2.switch()
     print ( "haha22" )
     gr2.switch()
 
def  func2():
     print ( "haha33" )
     gr1.switch()
     print ( "haha44" )
 
gr1  =  greenlet(func1)
gr2  =  greenlet(func2)
gr1.switch()

  gevent模块:

    gevent是一个第三方库,可以轻松实现并发同步或异步编程。

    在gevent中用到的主要是greenlet,它是以C扩展模式形式接入python的轻量级协程。

    greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度

    gevent能够自动进行IO切换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python
#Author:sean
 
import  gevent
 
def  foo():
     print ( "Running in foo" )
     gevent.sleep( 0 #模仿IO操作
     print ( 'Explicit context switch to foo again' )
 
def  bar():
     print ( 'Explicit context to bar' )
     gevent.sleep( 0 #模仿IO操作
     print ( 'Implicit context switch back to bar' )
 
gevent.joinall([
     gevent.spawn(foo),
     gevent.spawn(bar)
])

  同步与异步的区别:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/python
#Author:sean
 
import  gevent
 
def  task(pid):
     """
     Some non-deterministic task
     """
     gevent.sleep( 0.5 )
     print ( 'Task %s done'  %  pid)
 
def  synchronous():
     for  in  range ( 1 10 ):
         task(i)
 
def  asynchronous():
     threads  =  [gevent.spawn(task, i)  for  in  range ( 10 )]
     gevent.joinall(threads)
 
print ( 'Synchronous:' )
synchronous()
 
print ( 'Asynchronous:' )
asynchronous()

  用协程并发爬虫爬取网站:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/python
#Author:sean
 
from  urllib  import  request
import  gevent
#默认情况下,gevent并不知道urllib或者socket什么时候进行了IO操作
#默认情况下,gevent和urllib以及socket并没有任何关联,当然就无法提高效率,因为其实质上还是串行操作
#要想让gevent知道urllib或socket正在进行IO操作,需要给gevent打个补丁
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))
 
gevent.joinall([
     gevent.spawn(f, 'https://www.python.org' ),
     gevent.spawn(f, 'https://yahoo.com' ),
     gevent.spawn(f, 'https://github.com' )
])

  用gevent协程写一个单线程高并发的socket:

  服务端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/usr/bin/python
#Author:sean
 
import  sys
import  socket
import  time
import  gevent
 
from  gevent  import  socket,monkey
monkey.patch_all()   #把当前程序的所有IO操作单独做上标记
 
def  server(host,port):
     =  socket.socket()
     s.bind((host,port))
     s.listen( 500 )
     while  True :
         cli,addr  =  s.accept()
         gevent.spawn(handle_request,cli)
 
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( '0.0.0.0' , 8001 )

  客户端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/python
#Author:sean
 
import  socket
 
HOST  =  'localhost'   #The remote host
PORT  =  8001  #The same port as used by the server
=  socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect((HOST,PORT))
while  True :
     msg  =  bytes( input ( ">>:" ),encoding = "utf-8" )
     s.sendall(msg)
     data  =  s.recv( 1024 )
     print ( 'Received' , repr (data))
s.close()

 并发100个sock连接:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/python
#Author:sean
 
import  socket
import  threading
 
def  sock_conn():
     client  =  socket.socket()
     client.connect(( "localhost" , 8001 ))
     count  =  0
     while  True :
         #msg = input(">>:").strip()
         #if len(msg) == 0:continue
         client.send( ( "hello %s"  % count).encode( "utf-8" ))
         data  =  client.recv( 1024 )
         print ( "[%s]recv from server:"  %  threading.get_ident(),data.decode())  #结果
         count  + = 1
     client.close()
 
for  in  range ( 100 ):
     =  threading.Thread(target = sock_conn)
     t.start()


  事件驱动与异步IO请往这走


  现在我们可以来回答下这个问题了,python如何监测IO操作是否结束?

  IO操作是由操作系统进行处理的,当遇到IO操作时就切换

  等IO操作完以后让其调用回调函数,回调函数会通知协程说这个IO操作完成了










本文转自 忘情OK  51CTO博客,原文链接:http://blog.51cto.com/itchentao/1895251,如需转载请自行联系原作者
目录
相关文章
|
1月前
|
并行计算 调度 开发者
深入浅出Python协程:提升你的异步编程效率
在当今快速发展的软件开发领域,异步编程已成为提高程序性能和用户体验的关键技术。Python,作为一门广泛使用的高级编程语言,其协程(Coroutine)功能为开发者提供了强大的异步编程工具。本文将从协程的基本概念入手,通过实例深入浅出地讲解如何在Python中有效利用协程来提升异步编程的效率和可读性。我们将探讨协程的工作原理、与传统多线程/多进程相比的优势,以及如何在实际项目中应用协程来解决复杂的并发问题。通过本文的学习,读者将能够掌握Python协程的核心知识,为构建高效、可维护的异步应用奠定坚实基础。
|
1天前
|
调度 Python
Python多线程、多进程与协程面试题解析
【4月更文挑战第14天】Python并发编程涉及多线程、多进程和协程。面试中,对这些概念的理解和应用是评估候选人的重要标准。本文介绍了它们的基础知识、常见问题和应对策略。多线程在同一进程中并发执行,多进程通过进程间通信实现并发,协程则使用`asyncio`进行轻量级线程控制。面试常遇到的问题包括并发并行混淆、GIL影响多线程性能、进程间通信不当和协程异步IO理解不清。要掌握并发模型,需明确其适用场景,理解GIL、进程间通信和协程调度机制。
8 0
|
22天前
|
API 数据处理 调度
Python中的异步编程与协程应用
传统的Python编程在处理IO密集型任务时常常面临效率低下的问题,而异步编程和协程技术的引入为解决这一问题提供了有效的途径。本文将介绍Python中异步编程的基本概念,深入探讨asyncio库的使用以及协程在实际项目中的应用,旨在帮助开发者更好地理解和运用异步编程技术。
|
1月前
|
调度 Python
python协程—asyncio模块
python协程—asyncio模块
20 0
|
1月前
|
API 开发者 Python
深入浅出Python协程:提升并发编程效率
在当今高速发展的互联网时代,高并发成为了软件开发中的一个重要需求。本文将引领读者深入理解Python中的协程(Coroutine)概念,探讨其在并发编程中的应用及优势。我们将从协程的基础概念出发,通过实例讲解如何使用asyncio库来编写高效的异步代码。文章旨在帮助读者掌握协程的工作原理和使用方法,从而在实际开发中能够更好地利用Python进行高效的并发编程。
|
1月前
|
数据采集 调度 开发者
深入浅出Python协程:提升并发编程效率
本文旨在为读者揭开Python协程的神秘面纱,通过深入浅出的方式阐述其工作原理及应用场景。不同于传统的技术文章摘要,我们将以一种独特的视角,将协程比作一场精心编排的交响乐,其中每一个乐章都是一个独立的任务,共同演绎出并发编程的华丽篇章。文章将从协程的基本概念切入,通过对比线程和进程,逐步深入到事件循环、异步IO等核心机制,最后通过案例分析,让读者能够掌握使用Python协程处理高并发任务的技巧,从而提升编程效率。
|
1月前
|
程序员 开发者 Python
深入浅出Python协程:提升代码效率的秘诀
【2月更文挑战第12天】 在当今追求高效编程的时代,Python协程成为了开发者提升代码执行效率的重要工具。本文将以通俗易懂的方式,深入探讨Python协程的原理、使用方法及其在实际开发中的应用场景。通过对比传统同步编程和异步编程的差异,我们将揭示协程如何在不牺牲代码可读性的前提下,显著提高程序的运行效率。文章旨在为Python开发者提供一份全面、实用的协程学习指南,帮助他们在实际项目中更好地利用这一强大的特性。
22 2
|
2月前
|
调度 Python
什么是Python中的协程(Coroutine)?如何使用`async`和`await`进行协程编程?
什么是Python中的协程(Coroutine)?如何使用`async`和`await`进行协程编程?
26 0
|
2月前
|
程序员 Python
Python并发编程之协程与多线程对比分析
本文通过对Python中协程和多线程的特点、优缺点以及适用场景进行深入比较分析,帮助读者更好地理解并发编程中不同技术方案的选择与应用。
|
2月前
|
Java 调度 Python
python协程
我们知道线程的提出是为了能够在多核cpu的情况下,达到并行的目的。而且线程的执行完全是操作系统控制的。而协程(Coroutine)是线程下的,控制权在于用户,本质是为了能让多组过程能不独自占用完所有资源,在一个线程内交叉执行,达到高并发的目的。【2月更文挑战第4天】
37 1