记得在PHP开发过程中，经常会用到实例级别或者线程级别的变量缓存，带来的性能提升是巨大的。但对于tornado来说，由于每次访问都会实例化tornado.web.RequestHandler，不能满足要求，只能考虑在主线程上进行变量缓存。一旦成功将有可能直接抛弃redis。

种种原因，不公开最终实现的代码，这里只用一个页面计数器来模拟。通过一个页面http://localhost/get获得主页http://localhost/的Page View。

import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.httpclient
import tornado.web
import sys, os
from tornado.options import define, options

#####
class PageCounter(object):
    count = 0
####

#PageCounter = 0 这种采用全局变量的方法被证实无法实现。

class MainPage(tornado.web.RequestHandler):

    def get(self):
        PageCounter.count += 1
        self.finish('Hello World!')

class GetPageView(tornado.web.RequestHandler):
    def get(self):
        sPageView = str(PageCounter.count)
        self.write(sPageView)

def main(port):
    if os.fork() != 0:
        exit()
    define("port", default=port, help="run on the given port", type=int)
    application = tornado.web.Application([
        ("/", MainPage),
        ("/get", GetPageView),
    ])
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()

if __name__ == "__main__":

    if len (sys.argv) > 1:
        port = sys.argv[1]
    else:
        port = 80
    main(port)

这里要说的是object基类的PageCounter方法，可以定义一种数据结构以及对应的操作方法。当然这段代码只是Demo，写得不规范。由于PageCount是全局的，跟随进程实例化，所以可以很灵活在各个实例之间传递数据。

类似这种方法，我们的项目性能提升了至少5倍。但这样实现的结果也非常明显，首先不能持久化，一旦进程终止，数据就被清空；其次是进程隔离，这种方法共享数据只能工作在tornado的一个进程中，对于习惯于多进程并行的Tornado部署会有问题，我们最终的做法是做唯一哈希；最后要注意的是内存释放的问题，数据保存在内存中，如果是大量的数据通过dict/list做映射的话需要进行定期清理，当然通过这种方法可以变态的做一个基于HTTP协议的Key-value数据库。

# ab -n10000 -c1000 http://localhost/
This is ApacheBench, Version 2.3 < $Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 1000 requests
Completed 2000 requests
Completed 3000 requests
Completed 4000 requests
Completed 5000 requests
Completed 6000 requests
Completed 7000 requests
Completed 8000 requests
Completed 9000 requests
Completed 10000 requests
Finished 10000 requests

Server Software: TornadoServer/2.1.1
Server Hostname: localhost
Server Port: 80

Document Path: /
Document Length: 12 bytes

Concurrency Level: 1000
Time taken for tests: 8.921 seconds
Complete requests: 10000
Failed requests: 0
Write errors: 0
Total transferred: 1700000 bytes
HTML transferred: 120000 bytes
Requests per second: 1120.89 [#/sec] (mean)
Time per request: 892.148 [ms] (mean)
Time per request: 0.892 [ms] (mean, across all concurrent requests)
Transfer rate: 186.09 [Kbytes/sec] received

Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 230 792.8 0 3012
Processing: 14 134 73.9 114 1878
Waiting: 14 134 73.9 114 1878
Total: 86 364 815.1 114 3818

Percentage of the requests served within a certain time (ms)
50% 114
66% 115
75% 121
80% 141
90% 378
95% 3135
98% 3176
99% 3223
100% 3818 (longest request)

一直把Python当成胶水语言来用，这次就接着这个话题，说个Python C重构的例子：

首先是python原码：(很眼熟吗？)

#!/usr/bin/env python

import time

lGoal = {}

def main(i):
#    if lGoal.has_key(i):
#        return lGoal[i]

    if i < 1:
        return long (0)
    elif i < 2:
        return long(1)
    return main(i-1) + main(i-2) - main(i-5)

def getList(iMax):
    for i in range(1, iMax+1):
        iGoal = main(i)
        lGoal[i] = iGoal

    return lGoal

#i = int(raw_input())
i = 30
timeStart = time.time()
getList(i)

print "Cost: %s" % (time.time() - timeStart)

看看它的耗时：
Cost: 21.9739699364

首先对于这种多重循环和调用，绝对是C的强项，理论上Python 2 C 之后会有很大的提升空间。重构的思路是用Python的ctypes模块调用基于C的lib库，这样可以在保留大部分Python代码的基础上完成重构，而且重构之后的程序仍然还是Python的。
开始C重构vi LoadTest.c：

#include <stdio.h>
/*
int main()
{
    int i, goal;
    for (i=1; i <= 30; i++)
    {
        goal = C_Time_Cost(i);
        printf ("%d, %d \n", i, goal);

    }

   return 0;
}
*/
int C_Time_Cost(int a)
{
    if (a < 1)
    {
        return 0;
    }
    if (a < 2 )
    {
        return 1;
    }

    return C_Time_Cost( a - 1 ) + C_Time_Cost( a - 2 ) - C_Time_Cost( a - 5 ) ;
}

编译到.o文件：
gcc -c LoadTest.c -fPIC

编译成为Lib
gcc –shared -o libLoadTest.so LoadTest.o
cp libLoadTest.so /lib64 && ldconfig //这一点很重要，否则会报找不到lib文件。

修改python:

#!/usr/bin/env python

import time
from ctypes import *
lGoal = {}

def main(i):
    cdll.LoadLibrary("libLoadTest.so")
    libc = CDLL("libLoadTest.so")
    goal = libc.C_Time_Cost(c_int(i))
    return goal

def getList(iMax):
    for i in range(1, iMax+1):
        iGoal = main(i)
        lGoal[i] = iGoal

    return lGoal

#i = int(raw_input())
i = 30
timeStart = time.time()
getList(i)

print "Cost: %s" % (time.time() - timeStart)

执行时间：
Cost: 0.280420064926

对比之前的21.9739699364 性能提升78倍！不过需要注意，ctypes模块的加载本身很耗资源，使用不当会起到反效果，例如将i=30改为i=10的情况下，python: 0.000591039657593，而Ctypes则需要0.00165605545044，反而落后3倍的时间。

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

1. 系统是nginx + php-fpm方式，php-fpm“hold不住”过多的Http请求，而nginx需要调整响应时间。
2. 用户数量很多，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()

一旦建立http连接，系统会每隔一段时间去轮询用户的队列中是否有数据，有数据时才向客户端发送请求，否则就是“长时间小菊花”状态。很简单，仅仅用了不到100行代码的样子。当然，为了安全因素和节省资源，代码里添加了很多限制性的操作，否则可能会更简洁高效。

需要注意的是，tornado的理念就是建立在“非阻塞”基础上的，你当然可以选择time.sleep(n)，但传统上的time.sleep(n)方式的休眠会导致IO阻塞，故只能采用tornado.ioloop.IOLoop.instance().add_timeout 的方法回调来回调去，将下次启动的时间转给系统。话说回来，这是我第一次在Java或JS以外使用回调函数……

初步测试了一下，借助Redis本身就很强的并发能力在台式机上可以每秒钟完成4K次请求以上，并可以保持同时4K以上的访问不掉线，此时的CPU load仍然保持在1以下，单是测试的结果就足以让Apache+Php组合汗颜。

部署的时候采用了单IP多端口方式，服务器有4个核心，决定开4个端口对应，分别是8885~8888，修改

define("port", default=8888, help="run on the given port", type=int)

即可

前端nginx用负责负载分发：

upstream backend {
        server 127.0.0.1:8888;
        server 127.0.0.1:8887;
        server 127.0.0.1:8886;
        server 127.0.0.1:8885;
}
 server{
        listen  80;
        server_name message.test.com;
        keepalive_timeout 65;    #
        proxy_read_timeout 2000; #
        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;

        proxy_pass  http://backend;
        }
}

