生产者和消费者模型:

  1. #!/usr/bin/env python
  2. #coding:utf8
  3.  
  4. import threading,Queue
  5. import time
  6. import random
  7.  
  8. def producer(name,n):#生产者
  9. # while True:#无限循环生产包子
  10. time.sleep(random.randrange(3))#random生成一个3以内不包含3的随机数,通过随机数决定等待多长时间,主要便于测试
  11. if q.qsize()<4:#判断队列个数如果小于4程序继续往下执行,#包子剩余的个数如果小于4个才生产包子,避免浪费.每个厨师在生产包子都会看还剩余几个
  12. for i in range(2):#每个厨师生产2个包子上传到队列
  13. print '%s生产了[%d]个包子\n'%(name,n)
  14. q.put(n)
  15. q.join()#队列的个数为空则阻塞.#因为消费者每吃完一个包子都会告诉厨师,当所有包子都吃完厨师继续生产包子.#就是继续下一次循环
  16. print '包子已卖光了,[%d]'%q.qsize()
  17.  
  18. def consumer(name,n):#消费者
  19. while True:#无限循环吃包子
  20. print '%s 吃了[%d]个包子\n'%(name,n)
  21. q.get()#吃掉一个包子从队列减1
  22. time.sleep(1)#每个消费者吃掉一个包子的时候等待1
  23. q.task_done()#每个消费者吃掉一个包子通知队列(厨师)
  24.  
  25. if __name__=='__main__':
  26. q=Queue.Queue()
  27. c_name=['z1','z2','z3','z4']#4个消费者
  28. p_name=['p1','p2']#2个厨师
  29.  
  30. for name in p_name:
  31. p=threading.Thread(target=producer,args=[name,1,])#开启2个线程调用producer函数,#2个厨师同时生产包子
  32. p.start()#开启线程,线程的开关
  33.  
  34. for name in c_name:
  35. c=threading.Thread(target=consumer,args=[name,1,])#开启4个线程调用consumer函数,#4个消费者同时吃包子
  36. c.start()#开启线程,线程的开关

执行结果:

  1.  

p1生产了[1]个包子

p1生产了[1]个包子

z1 吃了[1]个包子

z4 吃了[1]个包子
z1 吃了[1]个包子

包子已卖光了,[0]

协程

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

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

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

协程的好处:

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

缺点:

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

使用yield实现协程操作例子    

  1. import time
  2. import queue
  3. def consumer(name):
  4. print("--->starting eating baozi...")
  5. while True:
  6. new_baozi = yield
  7. print("[%s] is eating baozi %s" % (name,new_baozi))
  8. #time.sleep(1)
  9.  
  10. def producer():
  11.  
  12. r = con.__next__()
  13. r = con2.__next__()
  14. n = 0
  15. while n < 5:
  16. n +=1
  17. con.send(n)
  18. con2.send(n)
  19. print("\033[32;1m[producer]\033[0m is making baozi %s" %n )
  20.  
  21. if __name__ == '__main__':
  22. con = consumer("c1")
  23. con2 = consumer("c2")
  24. p = producer()

Greenlet

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3.  
  4. from greenlet import greenlet
  5.  
  6. def test1():
  7. print 12
  8. gr2.switch()
  9. print 34
  10. gr2.switch()
  11.  
  12. def test2():
  13. print 56
  14. gr1.switch()
  15. print 78
  16.  
  17. gr1 = greenlet(test1)
  18. gr2 = greenlet(test2)
  19. gr1.switch()

  

Gevent

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

  1. import gevent
  2.  
  3. def foo():
  4. print('Running in foo')
  5. gevent.sleep(0)
  6. print('Explicit context switch to foo again')
  7.  
  8. def bar():
  9. print('Explicit context to bar')
  10. gevent.sleep(0)
  11. print('Implicit context switch back to bar')
  12.  
  13. gevent.joinall([
  14. gevent.spawn(foo),
  15. gevent.spawn(bar),
  16. ])

输出:

  1. Running in foo
  2. Explicit context to bar
  3. Explicit context switch to foo again
  4. Implicit context switch back to bar

同步与异步的性能区别 

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

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

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

  1. from gevent import monkey; monkey.patch_all()
  2. import gevent
  3. from urllib.request import urlopen
  4.  
  5. def f(url):
  6. print('GET: %s' % url)
  7. resp = urlopen(url)
  8. data = resp.read()
  9. print('%d bytes received from %s.' % (len(data), url))
  10.  
  11. gevent.joinall([
  12. gevent.spawn(f, 'https://www.python.org/'),
  13. gevent.spawn(f, 'https://www.yahoo.com/'),
  14. gevent.spawn(f, 'https://github.com/'),
  15. ])

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

server side 

  1. import sys
  2. import socket
  3. import time
  4. import gevent
  5.  
  6. from gevent import socket,monkey
  7. monkey.patch_all()
  8. def server(port):
  9. s = socket.socket()
  10. s.bind(('0.0.0.0', port))
  11. s.listen(500)
  12. while True:
  13. cli, addr = s.accept()
  14. gevent.spawn(handle_request, cli)
  15. def handle_request(s):
  16. try:
  17. while True:
  18. data = s.recv(1024)
  19. print("recv:", data)
  20. s.send(data)
  21. if not data:
  22. s.shutdown(socket.SHUT_WR)
  23.  
  24. except Exception as ex:
  25. print(ex)
  26. finally:
  27.  
  28. s.close()
  29. if __name__ == '__main__':
  30. server(8001)

