python2.0_s12_day9_协程&Gevent协程

 1 　　
 2             #!/usr/bin/env python3.5
 3             #__author__:ted.zhou
 4             ‘‘‘
 5             使用yield实现协程的例子
 6             ‘‘‘
 7             import time
 8             import queue
 9             def consumer(name):
10                 print("--->starting eating baozi...")
11                 while True:
12                     new_baozi = yield
13                     print("[%s] is eating baozi %s" % (name,new_baozi))
14                     #time.sleep(1)
15 
16             def producer():
17 
18                 r = con.__next__()  # python3.0里变成__next__(),python2.0是next()
19                 r = con2.__next__()
20                 n = 0
21                 while n < 5:
22                     time.sleep(1) # 模拟阻塞1秒
23                     n +=1
24                     con.send(n)
25                     con2.send(n)
26                     print("\033[32;1m[producer]\033[0m is making baozi %s" %n )
27 
28 
29             if __name__ == ‘__main__‘:
30                 con = consumer("c1")
31                 con2 = consumer("c2")
32                 p = producer()

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

 1             #!/usr/bin/env python3.5
 2             #__author__:‘ted.zhou‘
 3             ‘‘‘
 4             使用gevent模块创建协程代码实例
 5             ‘‘‘
 6             import gevent
 7             def foo():
 8                 print(‘\033[32;1mRunning in foo\033[0m‘)
 9                 gevent.sleep(0)  # 这里sleep(0)就是为了掩饰gevent协程遇到IO或者sleep就切换的特性
10                 print(‘\033[32;1mExplicit context switch to foo again\033[0m‘)
11 
12             def bar():
13                 print(‘Explicit context to bar‘)
14                 gevent.sleep(0)
15                 print(‘Implicit context switch back to bar‘)
16 
17             gevent.joinall([         # gevent.joinall() 是等待所有执行完成的意思
18                 gevent.spawn(foo),   # gevent.spawn()是启动的意思
19                 gevent.spawn(bar),
20             ])

 1             #!/usr/bin/env python3.5
 2             #__author__:‘ted.zhou‘
 3             ‘‘‘
 4             使用gevent 和 urllib 在但线程中并发的抓取几个页面
 5             ‘‘‘
 6 
 7             from gevent import monkey; monkey.patch_all()
 8             import gevent
 9             from  urllib.request import urlopen
10 
11             def f(url):
12                 print(‘GET: %s‘ % url)
13                 resp = urlopen(url)     #使用urlopen直接讲输入进来的URL进行下载
14                 data = resp.read()      # 把结果读取下来
15                 print(‘%d bytes received from %s.‘ % (len(data), url)) #打印爬到的字节
16 
17             # 使用gevent启动3个协程
18             gevent.joinall([
19                     gevent.spawn(f, ‘https://www.python.org/‘), #调用f函数,后面是参数
20                     gevent.spawn(f, ‘https://www.yahoo.com/‘),
21                     gevent.spawn(f, ‘https://github.com/‘),
22             ])
23         执行结果:
24             GET: https://www.python.org/
25             GET: https://www.yahoo.com/
26             GET: https://github.com/
27             451842 bytes received from https://www.yahoo.com/.
28             47381 bytes received from https://www.python.org/.
29             25540 bytes received from https://github.com/.
30 
31             Process finished with exit code 0

 1         server side
 2             #!/usr/bin/env python3.5
 3             #__author__:"ted.zhou"
 4             ‘‘‘
 5             单线程下实现多socket,解决多线程socketserver开销大,效率低得问题
 6             ‘‘‘
 7             import sys
 8             import socket
 9             import time
10             import gevent
11             from gevent import monkey   # 非常有意思,python中得黑魔法
12             from gevent import socket   # 导入的是gevent下的socket
13             monkey.patch_all()          # 非常有意思,python中得黑魔法,我们写socket是不是很多是阻塞得,比如读IO,或网络接口都是阻塞得,而这个monkey.path_all()方法就使得代码一旦遇到阻塞就切换到其他线程.也就是标题所说的(非阻塞).
14             def server(port):
15                 s = socket.socket()
16                 s.bind((‘0.0.0.0‘, port))
17                 s.listen(500)           # 最多可以监听500个连接
18                 while True:
19                     cli, addr = s.accept()
20                     gevent.spawn(handle_request, cli)  # 启动一个新的协程,把客户端的socket对象,调用
21             def handle_request(s):
22                 try:
23                     while True:                 # 一个循环,
24                         data = s.recv(1024)     # 前面用了monkey.path_all()了,这里程序就不阻塞了,而是切换到其他线程了,这里就是回到调用它的server函数
25                         print("recv:", data)
26                         s.send(data)
27                         if not data:            # 如果没有数据
28                             s.shutdown(socket.SHUT_WR)  # 这个shutdown,就是把客户端连接过来产生的socket客户端对象销毁掉.
29 
30                 except Exception as  ex:
31                     print(ex)
32                 finally:
33 
34                     s.close()       # 把服务器跟这个客户端连接的实例关掉
35             if __name__ == ‘__main__‘:
36                 server(8001)

 1             #!/usr/bin/env python3.5
 2             #__author__:‘ted.zhou‘
 3             ‘‘‘
 4             socket客户端代码,就是普通的客户端
 5             ‘‘‘
 6 
 7             import socket
 8 
 9             HOST = ‘localhost‘    # The remote host
10             PORT = 8001           # The same port as used by the server
11             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
12             s.connect((HOST, PORT))
13             while True:
14                 msg = bytes(input(">>:"),encoding="utf8")
15                 s.sendall(msg)
16                 data = s.recv(1024)
17                 #print(data)
18 
19                 # print(‘Received‘, repr(data))
20                 print(‘Received‘, data.decode())
21             s.close()