需要注意的是，这样的httpSocket方式很可能被内核认为是SYN攻击，而且对于大量的keep alive而言，很可能超过核心限制，还要修改sysctl参数。

#系统最大打开文件数
fs.file-max = 201510

#TCP连接的最长时间
net.ipv4.tcp_keepalive_time = 1800
#出现问题的尝试次数
net.ipv4.tcp_keepalive_probes = 15
#检查是否连接的等待时间
net.ipv4.tcp_keepalive_intvl = 60
#不进行SYN cookies防御
net.ipv4.tcp_syncookies = 0

fork，顾名思义就是一把叉子，或者专业一点叫做复制叉。作为sys/type.h的一个函数，系统在每次调用fork()之后，将会以此为分叉，对进程本身进行复制，新的进程和旧进程有近乎完全一致的cpu时间和内存寄存器。

这本身并不重要，重要的是对于fork()函数的返回而言，父进程返回的是子进程的pid，而子进程返回的是0，当然还有一个-1的返回表示fork()的失败。对与C大致如此：

#include <unistd.h>;
#include <sys/types.h>;

main ()
{
        pid_t pid;
        pid=fork();

        if (pid < 0)
                printf("error in fork!");
        else
        {
			if (pid == 0)
                        {
                                 printf("i am the child process, my process id is %d\n",getpid());
		                 exit();
                        }
			else
                        {
                                printf("i am the parent process, my process id is %d\n",getpid());
				exit();
                         }
         }
}

执行后，父进程和子进程分别将自己的Pid打印出来。

既然如此，对于我常用的php来说，可以同样做到后端执刑一些耗时的操作，从而达到异步的效果：

function mulitProcess()/*{{{*/
{
        if (function_exists(pcntl_fork))
        {
            $pid = pcntl_fork();

		    if ( $pid === -1 )
		    {
		    	return false;
		    }
		    elseif ( $pid )
		    {
                        usleep(10);
                        exit();
                    }
                    else
                    {
                         doBackground();
                    }
        }
        // windows system or php not support PCNTL libs
        else
        {
			doBackground();
        }
}

对于很多守护进程来说，脱离shell（即“脱壳”）正是利用了这种方式进行进程复制。对与PHP来说需要进行2次fork之后配合一个死循环即可,当然为了防止死循环真的“死掉”需要sleep()函数来进行休眠：

function daemonize() /*{{{*/
{
    $pid    =   pcntl_fork();

    if (-1 == $pid)
    {
        return false;
    }
    elseif ($pid)  //parent process
    {
        usleep(500);
        exit();
    }
    $sid    =   posix_setsid();

    if (!$sid)
    {
        return false;
    }

    $pid    =   pcntl_fork();

    if ( -1 == $pid )
    {
        return false;
    }
    elseif ($pid)
    {
        usleep(500);
        exit(0);
    }

    // deny process display and io
    if (defined('STDIN'))
            fclose(STDIN);

    if (defined('STDOUT'))
            fclose(STDOUT);

    if (defined('STDERR'))
            fclose(STDERR);
    while(true)
            doSomeThing();

}/*}}}*/

