非阻塞的Python web框架tornado

最新推荐文章于 2024-09-15 22:31:42 发布

liangpz521

最新推荐文章于 2024-09-15 22:31:42 发布

阅读量1.5k

点赞数

分类专栏： python django 文章标签： web框架 python callback redis asynchronous nginx

python 同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

django

13 篇文章 0 订阅

订阅专栏

公司项目中需要使用长链接方式的获取后端数据库——主要是Redis的实时数据。

由于项目本身是PHP的初次看到这个项目，首先想到的是Apache + mod_php的方式，配合php的ob_start()方式直接调用，就如同我之前的一篇东西所说的那样。可问题不这么简单：

系统是nginx + php-fpm方式，php-fpm“hold不住”过多的Http请求，而nginx需要调整响应时间。
用户数量很多，Apache的消耗很大。本身功能点很小，实现成本不合算。

说到并发，Apache采用的方式是大量的fork进程，通过“人多力量大”的方式应对多个请求，这样的基于进程（线程）模型的并发，一旦调用sleep，进程只是休眠而已，仍然占用着内存，仍然需要进程调度，资源始终得不到释放，资源自然无法得到控制。这些年nginx的流行大多都是因为nginx采用的epoll方式有效的解决这个问题——直接挂掉进程，然后再指定时间内重新启用。这就是传说中的“非阻塞”(asynchronous IO AIO)。

多并发、轻量级应用，我首先想到的是Python，加上“非阻塞”关键字，得到的结果就是Tornado。

tornado原本是FriendFeed引擎的开源版本，本身就是为解决“C10K”问题而生的。

稍微研究了一下，coding也很简便：

    #!/usr/bin/env python  
    #By Litrin J   
    #http://www.litrin.net/  
    import tornado.httpserver  
    import tornado.ioloop  
    import tornado.options  
    import tornado.web  
    import time, redis, hashlib,random  
    from tornado.options import define, options  
      
    define("port", default=8888, help="run on the given port", type=int)  
      
    class LongPolling(tornado.web.RequestHandler):  
      
        minWaitTime = 15  
        maxWaitTime = 900  
      
        RedisHost   = "172.18.194.98"  
        RedisPrefix = "Q/MSG%s"  
      
        SignSalt    = "salt"  
      
        StopCode    = "{'stop':1}"  
     
        @tornado.web.asynchronous  
        def get(self):  
            sUid        = self.get_argument("uid", None)  
            sSign       = self.get_argument("sign", None)  
            sJsonCall   = self.get_argument("jsonCallback", None)  
      
            if (sUid is None or sSign is None   
                    or self.checkSign(sUid, sSign) == False):  
                raise tornado.web.HTTPError(404)  
                self.clear()  
      
            else:  
                self.doLongPolling(callback=self.onWaitting)  
      
        def checkSign(self, sUid, sSign):  
            return True  
      
        def doLongPolling(self, callback):  
            #Check if the client close the connection  
            if self.request.connection.stream.closed():  
                self.clear()  
      
            sKey        =   self.RedisPrefix % self.uid  
            res         =   redis.Redis(self.RedisHost)  
            sMessage    =   res.rpop(sKey)  
            del res #close the redis at 1st time  
      
            callback(sMessage)  
      
        def onWaitting(self, sMessage):  
            if (sMessage is not None):  
                self.onRespones(sMessage)  
            else:  
                iNextPollingTime = time.time() + self.minWaitTime  
                if self.minWaitTime < self.maxWaitTime:  
                    self.minWaitTime *= 2  
                    #Can't useing time.sleep for no-bloking mode  
                    tornado.ioloop.IOLoop.instance().add_timeout(  
                    iNextPollingTime ,   
                    lambda: self.doLongPolling(callback=self.onWaitting)  
                )  
                else:  
                    self.onRespones(self.StopCode)  
      
        def onRespones(self, sMessage):  
            sJsonCall   = self.get_argument("jsonCallback", None)  
            if sJsonCall is not None:  
                sMessage= sJsonCall + "( " + sMessage.decode('utf-8') + ")"  
      
            self.write(sMessage)  
            self.finish()  
      
    def main():  
        tornado.options.parse_command_line()  
        application = tornado.web.Application([  
            (r"/", LongPolling),  
        ])  
        http_server = tornado.httpserver.HTTPServer(application)  
        http_server.listen(options.port)  
        tornado.ioloop.IOLoop.instance().start()  
      
    if __name__ == "__main__":  
        main()