Python (九) 协程以及数据库操做

时间 2020-05-15

标签 python 以及数据库栏目 Python 繁體版

原文原文链接

本节内容html

Gevent协程
Select\Poll\Epoll异步IO与事件驱动
Python链接Mysql数据库操作
Paramiko SSH

协程

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

协程拥有本身的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其余地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。所以：程序员

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

协程的好处：数据库

无需线程上下文切换的开销
无需原子操做锁定及同步的开销
方便切换控制流，简化编程模型
高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。因此很适合用于高并发处理。

缺点：编程

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

使用yield实现协程操做例子　　　　数组

 
         import 
         time 
        
         import 
         queue 
        
         def 
         consumer(name): 
        
         print 
         ( 
         "--->starting eating baozi..." 
         ) 
        
         while 
         True 
         : 
        
         new_baozi  
         = 
         yield 
        
         print 
         ( 
         "[%s] is eating baozi %s" 
         % 
         (name,new_baozi)) 
        
         #time.sleep(1) 
        
         def 
         producer(): 
        
         r  
         = 
         con.__next__() 
        
         r  
         = 
         con2.__next__() 
        
         n  
         = 
         0 
        
         while 
         n <  
         5 
         : 
        
         n  
         + 
         = 
         1 
        
         con.send(n) 
        
         con2.send(n) 
        
         print 
         ( 
         "\033[32;1m[producer]\033[0m is making baozi %s" 
         % 
         n ) 
        
         if 
         __name__  
         = 
         = 
         '__main__' 
         : 
        
         con  
         = 
         consumer( 
         "c1" 
         ) 
        
         con2  
         = 
         consumer( 
         "c2" 
         ) 
        
         p  
         = 
         producer()

Greenlet

 
         #!/usr/bin/env python 
        
         # -*- coding:utf-8 -*- 
        
         from 
         greenlet  
         import 
         greenlet 
        
         def 
         test1(): 
        
         print 
         12 
        
         gr2.switch() 
        
         print 
         34 
        
         gr2.switch() 
        
         def 
         test2(): 
        
         print 
         56 
        
         gr1.switch() 
        
         print 
         78 
        
         gr1  
         = 
         greenlet(test1) 
        
         gr2  
         = 
         greenlet(test2) 
        
         gr1.switch()

Gevent

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

 
         import 
         gevent 
        
         def 
         foo(): 
        
         print 
         ( 
         'Running in foo' 
         ) 
        
         gevent.sleep( 
         0 
         ) 
        
         print 
         ( 
         'Explicit context switch to foo again' 
         ) 
        
         def 
         bar(): 
        
         print 
         ( 
         'Explicit context to bar' 
         ) 
        
         gevent.sleep( 
         0 
         ) 
        
         print 
         ( 
         'Implicit context switch back to bar' 
         ) 
        
         gevent.joinall([ 
        
         gevent.spawn(foo), 
        
         gevent.spawn(bar), 
        
         ])

输出：网络

Running in foo Explicit context to bar Explicit context switch to foo again Implicit context switch back to bar

同步与异步的性能区别 多线程

上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数，后者阻塞当前流程，并执行全部给定的greenlet。执行流程只会在全部greenlet执行完后才会继续向下走。　　

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

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

server side

client side 　　

论事件驱动与异步IO

事件驱动编程是一种编程范式，这里程序的执行流由外部事件来决定。它的特色是包含一个事件循环，当外部事件发生时使用回调机制来触发相应的处理。另外两种常见的编程范式是（单线程）同步以及多线程编程。

让咱们用例子来比较和对比一下单线程、多线程以及事件驱动编程模型。下图展现了随着时间的推移，这三种模式下程序所作的工做。这个程序有3个任务须要完成，每一个任务都在等待I/O操做时阻塞自身。阻塞在I/O操做上所花费的时间已经用灰色框标示出来了。

在单线程同步模型中，任务按照顺序执行。若是某个任务由于I/O而阻塞，其余全部的任务都必须等待，直到它完成以后它们才能依次执行。这种明确的执行顺序和串行化处理的行为是很容易推断得出的。若是任务之间并无互相依赖的关系，但仍然须要互相等待的话这就使得程序没必要要的下降了运行速度。

在多线程版本中，这3个任务分别在独立的线程中执行。这些线程由操做系统来管理，在多处理器系统上能够并行处理，或者在单处理器系统上交错执行。这使得当某个线程阻塞在某个资源的同时其余线程得以继续执行。与完成相似功能的同步程序相比，这种方式更有效率，但程序员必须写代码来保护共享资源，防止其被多个线程同时访问。多线程程序更加难以推断，由于这类程序不得不经过线程同步机制如锁、可重入函数、线程局部存储或者其余机制来处理线程安全问题，若是实现不当就会致使出现微妙且使人痛不欲生的bug。

在事件驱动版本的程序中，3个任务交错执行，但仍然在一个单独的线程控制中。当处理I/O或者其余昂贵的操做时，注册一个回调到事件循环中，而后当 I/O操做完成时继续执行。回调描述了该如何处理某个事件。事件循环轮询全部的事件，当事件到来时将它们分配给等待处理事件的回调函数。这种方式让程序尽可能的得以执行而不须要用到额外的线程。事件驱动型程序比多线程程序更容易推断出行为，由于程序员不须要关心线程安全问题。

当咱们面对以下的环境时，事件驱动模型一般是一个好的选择：

程序中有许多任务，并且…
任务之间高度独立（所以它们不须要互相通讯，或者等待彼此）并且…
在等待事件到来时，某些任务会阻塞。

当应用程序须要在任务间共享可变的数据时，这也是一个不错的选择，由于这里不须要采用同步处理。

网络应用程序一般都有上述这些特色，这使得它们可以很好的契合事件驱动编程模型。

Select\Poll\Epoll异步IO　

selectors模块

This module allows high-level and efficient I/O multiplexing, built upon the select module primitives. Users are encouraged to use this module instead, unless they want precise control over the OS-level primitives used.

 
         import 
         selectors 
        
         import 
         socket 
        
         sel  
         = 
         selectors.DefaultSelector() 
        
         def 
         accept(sock, mask): 
        
         conn, addr  
         = 
         sock.accept()   
         # Should be ready 
        
         print 
         ( 
         'accepted' 
         , conn,  
         'from' 
         , addr) 
        
         conn.setblocking( 
         False 
         ) 
        
         sel.register(conn, selectors.EVENT_READ, read) 
        
         def 
         read(conn, mask): 
        
         data  
         = 
         conn.recv( 
         1000 
         )   
         # Should be ready 
        
         if 
         data: 
        
         print 
         ( 
         'echoing' 
         ,  
         repr 
         (data),  
         'to' 
         , conn) 
        
         conn.send(data)   
         # Hope it won't block 
        
         else 
         : 
        
         print 
         ( 
         'closing' 
         , conn) 
        
         sel.unregister(conn) 
        
         conn.close() 
        
         sock  
         = 
         socket.socket() 
        
         sock.bind(( 
         'localhost' 
         ,  
         10000 
         )) 
        
         sock.listen( 
         100 
         ) 
        
         sock.setblocking( 
         False 
         ) 
        
         sel.register(sock, selectors.EVENT_READ, accept) 
        
         while 
         True 
         : 
        
         events  
         = 
         sel.select() 
        
         for 
         key, mask  
         in 
         events: 
        
         callback  
         = 
         key.data 
        
         callback(key.fileobj, mask)