需要注意的是，windows没有fork()，php直接屏蔽了PCNL函数库，而python相对没有一棒子打死。Python采用的方式等于在命令行重新调用一次脚本，如果直接将没有考虑到这个问题的python脚本直接移植windows的话进程数量将会爆炸式增长，很快就会导致资源耗尽。由于我在windows上大多只是进行测试而已，多进程带来的性能优势不重要，习惯上我的方法就是使用threading模块替换掉mulitprocessing模块。写个示例：

try: #if os.name == 'posix':
    from multiprocessing import Process, Queue
except: #else:
    from threading import Thread as Process
    from Queue import Queue

首先，下载安装包，我选择的是最新的stable版， 不过不客气的说，即便是coreseek的stable版本，不论是从稳定性、兼容性还是灵活性上都不能算是完善，至少无法跟apache这类经典应用相提并论。

安装ubuntu开发包：
apt-get install make gcc g++ automake libtool mysql-client libmysqlclient15-dev libxml2-dev libexpat1-dev

 
解压：
tar xzvf coreseek-3.2.14.tar.gz
cd coreseek-3.2.14

应该看到有mmseg csft testpack 至少3个目录

安装mmseg中文分词模块

cd mmseg-3.2.14
./bootstrap
./configure –prefix=/usr/local/mmseg3 #不喜欢这个官方目录配置，更换目录后配置无法生效郁闷了很久，稍后再说
make
make install
cd ../testpack
/usr/local/mmseg3/bin/mmseg -d /usr/local/mmseg3/etc var/test/test.xml #测试结果，请确保终端可以看到utf8中文，应该可以看到分词后的结果

安装Python包

虽然coreseek支持直接的mysql连接，但考虑到分词、分表的情况，这种设置不是很灵活。我的方案是通过python脚本的预处理，将mysql的数据整理后传输到coreseek建立索引。这样还有一个优势就是“万能数据源”——memcache、redis这类几乎不指望coreseek官方支持的妖异存储方案，只要有python的api，均可以索引。

官方的安装手册中介绍的python接口是基于ActivePython 替代系统python语言的方式进行的。ActivePython属于第三方封包，远没有系统自带python来的方便，刚开始用系统python测试了数次，均不成功，后来根据出错信息，找到了原因。

apt-get install python-dev python-sqlite python-mysqldb python-memcache

安装coreseek

cd ../csft-3.2.14
./buildconf.sh
./configure –prefix=/usr/local/coreseek –without-unixodbc –with-mmseg –with-mmseg-includes=/usr/local/mmseg3/include/mmseg/ –with-mmseg-libs=/usr/local/mmseg3/lib/ –with-mysql –with-python
make
make install

cd ../testpack
/usr/local/coreseek/bin/indexer -c etc/csft.conf –all
/usr/local/coreseek/bin/search -c etc/csft.conf 网络搜索 #没什么问题了

安装libsphinxclient

coreseek官方教程中建议php使用直接include一个php文件进行操作，事实上php有独立的sphinx模块可以直接操作coreseek (coreseek就是sphinx！)已经进入了php的官方函数库，而且效率的提升不是一点点！但php模块依赖于libsphinxclient包。

cd ../csft-3.2.14/api/libsphinxclient
./configure
make
make install
ldconfig

安装php-sphinx支持

apt-get install php5-dev
wget http://pecl.php.net/get/sphinx-1.1.0.tgz
tar vzxf  sphinx-1.1.0.tgz
cd  sphinx-1.1.0
phpize
./configure
make
make install

确信成功后修改php.ini，还是遵从ubuntu的配置规则
echo “extension=sphinx.so”  > /etc/php5/conf.d/sphinx.ini

如果使用apache或者fast-cgi的话，请重起。察看phpinfo() 如下则安装成功。

sphinx

配置coreseek

说容易也容易，说麻烦也麻烦的工作，照贴一份吧前面说过，我用的是python数据源

/usr/local/coreseek/etc/coreseek.conf

python
{
           path = /usr/local/coreseek/DBSource #python 数据源脚本的存放路径
}
source Blog #索引库1 “Blog”
{
          type = python #类型为python
          name = Blog.MainSource #调用python的class
}
index Blog
{
    source          = Blog #数据源名称
    path            = /data/sphinx/Blog #数据文件存放路径
    docinfo         = extern
    mlock           = 0
    morphology      = none
    min_word_len    = 1
    html_strip      = 0
   charset_dictpath = /usr/local/mmseg3/etc/ #mmseg中文分词库的位置，本文开头时我说不能修改mmseg的安装路径就错在这里
   charset_type        = zh_cn.utf-8
}
source UserInfo #索引库2 “UserInfo” 其余同上
{
    type = python
    name = UserInfo.MainSource
}
index UserInfo
{
     source          = UserInfo
     path            = /data/sphinx/UserInfo
     docinfo         = extern
     mlock           = 0
    morphology      = none
    min_word_len    = 1
    html_strip      = 0
    charset_dictpath = /usr/local/mmseg3/etc/
    charset_type        = zh_cn.utf-8
}

searchd #服务器配置
{
    listen          =   9312  #显而易见，默认的监听端口
    listen          =   172.18.196.90:3306:mysql41 #兼容mysql方式的监听，我们配置了php-sphinx，故除了命令行方式外意义不大，可以关闭
    pid_file        =   /var/run/coreseek.pid
}

