1 import gevent
 2 from gevent import socket
 3 import Tkinter as tk
 4 
 5 class SockLoop(object):
 6     def __init__(self, callback):
 7         self.callback = callback
 8 
 9     def __call__(self, sock, client):
10         while 1:
11             mes = sock.recv(256)
12             ret = self.callback(client, mes)
13             if ret is not None:
14                 sock.send(ret)
15 
16 def socket_server(port, callback):
17     ssock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
18     ssock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
19     ssock.bind(('', port))
20     ssock.listen(5)
21 
22     while 1:
23         sock, client = ssock.accept()
24         gevent.spawn(callback, sock, client)
25 
26 class App(object):
27     def __init__(self, root):
28         self.greenlet = None
29         self.root = root
30         self._build_window(root)
31         self.root.after(100, self._connect)
32 
33     def add_text(self, text):
34         cleaned_string = text.replace('\r', '')
35         self.text.insert(tk.END, cleaned_string)
36 
37     def quit(self):
38         self.root.quit()
39 
40     def _build_window(self, root):
41         self.frame = tk.Frame(root)
42         self.text = tk.Text(self.frame)
43         self.quit_button = tk.Button(self.frame, text="Quit", command=self.quit)
44         self.text.pack()
45         self.quit_button.pack()
46         self.frame.pack()
47 
48     def _connect(self):
49         self.greenlet = gevent.spawn(
50                 socket_server,
51                 8080,
52                 SockLoop(lambda cl, txt: self.add_text("%s: %s" % (cl, txt))))
53         self.gevent_loop_step()
54 
55     def gevent_loop_step(self):
56         gevent.sleep()
57         self.root.after_idle(self.gevent_loop_step)
58 
59 
60 if __name__ == '__main__':
61     root = tk.Tk()
62     app = App(root)
63     root.mainloop()

放屁阿狗 2014-05-04 16:59 发表评论

http://api.mongodb.org/python

http://webpy.org/cookbook/storeupload.zh-cn

http://webpy.org/cookbook/streaming_large_files

放屁阿狗 2014-03-29 21:27 发表评论

multithread_test cost time: 2.45199990273

normal_test cost time: 4.04299998283

gevent_test cost time: 2.12800002098

 1 import gevent
 2 import gevent.queue
 3 
 4 import psycopg2
 5 import psycopg2.extensions
 6 
 7 import psycogreen.gevent
 8 
 9 psycogreen.gevent.patch_psycopg()
10 
11 sys.path.insert(0,'../')
12 
13 import easymq
14 
15 '''
16 在同一线程中，同一个连接conn上两次创建的cur将会是一样滴，因为是异步wait_read()缘故
17 所以要么每次创建数据库连接，要么使用dbpool
18 '''
19 
20 
21 def readThread():
22     conn = psycopg2.connect(database='postgres',user='postgres',password='111111')
23 
24     # cur = conn.cursor(cursor_factory=psycopg2.extensions.DictCursor)
25     cur = conn.cursor(cursor_factory=psycopg2.extensions.cursor)
26 
27     # cur.execute("select pg_sleep(%s)", (2,))
28     for n in range(10):
29         cur.execute("select CURRENT_DATE")
30         # print cur.fetchone()
31     # print 'read end..'
32     conn = None
33 
34 
35 def gevent_test():
36     jobs=[]
37     for n in range(100):
38         jobs.append(gevent.spawn(readThread))
39     gevent.joinall(jobs)
40 
41 def normal_test():
42     for n in range(100):
43         readThread()
44 
45 def multithread_test():
46     threads=[]
47     for n in range(100):
48         thread = threading.Thread(target=readThread)
49         threads.append(thread)
50         thread.start()
51     for thread in threads:
52         thread.join()
53 
54 start = time.time()
55 normal_test()
56 end = time.time()
57 print 'normal_test cost time:',end-start
58 
59 start = time.time()
60 gevent_test()
61 end = time.time()
62 print 'gevent_test cost time:',end-start
63 
64 # start = time.time()
65 # multithread_test()
66 # end = time.time()
67 # print 'multithread_test cost time:',end-start
68 

放屁阿狗 2013-09-25 02:08 发表评论

放屁阿狗 2013-09-25 00:35 发表评论

http://blog.163.com/lxl_1995/blog/static/677173392012724103742746/
这篇博文讲的非常清楚，建议读一下 

gevent的特点如下： 
 1. 单线程执行，所有协程都在同一进程中被模拟和调度分派
 2. 可以创建成千上万的 协程，而不会受任何性能影响
3. 由于spawn的协程不是os分配和管理，所以不会有额外的线程资源分配，cpu也不用在这些线程之间调度切换
4. 单线程执行，无需考虑资源互斥
5. 协程之间切换是通过gevent的io阻塞完成，例如 gevent.sleep(0), queue.get/put,event,socket....
    每调用一次gevent 的api，gevent就能获得一次schedule的机会(这很类似操作系统的用户调用中断，由用户态切换到内核态)

 以上特点保证gevent的性能非常出色，但当我们的server用到第三方软件包的时候那要非常小心了，特别是这些包内部涉及了io操作。
如果第三方软件包是纯python的那很简单，只需要gevent.monkey_patch(xxx)就okay； 但如果包是扩展clib,那要当心了，monkey_patch
并不能将其相关io操作打上补丁，为了使用这些第三方软件包，要求这些软件包必须支持 协程异步 接口(调用其同步io接口，将阻塞住gevent的执行线程，那gevent就完蛋了)。
gevent的patch对psycopg2无效，因为psycopg2的通信部分是c接口的函数库，还好psycopg2内部支持协程，需要使用 到 psycogreen 这个东东

放屁阿狗 2013-09-24 23:47 发表评论

放屁阿狗 2013-09-19 14:44 发表评论

 1 class MutexObject:
 2     def __init__(self):
 3         self.mtx = threading.Condition()
 4         self.d = None
 5         
 6     def waitObject(self,timeout):
 7         d = None
 8         self.mtx.acquire()
 9         if self.d == None:
10             if timeout:
11                 self.mtx.wait(timeout)
12             else:
13                 self.mtx.wait()
14             d = self.d
15             self.d = None
16         self.mtx.release()
17         return d
18         
19     def notify(self,d):
20         self.mtx.acquire()
21         self.d = d
22         self.mtx.notify()
23         self.mtx.release()

放屁阿狗 2013-05-14 01:04 发表评论