client side   

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

  

论事件驱动与异步IO

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

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

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

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

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

当我们面对如下的环境时,事件驱动模型通常是一个好的选择:

  1. 程序中有许多任务,而且…
  2. 任务之间高度独立(因此它们不需要互相通信,或者等待彼此)而且…
  3. 在等待事件到来时,某些任务会阻塞。

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

网络应用程序通常都有上述这些特点,这使得它们能够很好的契合事件驱动编程模型。

select-server端代码:

  1. #!/usr/bin/env python
  2. #coding:utf8
  3. import select
  4. import socket
  5. import time
  6. import sys
  7.  
  8. import Queue#用于存放客服端发送过来的消息
  9.  
  10. server_ip=('0.0.0.0',9003)#定义元组,服务器IP,端口
  11. sk=socket.socket()#实例化socket模块的socket类创建一个对象为sk
  12. sk.bind(server_ip)#调用sk对象中的bind方法,传入参数.绑定IP和端口
  13. sk.listen(20)#server端允许的最大连接数
  14. sk.setblocking(False)#遇到IO的时候不阻塞
  15. inputs=[sk,]#定义一个列表存放服务端和客服端socket对象
  16. outputs=[]#定义一个列表存放客服端socket对象
  17. message={}#定义一个字典存放"{客服端socket对象:队列}",队列中是放的客服端发送过来的消息
  18.  
  19. while True:
  20. """
  21. select一共可以设置4个参数
  22. rList=inputs=[sk,客服端socket对象]
  23. wList=outputs[客服端socket对象]
  24. 第三个参数异常信息
  25. 第四个参数是超时时间,如果客服端没有连接server端,0.5秒超时,程序会继续往下执行
  26. 程序第一次启动的时候 rList=sk 感知server的变化,只有客服端连接过来server才会变化
  27. 如果客服端已经连接进来此时 inputs列表中至少存在2个元素 server的socket对象和client端的socket对象,select会遍历列表中的每一个元素并感知时候是否有变化
  28. 如果有变化那么满足条件select不会阻塞程序继续向下执行
  29. 如果select感知到rList发生变化,比如客服端给服务端发送消息,程序向下执行
  30. """
  31. rList,wList,error=select.select(inputs,outputs,inputs)#读,写,错误,超时时间
  32. #客服端连接过来,rList [<socket._socketobject object at 0x101445750>]
  33. for r in rList:
  34. #如果rList有变化进入for循环,判断r == <socket._socketobject object at 0x101445750>
  35. if r == sk:#
  36. conn,address=r.accept()#监听客服端socket对象
  37. inputs.append(conn)#把客服端socket对象放入inputs列表中
  38. message[conn]=Queue.Queue()#message={socket对象:队列}
  39. print address#打印客服端IP
  40. ####注视中客服端连接指的是客服端socket对象#####
  41. else:
  42. #如果r==客服端连接,前提条件是已经感知到客服端socket对象发生变化,程序才会执行到此处
  43. #监听客服端发送过来的数据
  44. data=r.recv(1024)
  45. if data:
  46. #如果有数据把客服端socket对象放入outputs列表中让select感知wList的变化,也就是感知客服端是否发送过来消息,用于读写分离
  47. print data #打印客服端发送过来的消息
  48. outputs.append(r)#把客服端连接添加到outputs列表
  49. message[r].put(data)#message[客服端连接].put(接受的数据), message{客服端socket对象:客服端发送过来的消息上次到队列}
  50. else:
  51. inputs.remove(r)#如果客服端异常断开,删除inputs列表中客服端socket对象
  52. del message[w]#如果客服端异常断开,删除message字典中客服端socket对象和客服端的消息队列
  53. #客服端异常断开的时候会发送空数据,此时在inputs列表中删除客服端连接
  54.  
  55. for w in wList:
  56. #select遍历wList的时候感知到了变化,也就是服务端已经接受到客服端已经发送过来的消息了
  57. try:
  58. data=message[w].get_nowait()#message[客服端socket对象]获取到消息队列,最后得到发送过来的消息,get_nowait如果从队列中没有获取到数据也不会阻塞
  59. w.sendall(data)#发送数据给客服端
  60. #给客服端发送数据
  61. except Queue.Empty as e:#捕捉队列是否为空
  62. if message[w]:
  63. del message[w]#删除message字典中客服端socket对象和客服端的消息队列
  64. outputs.remove(w)#删除outputs列表中客服端socket对象
  65. #删除客服端连接

select-client端代码:

  1. import socket
  2.  
  3. server_ip=('127.0.0.1', 9003)
  4. sk=socket.socket()
  5. sk.connect(server_ip)
  6.  
  7. while True:
  8. data=raw_input('Please:').strip()
  9. if len(data) ==0:continue
  10. sk.sendall(data)
  11. server_response=sk.recv(1024)
  12. print server_response