话说去年11月份，刚接到一个项目，要在Android平台上开发一个基于手机通讯录的应用。众所周知的原因，Android开发者网站http://developer.android.com/ 在国内无法访问。一开始，我直接下载了本地版本的html全站镜像文件。作为一开始了解这个平台，读读SDK搭建方法一点问题也没有。后来对照几个example进行开发联系，发觉很多类型不知道何去何从，用了本地搜索发觉也是摸不着头脑。于是有了一个想法：为何不把手册放在网上，借助google来索引整个网站。

于是我马上切换到Geeker模式，浏览手册的目录，发觉所有的html都是很规范的相对路径，完全可以直接放在网上。而且主目录下已经有了部分GAE的文件，似乎可以很方便的上传到GAE。尝试了几次，大失所望，原来单是文件数目就有接近3000，超出了GAE 1000个文件的限制很多。

切换回程序员模式。想到之前曾经写过一个系统底层的Python脚本，为了方便翻阅归档的文件，通过python对于zip良好的支持和多线程操作，一次性diff多个版本的区别。用这种方式可以解决GAE的一系列限制，上传网站。
很快，最基本的代码完成了，网站也上传成功，大部分情况工作的也不错。于是有了想要把这个项目分享的想法。
既然要开源，只是基本的功能实现是不够的，而且代码也不够清晰。就算原理再简单，也应该给人清新的感觉，于是先重写了原型代码。想了很久有什么功能需要再添加，后来想到了GAE的CPU Time其实也是有限制的，zip解压又是CPU耗费型的。又通过GAE的Data Store和Memcache做了双重缓冲。大致上有点意思了，于是申请了google code的空间，通过SVN放出了第一个版本ver0.1作为测试。最后，为了显得有点可扩展性，写了一个接口，可以支持插件，其实主要是纯文本和HTML，最初的想法只是看到Android手册中的HTML有太多的空格和换行，很浪费带宽而已。

话说当时正巧我的广告帐户里面攒到了$80多之后，很久没有动静。始终无法达到最低的汇款金额$100。要知道，$80比$0还要折磨人。切换到商人模式，复杂化了插件，让他可以自动的制定位置插入广告。又复杂了一步。

本来这个项目只是为了想要借助google的本地索引来完成一些事情，谁知道上线很久以后，Google仍不能完成全站的收录。SEO吧。又写了sitemap的支持功能到项目中，发布了Ver0.2版本。

剩下的任务就是不断的修正bug而已。春节前几天，我觉得整个项目该有的功能都差不多了，于是这才开始整理feature——生命周期完全颠倒了。也正是这个原因，回头看看之前的代码，已经乱的差不多了。特别是插件的接口我觉得真的很垃圾，况且即便是程序员，也没有几个人愿意通过大量的正则表达式来实现功能，于是索性取消了。

为了给这个项目制作一个像样点的文档，我特地在Mac app store里面买了一套iwork，花了差不多$90大洋。呵呵，也算是开发费用的一部分吧。

然后就是Ver1.0 RC 版本，虽然这个项目没有什么人关注，但很庆幸，有几个人特地找到我，愿意参加测试，在此感谢下！

今天终于咬牙发布了最终的Release版本。希望不要马上推出个什么紧急补丁之类的东西。

说到下一个版本，我觉得应该遵守GAE的习惯，采用整数版本号来表示Release版本，小数表示tag或者snap版本。2版本应该增加一个管理员界面，在后台上多做些文章；重新启用插件部分，当然表达方式越简单越好。Zipsite项目的最终目标是成为一个运行在GAE沙盒内部的一个快速、傻瓜化的网站搭建系统。

初次测试的过程中，由于仅仅只是测试下性能如何，没有“特别规矩”没有关闭定义的类，于是代码大致如此：

for mailBody in mailList:

        mail = SendMail()
        mail.MailServer['UserName'] = username
        mail.MailServer['Password'] = password 
        mail.MailServer['Host'] = host
        mail.MailServer['port'] = port

        mail.SenderName = senderName
        mail.Charset = 'UTF-8'

        mail.AddMeta('Precedence', 'bulk')

        delFromDb(mailBody[3])  

        try :
            mail.Send(From = smtpFrom,
              Address = mailBody[0],
              Subject = mailBody[1],
              Body = mailBody[2])           

            logging.info('Mail send to: ' + mailBody[0] + " with subject is " + mailBody[1] + " By thread #" + str(thread))

        except:
            logging.error('Error send to: ' + mailBody[0] + " with subject is " + mailBody[1] +"By thread #" + str(thread))

初版测试了一下，每小时的发送量保守达到2w左右。已经达到了要求，可以正式部署。
考虑到了生产环境中的服务器负载很高，于是对python的代码提出了更高的要求，在上述代码的最后加上了一句：
mail = None
结束发送循环以后立即释放 SendMail()这个类占据的资源。这是一个程序员都应该遵守的好习惯。部署好了以后，再次测试，每小时仅能发送不足7000。性能仅有之前的30%。
多次拉锯测试，只要加上那句mail=None，性能就会下降。所有的性能缺陷都指向了这句“好习惯”。没什么说的，直接在头部加上

import gc
gc.disable()

加不加那句已经没有实质性的影响了。

Python不同于Java的垃圾回收机制，Java机制是只有等到资源，特别是内存资源紧张的情况下才会执行垃圾回收机制。而Python则是忠实于C++系的逻辑，只要资源没有被引用就回自动被回收机制无情的回收。
在这个例子中，由于Sendmail的类相对比较复杂的操作，每次构建和解构的过程都需要花费较长时间。而且由于Sendmail是主循环，占用了大量的内存，每次垃圾的回收系统都会重新整理内存碎片，如果每次都为释放内存而手工解构的话性能反而会大大降低。

