python的并发库：asyncore和eventlet
asyncore就是纯粹的异步socket，和c++使用异步socket没有什么大的区别，就是封装了loop等。实际上还是会有很多状态。
eventlet采用coroutine，本质上也是异步socket，但是已经是将异步socket同步化，没有任何状态（状态都保存在栈中），只有异步才需要考虑状态，同步根本没有状态之分。
所以eventlet明显比asycore要好用很多，也复杂很多。
贴一个asycore的例子：
#!/usr/bin/python
import sys,os,time;
import asyncore,socket;
class HTTPClient(asyncore.dispatcher):
def __init__(self, host, port, path):
asyncore.dispatcher.__init__(self);
self.create_socket(socket.AF_INET, socket.SOCK_STREAM);
self.connect((host, int(port)));
self.buffer = 'GET %s HTTP/1.1\r\nHost: %s\r\n\r\n'%(path, host);
def handle_connect(self):
pass;
def handle_close(self):
self.close();
def handle_read(self):
print("[handle_read] event loop start to read.");
print self.recv(8192);
def writable(self):
return len(self.buffer) > 0;
def handle_write(self):
sent = self.send(self.buffer);
self.buffer = self.buffer[sent:];
class EchoServer(asyncore.dispatcher):
def __init__(self, host, port):
asyncore.dispatcher.__init__(self);
self.create_socket(socket.AF_INET, socket.SOCK_STREAM);
self.set_reuse_addr();
self.bind((host, int(port)));
self.listen(10);
def handle_accept(self):
pair = self.accept();
if pair is None:
return;
(sock, addr) = pair;
print("incoming client: %s"%(repr(addr)));
handler = EchoHandler(sock);
class EchoHandler(asyncore.dispatcher_with_send):
def handle_read(self):
data = self.recv(8192);
if data is None:
return;
self.send("winlin");
time.sleep(3);
self.send(data);
check_mode = lambda : len(sys.argv) <= 1;
check_mode_value = lambda: sys.argv[1] not in ("server", "client");
check_mode_argc = lambda mode,argc: sys.argv[1] == mode and len(sys.argv) != 2+argc;
if check_mode() or check_mode_value() or check_mode_argc("client", 3) or check_mode_argc("server", 2):
print("Usage: %s <mode>\n"
"mode: the mode, server or client.\n"
"if mode is client, must specifies: <host> <port> <path>\n"
" host: the server ip or hostname. ie. dev\n"
" port: the port to connect to. ie. 80\n"
" path: the path to get. ie. /api/mine\n"
"if mode is server, must specifies: <host> <port>\n"
" host: the server ip or hostname. ie. dev\n"
" port: the port to listen. ie. 80"%(sys.argv[0]));
sys.exit(1);
mode = sys.argv[1];
if mode == "client":
(host, port, path) = sys.argv[2:];
client = HTTPClient(host, port, path);
asyncore.loop();
else:
(host, port) = sys.argv[2:];
server = EchoServer(host, port);
asyncore.loop();
可以看到，客户端的收函数调用了两次。而在eventlet中可以在一个函数一直调用，asyncore不能用while循环调用（会造成阻塞，就和它的非阻塞目标违背了）。
eventlet和st-threads一样的思路，都是提供替代函数，实现异步socket的同步化：
#!/usr/bin/python
import sys,os,time,json;
import eventlet;
import eventlet.green.urllib2;
# download and install:
# http://eventlet.net/
# wget https://pypi.python.org/packages/source/e/eventlet/eventlet-0.13.0.tar.gz
# tar xf eventlet-0.13.0.tar.gz && cd eventlet-0.13.0 && sudo python setup.py install
if len(sys.argv) <= 1:
print("Usage: %s <connections>\n"
"connections: the concurrency connection to request."%(sys.argv[0]));
sys.exit(1);
connections = int(sys.argv[1]);
print("create %s concurrency connection to request api"%(connections));
pool = eventlet.GreenPool(connections+1);
apis = {
"cdn": "http://www.baidu.com",
"key": "http://www.sina.com.cn"
};
def task_function(id):
# request cdn info.
url = apis["cdn"];
print("[task][#%s] request cdn info from %s"%(id, url));
cdn_str = eventlet.green.urllib2.urlopen(url).read();
cdn_json = json.loads(cdn_str);
print("[task][#%s] timestamp=%s"%(id, cdn_json["timestamp"]));
# request key info.
url = apis["key"];
print("[task][#%s] request cdn info from %s"%(id, url));
key_str = eventlet.green.urllib2.urlopen(url).read();
key_json = json.loads(key_str);
print("[task][#%s] len(key_pieces)=%s"%(id, len(key_json["key_pieces"])));
def deamon():
while True:
print("green threads: running=%s waiting=%s"%(pool.running(), pool.waiting()));
eventlet.green.time.sleep(0.5);
pool.spawn_n(deamon);
for i in range(0, connections):
pool.spawn_n(task_function, i);
pool.waitall();
print("all task finished.");