day9-协程的更多相关文章

  1. 什么是协程?与线程和进程对比优劣在哪?gevent协程示例代码

      协程 协程,又称微线程,纤程.英文名Coroutine..一句话说明什么是线程:协程是一种用户态的轻量级线程. 协程拥有自己的寄存器上下文和栈.协程调度切换时,将寄存器上下文和栈保存到其他地方,在 ...

  2. Python之路,Day9 - 线程、进程、协程和IO多路复用

    参考博客: 线程.进程.协程: http://www.cnblogs.com/wupeiqi/articles/5040827.html http://www.cnblogs.com/alex3714 ...

  3. python协程和yeild

    python多线程其实在操作系统级别是进程,因为在执行时,默认加了一个全局解释器锁(GIL),python的多线程,本质还是串行的,无法利用多核的优势:在java和C# 中,多线程是并发的,可以充分利 ...

  4. Day10 - Python协程、异步IO、redis缓存、rabbitMQ队列

    Python之路,Day9 - 异步IO\数据库\队列\缓存   本节内容 Gevent协程 Select\Poll\Epoll异步IO与事件驱动 Python连接Mysql数据库操作 RabbitM ...

  5. day30 网络编程 之进程,线程,协程

    进程点进去 线程点进去 协程点进去 什么是进程 进程(有时称为重量级进程)是一个执行中的程序.每个进程都拥有自己的地址空间.内存.数据栈以及其他用于跟踪执行的辅助数据.同一个程序执行两次,属于是两个不 ...

  6. Python_oldboy_自动化运维之路_线程,进程,协程(十一)

    本节内容: 线程 进程 协程 IO多路复用 自定义异步非阻塞的框架 线程和进程的介绍: 举个例子,拿甄嬛传举列线程和进程的关系: 总结:1.工作最小单元是线程,进程说白了就是提供资源的 2.一个应用程 ...

  7. python2.0_s12_day9_协程&Gevent协程

    Python之路,Day9 - 异步IO\数据库\队列\缓存 本节内容 Gevent协程 Select\Poll\Epoll异步IO与事件驱动 Python连接Mysql数据库操作 协程 1.协程,又 ...

  8. 异步IO/协程/数据库/队列/缓存(转)

    原文:Python之路,Day9 - 异步IO\数据库\队列\缓存 作者:金角大王Alex add by zhj: 文章很长 引子 到目前为止,我们已经学了网络并发编程的2个套路, 多进程,多线程,这 ...

  9. Python(八)进程、线程、协程篇

    本章内容: 线程(线程锁.threading.Event.queue 队列.生产者消费者模型.自定义线程池) 进程(数据共享.进程池) 协程 线程 Threading用于提供线程相关的操作.线程是应用 ...

  10. Lua的协程和协程库详解

    我们首先介绍一下什么是协程.然后详细介绍一下coroutine库,然后介绍一下协程的简单用法,最后介绍一下协程的复杂用法. 一.协程是什么? (1)线程 首先复习一下多线程.我们都知道线程——Thre ...

随机推荐

  1. CSS3新特性学习

    1.一些实用规范:盒子模型,列表模块,超链接方式,语言模块,背景和边框,文字特效,多栏布局: 2:新增的选择器selctor eg: 1) 子元素过滤伪类:div:first-child  (自动识别 ...

  2. js日期时间计算天数

    var stime = new Date('2016-03-14'); //开始时间 var etime = new Date('2016-03-20'); //结束时间 var times = et ...

  3. webStorm 多个项目并存

    点击file ->settings ->Directories 然后右侧有个Add Content Root 添加某个Root即可看见该root下的所有项目

  4. c# 引用百度地图

    <script type="text/javascript"> //创建和初始化地图函数 var map = new BMap.Map("home" ...

  5. php 斐波那契数列

    function fib($n) { $cur = 1; $prev = 0; for ($i = 0; $i < $n; $i++) { yield $cur; $temp = $cur; $ ...

  6. Dos学习笔记(3)attrib命令

    今天和昨天一直在摸索这个命令觉得这个命令为什么改变不了文件夹的属性, 因为我试着用attrib +r /s 去修改子文件夹的时候发现没用,然后如果输入 attrib +r /d 又提示说/d需要和/s ...

  7. 收藏:Linux系统信息查看命令大全

    系统# uname -a               # 查看内核/操作系统/CPU信息# head -n 1 /etc/issue   # 查看操作系统版本# cat /proc/cpuinfo  ...

  8. centos 6 cglib

    Error: Package: glibc-2.12-1.166.el6_7.3.i686 (@ultra-centos-6.7-updates) Requires: glibc-common = 2 ...

  9. install google chrome

    32bit: wget https://dl.google.com/linux/direct/google-chrome-stable_current_i386.deb sudo dpkg -i go ...

  10. Xcode LLDB Debug教程

    开胃小菜--简单的断点调试 在xcode中打开一个app,在想要break的行号上单击,即可生成一个深色的箭头标识--断点.如下图,在viewDidLoad:中设置了断点. 运行app,等待...就可 ...