首当其冲的应该算是云技术，但这个技术总体上属于物理层的技术，况且云已经成为公认的技术趋势。这里主要是谈下网站的架构，云技术相对关系较为偏离，我也就不再探讨了。

BigTable数据库

一开始接触下来的GAE，最感觉不适应的就非它的“数据存储”技术。通常用惯了SQL，用了GAE觉得数据设计上很要有很大的转变。
GAE的“数据库”感觉就是一个巨大的List，每一条记录都是key-value的对应关系。当然起初是无法满足很多传统上的数据结构。不过如果你能够在数据结构设计上打破SQL的限制，通过极端灵活的Key-value, key-value, key-value，你就能发觉这样的框架事实上比传统的SQL更适合网站。
说mysql比oracle在网站实现上的优势并非是因为它功能的强大，而是它速度快，结构简单。尽管有人戏称mysql“裸奔”，但无可否认的就是这种“裸奔”的效果带来的mysql的成功。GAE的数据库比mysql还要“裸奔”，但更快的响应将会是SQL永远无法企及的。FaceBook之前也抛弃了SQL亦证明了这一点。

此外整站之间的数据复制也算是革新之一。

多通道的融合

GAE整合了mail，xmpp，跨域验证等一系列的通道也算是特色之一，想必很多人会认为google这是在捆绑自己的产品。作为之前的门户网站的特色，每家人都会有一个自己的邮箱，一个自己的聊天工具，以及一系列自己的产品捆绑在内。GAE的创新在于用户只需要一个自己的google帐户就可以实现捆绑所有的gae服务。这是一个真正意义上的以用户为本。
Xmpp的捆绑还意味着EDM之后，将来IM营销或者类似的IM推送将会逐步成为一个产业。或者更进一步，IM机器人或者类似的技术将会一定程度上取代现有人人对话模式。当然，这需要一段时间，但至少个人认为目前大量的taobao网店需要这种技术^_^。

精巧的运维界面

相信GAE的后他大家也会印象深刻，能对每一个模块进行精确的监控，已经让运维的工作从翻阅日志的文本化提升到了图形化。粒度也更为精准，如果能配合Analytics之类的数据，完全可以实现智能化的运维。

RSS XML SOAP 网址抓取…

其实这也不算是什么革新，Web2.0时代的开始就是以此为标志的。但事实上单单从开发库中各个库的名称都叫API来看，就可以明白，其实整个GAE就是构建在这些基础之上的。SOAP成为了各个模块之间的粘合剂。
这个带来的优势就是，无需关心这个库那个库——好像本站技术性文档的大部分都是解决的“库问题”。各自统一接口，加速了开发的进程。

知道GAE可以直接跟gtalk挂钩推送消息，可能一直挂Gtalk的人远没有挂QQ和MSN的多（密之声：Gtalk又没有星星和钻石，挂也没劲），但有了Android + 3G的实时在线，这种方式却可以直接替代SMS这类花钱的服务，何乐不为？

大致上完成了原型，制作了一个基于Python的命令行程序，不敢独享，分享给大家。希望大家能够一起加入这个项目完善它。
在此之前，请现将 server-say @@@ appspot.com （你懂的！）加为好友

#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
import re
import urllib

class ServerSaid:

	ApiURL = 'http://server-say.appspot.com/api'
	#
	#请到http://server-said.appspot.com/注册您的Ip地址。没有注册的Ip每小时最多10条消息。
	#
	Account = ''
	MessageBody = ''
	DefaultEncode = 'utf-8'

	def SendMessage(self):
		cleanMessage = self.MessageBody.encode(self.DefaultEncode)
		if (self.checkEmail(self.Account) and self.checkMessage(cleanMessage)):
			cleanMessage = self.MessageBody.encode('utf-8')
			url = self.ApiURL + '?account='+ urllib.quote(self.Account) +'&message=' + urllib.quote(cleanMessage)
		#	print url
			query = urllib.urlopen(url)
			if ( query.read() == '200' ):
				print 'Message be sent!\\n'

			else:
				print self.Error(0)
		else :
			print self.Error(1)

	def Error(self, code=0):
		return  'Message can\\'t be send! \\n'

	def checkEmail(self, Email):
		RegexString = r'^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w{2,5}$'

		return re.match(RegexString, Email)

	def checkMessage(self, Message):

		RegexString = r'^.{1,140}$'
		return re.match(RegexString, Message)

if __name__ == '__main__':

	if (len(sys.argv)>1):
		handler = ServerSaid()
		handler.Account = sys.argv[1]

		Message = sys.argv[2]

		handler.MessageBody = Message.decode(handler.DefaultEncode)

		handler.SendMessage()
	else:
		print 'serversaid.py YOUR_GTALK MESSAGE '

这里为了防止消息的滥发，使用前最好先到 http://server-say.appspot.com/ 注册一下。没有注册的IP每小时仅能发送10条消息，我想大部分情况下也够用了。注册了的用户可以无限制的发送消息了，除非我在GAE注册的那张信用卡里的钱花光——我会哭的。

啥也不说了，PHP接口也搞定了！

< ?php
/*
 *    Gtalk 通告机器人 Ver 0.1
 *
 *    Litrin Jiang 2010/12/02
 *
 * --------------------------------
 *  1. 2010/12: v0.1 原型实现
 *
 */

Class Gtalk{

	private $APIUrl = 'Http://server-say.appspot.com/api?';
	//Api 的地址，不要修改

	public $mothod = 'get';
	//默认的提交方式，现阶段仅支持get
	public $account = '';
	//接收人的Gtalk账户
	public $messageBody = '';
	//消息主体，最多支持140个字符

	public $Charset = 'UTF-8';

	public function Send($account=null, $messageBody=null){
		if (is_array($account)){
			foreach ($account as $key) {
				$this->Send($key);
			}
		}

		if ($account === null){
			$account = $this.account;
		}
		$this->CheckAccount($account);

		if($messageBody === null){
			$messageBody = $this->messageBody;
		}
		if ($this->Charset != 'UTF-8'){
			$messageBody = iconv("UTF-8", $this->Charset.'//IGNORE', $messageBody);
		}
		$this->CheckMessage($messageBody);

		$url = $this->APIUrl .'account=' . urlencode($account) . '&message=' .  urlencode($messageBody);

		$query = file($url);
		/*
		if($query == '200'){
			return true;
		}else{
			return false;
		}*/

	}

	private function CheckAccount($account){
		$regexString = '^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w{2,5}$';
		echo ereg($regexString, $account);
		if (ereg($regexString, $account) != true){
			#throw new Exception("Value not a Email account! ");
		}

	}

	private function CheckMessage($messageBody){
		$regexString = '^.{1,140}';
		if (ereg($regexString, $messageBody) != true){
			#throw new Exception("Message not a allowed format! ");
		}
	}
}

?>

看了看要上传的文件夹，5000多个文件，小气的google根本满足不了我。 想到Python的灵活性，在手册中翻了到了zipfile类库。有门！就上传zip文档，边解压边浏览。Google要用时间来换空间那就累死他的CPU 写个GAE应用loadzip.py：

#!/bin/env python
##
##	This is a project for Google App Engine
##		that support create a webisite by ZIP packages!
##
##	By Litrin J. 2010/11
##	Website: www.litrin.net
##	Example: android-sdk.appspot.com
##

import wsgiref.handlers
from google.appengine.ext import webapp
from google.appengine.api import memcache
from zipfile import ZipFile
import os
import logging
import mimetypes
import re

class MainHandler(webapp.RequestHandler):
	'''
This is a project for Google App Engine that support create a webisite by ZIP packages!
	'''
	URL = ''
	CACHEDTIME = 60*60*24*30
	#setting memcaching time (seconds)

	def get(self):

		self.URL=self.request.path

		if ( self.URL[-1:] == '/'):
		#Get the defaule file for the path
			self.URL+='index.html'

		sRealFileName = os.getcwd() + self.URL

		if (os.path.exists(sRealFileName)):
		#If the file not be ziped, read it drictory
			fNoZipedFile = open(sRealFileName,'r')
			Entry = fNoZipedFile.read()
			fNoZipedFile.close()

		else:
			Entry = self.loadFile()

		self.buildMineType()
		#Set the Mine type in header

		if (self.response.headers['Content-Type'] == 'text/html'):

			Entry = self.regex(Entry)

		self.response.out.write(Entry)
		#Response building finished!

	def loadZipFile(self):
	#Load the file from zip files. This is the core function!
		lFilename = self.URL.split('/')

		iPathLevel = 1
		#Loop count, The dir layers
		bLoaded = False
		#Sucessful marks

		while(iPathLevel < = len(lFilename)):
		#Get the zip file name and the filename from the URL, support muli-layer
			sFilePath = os.getcwd()
			sFileName = ''
			iElementCount = 1

			for sElement in lFilename:
			#Set or reset the Zip filename
				if ( iElementCount <= iPathLevel):
					sFilePath += sElement + '/'

				if ( iElementCount >= iPathLevel ):
					sFileName += sElement + '/'

				iElementCount += 1

			sFileName = sFileName[0:-1]
			sZipFilename = sFilePath[0:-1] + '.zip'

			if (os.path.exists(sZipFilename)):
			#Found the Zip file
				ZipFileHandle = ZipFile(sZipFilename)
				Entry = ZipFileHandle.read(sFileName)
				bLoaded = True
				ZipFileHandle.close()

				if (Entry is not None):
					logging.info(sFileName + " in " + sZipFilename + " Loaded!")
					return Entry
					break

			iPathLevel +=1

		if (bLoaded==False):
		#Can't file the file in Zip packages
			logging.error('No found ' + self.request.path + '' +sZipFilename+' !')
			self.error(404)

			return None

	def loadFile(self):
	#Load in from memcache if cached
		Entry = self.loadFromMemcach()

		if Entry is None:
		#If not cached, cache it
			Entry = self.loadZipFile()
			if(Entry is not None):
				self.writeToMemcache(Entry)

		return Entry

	def loadFromMemcach(self):
		memcachkey = self.URL
		#The cache key is URL

		Entry = memcache.get(memcachkey)
		if Entry is not None:
			return Entry

		else:
			return None

	def writeToMemcache(self, data):
		memcachkey = self.URL
		#set the URL as the key
		memcache.add(memcachkey, data, self.CACHEDTIME)

		logging.info(memcachkey + ' cached!')
		return True

	def buildMineType(self):
	#Building the MineType in Http header
		sFilename = os.path.basename(self.URL)
		lFileName = sFilename.split(".")
		sExFilename = lFileName.pop()
		#Get the file ex-filename

		mimetypes.init()
		sMineType = mimetypes.types_map['.'+sExFilename]

		if (sMineType == ''):
		#Others can't be idented, set to HTML
			sMineType = 'text/html'

		self.response.headers['Content-Type'] = sMineType
		#Send Content-type

	def regex(self, Entry):

		lRegGroup=(
			('\n+', '\n'),
			#
			('\t+', '\t'),
			#
		)

		for sRegCell in lRegGroup:
			(sSource, sTarget) = sRegCell
			rInfo = re.compile(sSource)
			Entry = rInfo.sub(sTarget, Entry)

		return Entry

def main():
	application = webapp.WSGIApplication([('.*', MainHandler)], debug=True)
	wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
	main()

比较简单，我也没有写太多注释。考虑到Google一直被这么搞，挂掉也不好，于是启用了memcache。 重写app.yaml

application: android-sdk
version: 1
runtime: python
api_version: 1

handlers:

- url: .*
 script: zipload.py

#- url: /
# static_files: index.html
# upload: index.html

准备就绪，把手册中每一个子目录压缩成zip，极限大小也无所谓，然后把手册根目录下的所有文件和这两个文件放在同一目录下。上传至GAE便可。 捎带说下，由于GAE还有对文件大小的限制。用此方法还无法完全解决Adroid手册上传的问题，后来我用了分级的目录结构搞定的，原理上跟上面是一致的，在此不再累述了。 把我的Android手册网站共享给大家 http://android-sdk.appspot.com/index.html PS:

1. Linux下的Idle工具真烂，远不及以及够烂的windows版。好在SPE这个工具很好用。
2. GAE的sdk for linux没有桌面工具，只能用命令行方式，在此代表Linux用户表示抗议！

本项目的后续版本已经通过google code开源，敬请访问：

http://code.google.com/p/zipsite/ 

获取最新版本！

原理上很简单，到头来python的smtplib调试了半天才ok，为了方便，重新封了一下包，基本上的用途都在里面了。分享给各位！
提醒各位：不要用它来收发垃圾邮件！

##
##******************************************************************************
##   NAME:       SendMail
##   PURPOSE:   
##
##   REVISIONS:
##   Ver        Date        Author           Description
##   ---------  ----------  ---------------  ------------------------------------
##   1.0        2010/06/28  Litrin J.        1. Created this Script.
##
##   NOTES:
##
##      Object Name:     SendMail.py
##      Sysdate:         2010/06/28
##     
##      Username:         Litrin Jiang
##      Website:          litrin.net
##
##******************************************************************************
##

import sys
import smtplib
import email
import re

class SendMail:
   
    MailServer = {}
    MailServer['UserName'] = ''            
    MailServer['Password'] = ''                 #SMTP密码
    MailServer['Host'] = ''
    MailServer['SSL'] = False
    MailServer['Port'] = 0

    Subtype = 'html'
    Charset = 'gb2312'

    SenderName = ''
    ReciverName = ''   
    Notification = False

    __aRealAddressList = []
   
    def __init__ (self, From = '', Address='', Subject='', Body='', CCAddress = '', BCCAddress = ''):

        if ((From + Address + Subject + Body) != ''):

            self.Send(self, From, Address, Subject, Body, CCAddress = '')
       

    def Send(self, From, Address, Subject, Body, CCAddress = '', BCCAddress = ''):

        self.Email = email.MIMEText.MIMEText (Body,_subtype=self.Subtype, _charset=self.Charset)

        self.Email['From'] = self.AddressList(From, self.SenderName, False)
                   
        self.Email['To'] = self.AddressList(Address)

        if CCAddress != '':
            self.Email['Cc'] = self.AddressList(CCAddress)

        if BCCAddress != '':
            self.AddressList(BCCAddress)
           
        self.Email['Subject'] = self.StrEncode(Subject)
       
        self.Email['X-Maile'] = 'Python Script by Litrin.net'
        self.Email['X-Python-Version'] = str(sys.platform) + str(sys.version_info)
       
        if (self.Notification) :
            self.Email['Disposition-Notification-To'] = From

 
        self.__ServerSending()

    def StrEncode(self, String, Charset = ''):
        if Charset == '':
            Charset = self.Charset
           
        return str(email.Header.Header (String, Charset))

    def AddressList(self, oAddress, ReciverName = '', SendingList = True):

        if isinstance(oAddress, dict):
            To = ''
            for dAddress in oAddress :
                To += self.AddressList(oAddress[dAddress],dAddress )  + ','
            return To
       
        elif isinstance(oAddress, list):
            To = ''
            for sAddress in oAddress :
                To += self.AddressList (sAddress, '') + ','
            return To
       
        else:
           
            try :
                self.CheckEmail(oAddress)
            except:
                print oAddress + 'is not a Email address!'
                exit()
               
            if ReciverName == '':
                ReciverName = self.ReciverName     
           
            if ReciverName != '':
                To = self.StrEncode(ReciverName) + '<' + oAddress + '>'
            else:
                To = oAddress
               
            if SendingList :
                self.__aRealAddressList.append(oAddress)               

            return To
   

    def CheckEmail(self, sEmailAddress):
        sRegex = r'^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$'
        return re.match(sRegex, sEmailAddress)
   
    def __ServerSending(self):

        if (self.MailServer['SSL'] == False):
          
            server = smtplib.SMTP(self.MailServer['Host'],port = self.MailServer['Port'])
        else:
            server = smtplib.SMTP_SSL(self.MailServer['Host'], port = self.MailServer['Port'])

          
        server.login(self.MailServer['UserName'], self.MailServer['Password'])
       
        for sAddress in self.__aRealAddressList:           
           
            server.sendmail(self.Email['From'], sAddress, self.Email.as_string())
           
        server.quit()

if __name__ == '__main__':
    mail = SendMail()
    mail.MailServer['UserName'] = ''            
    mail.MailServer['Password'] = ''                 #SMTP密码
    mail.MailServer['Host'] = ''
    #mail.MailServer['SSL'] = True
    mail.SenderName = 'Litrin J.'
   

    mail.Send(From = 'abc@123.com',
              Address = 'abc@71inc.com',
              Subject = 'Subject:test',
              Body = '<b>This is a test mail!</b>')
 

服务器中经常需要对大规模的数据进行压缩，传统使用单进程操作不足以体现8核CPU并发的威力。于是写了一个脚本用于多进程压缩。然而在windows的主机上进行调试，全都是死循环，以至于机器都无法进行响应。导入Linux主机，测试却通过。对脚本进行了精简如下：

出错的代码：

from multiprocessing  import Process
#from threading  import Thread

def work(a):
    print "This is : " + str(a) + '\n'
    exit

x = 2

while(x>1):
    p = Process(target=work, args=(x,))
    p.start()
    x -= 1

类似的调用方法，换成threading库是正确的

#from multiprocessing  import Process
from threading  import Thread

def work(a):
    print "This is : " + str(a) + '\n'
    exit

x = 2

while(x>1):
    thread = Thread(target=work, args=(x,))
    thread.start()
    x -= 1

翻阅了官方文档，找到了问题所在：

*Nix平台对于multiprocessing 的实现是基于C库中的fork()，所有子进程与父进程的数据是完全相同，可以说是父进程的完全克隆。
而对于windows，由于windows对于进程的实现方式不同，没有fork()函数，multiprocessing 的调用只能是对于该脚本的重新调用，难怪会出现死循环的问题。

改良后的代码：

from multiprocessing  import Process
#from threading  import Thread

def work(a):
    print "This is : " + str(a) + '\n'
    exit

if __name__ == '__main__' :
    x = 2

    while (x>1):
        p= Process(target=work, args=(x,))
        p.start()
        x -= 1

对于multiprocessing 和 Threading的区别：

Threading的操作只能和父进程在同一个物理CPU上执行。但由于不需要底层的调用，大多数简单的操作效率很高。
multiprocessing的操作可以在多个CPU上执行，但耗费的内存资源也远高于thread方式，适合于集中运算或大并发的状态。

CVS结构示例：1300428,浙江省嘉兴市,联通130卡 （一个手机号码的对应归属地列表）

configfile:

from google.appengine.ext import db
from google.appengine.tools.bulkloader  import Loader

class MobilePhone(db.Model):
  Number = db.StringProperty()
  Area = db.StringProperty()
  BrandType = db.StringProperty()

class MPLoader(Loader):
  def __init__(self):

    Loader.__init__(self, 'MobilePhone',
                    [('Number', unicode),
                     ('Area', unicode),
                     ('BrandType', unicode),
                     ])

loaders = [MPLoader]

主要分析了一下，问题分为几类。

1.验证不能通过的问题：

这个问题很多时候是一个低级错误，之前我曾经犯过类似的错误。在app.yaml中的handlers

handlers:
- url: /remote_api
  script: $PYTHON_LIB/google/appengine/ext/remote_api/handler.py
  login: admin
- url: /*
  script: main.py

这个/*的配置必须放在最后。否则所有的访问都会直接匹配main.py自然出现问题。

2.跟编码有关的错误：

这个错误是GAE SDK的一个bug，恐怕对于ASCII系统的用户没什么关系，对于我们UTF-8，GB2312，ASCII已经昏倒的用户来说，这是个严重的问题。

在GAE的安装目录下 google\appengine\tools\bulkloader.py文件中2521行

    for (name, converter), val in zip(self.__properties, values):
      if converter is bool and val.lower() in ('0', 'false', 'no'):
        val = False
      properties[name] = converter(val)

修改为：

    for (name, converter), val in zip(self.__properties, values):
        if converter is bool and val.lower() in ('0', 'false', 'no'):
            val = False
        if isinstance(val,str) and not isinstance(val, unicode):
            val=unicode(val,'utf-8')
        properties[name] = converter(val)

系统会将unicode类型的变量转换。

3.对于大容量数据的删除

GAE的限制，一次最多载入1000行的数据，每次最多删除500行数据，这对于像我制作的手机号码归属之类的大数据库是远远不够的，多次删除又会导致500报错，我的方法是使用task queue。
Task Queue在官方的中文文档中没有提及，在英文文档中介绍的也不够详细。个人的理解就是让系统定期的去访问一个页面而已，我的例子：

from google.appengine.ext import webapp
from google.appengine.ext.webapp import util
from google.appengine.ext import db
from google.appengine.api.labs import taskqueue

class MobilePhone(db.Model):
    Number = db.StringProperty()
    Area = db.StringProperty()
    BrandType = db.StringProperty()

class Delete(webapp.RequestHandler):
    def get(self):
        q = db.GqlQuery("SELECT * FROM MobilePhone limit 100")
        results = q.fetch(100)
        db.delete(results)
        q = db.GqlQuery("SELECT * FROM MobilePhone limit 100")
        if (q.count() > 0):
            self.addqueue()

        self.response.out.write('Hello world!')

    def addqueue(self):
        taskurl = 'http://ip-and-mp.appspot.com/'
        taskqueue.add( url='/del', params=dict(url=taskurl))
        self.response.out.write('added!')

每次删除100行，使用默认的default queue，即每秒一次。

4.关于命令行的问题

我按照中文文档的办法始终有问题，添加了–email=xxxx –passin的参数才成功。手册已经远远落后了。