每每读到一些好的算法都会让人有叹为观止的感觉，巧妙的设计让我们回味起数学，物理等，物理的测万有引力，远古 时代没有任何工具的情况下的测量出地球的半径，人就是这么一个奇妙的动物。想体味下巧妙，你可以看下《啊哈，灵机一动》google黑板报的《数学之美》 系列，微软的《编程之美》等，大道至简，简单的道理抽象到了一定的高度就适应于任何事物，在我看来数学和哲学都是抽象到一定程度的事物，你可以体味下 1+1=2，事物的都是有联系的普遍性。俗话说大道至简。
读计算机以来，自然也学到不少算法，虽然现在搞些web的开发，当初也是软件开发的，总是忘不了学过的那些经典的算法，经常及其老师讲解时候的费力和樯橹灰飞烟灭。自己体味好多计算机里面的算法，定理，思想，更大自然世界很协调。
先举几个简单的小例子：
1 将两只小猫放到足球场的对面，相距100码，他们以每分钟10码的速度相向行走。同时这两只小猫的母亲在足球场的一端，它可以以每分钟100码的速度跑步，猫妈妈从一只小猫跑到另一只小猫，来回轮流跑而速度不减，一直跑到两只小猫在中场相遇，问猫妈妈跑了多远？
2 渔民在池塘放养了大量鱼苗。养到一定程度后，我们要估计现在池塘中有多少鱼？
3 有一根27厘米的细长杆，在第3厘米，7厘米，11厘米，17厘米，23厘米在五个位置各放有一只蚂蚁，木杆很细，不能同时通过两次蚂蚁，开始时，蚂蚁头 朝右还是朝左是任意的，他们只会超前或者调头，当不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时掉头朝反方向走，假设蚂蚁每秒钟可以走一厘米的距离，所 有蚂蚁离开木杆的最短时间和最长时间。
4 棋盘覆盖问题。在一个2k x 2k ( 即：2^k x 2^k )个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用图示的4种不同形态的L型骨 牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。

5 某一天，一个新研究员向托马斯爱迪生报到。爱迪生要求他计算出一个空灯泡壳的体积。在使用测径仪和微积分进行数小时饿计算后，这个新员工给出了答案150立方厘米，而爱迪生在几秒之内计算就给出了更接近155，他是如何实现的呢？

—————————————-给出部分提示————————–

1 不要用蛮力，首先通过两只小猫可以计算出猫妈妈的跑步的时间，两只小猫相距100米，每分钟20码在接近，故5分钟完成，所以猫妈妈是500米

2 这个牵涉到数学中的概率等的知识，概率统计还是挺实用的一门学科，可以考虑用极大似然估算算法，即捞出一定数量的鱼，不能过少，坐上标记，过一定时间取出看看标记的比例

3 和第一个的思想有点像，碰头后蚂蚁会继续潜行，看做是个体运动就好考虑了

4 第四题图片方格少，还好，如果多了，你就不一定能搞定了，还需保证是4的k次幂，其实可以采用分治的思想，即图上可以上下左右四部分，带黑色宽那个就可以填好了，挨着黑色块的即中心的可以填好了，然后就把其他的搞定，如果更多如何？就行切分，分治，分而治理。

5 想想阿基米德王冠的故事你就明白了

现在可以看到了

一题三给我们一个解决问题的思路用时间求解较容易，摊还分析就是用这样一个思路，一如一个附加变量，位势，

二题，五题也是给我们一种思路转换问题的思路。4题给我们一个解决问题分而治之。

可以看到什么样的哲学思想呢？首先事物是联系的，解决了这个事物，和其关系的别的也就可以相应的解决了，整体和局部的思想，局部解决了，整体也就好了。

看看别的算法

1 递归于分治策略，递归？现实生活中哪里有递归的影子？没想到？那就照照镜子吧，看到了，这个就是递归，事物本身的属性，局部整体的哲学思想

2 动态规划，类似分治递归，当他们的若干个问题不是独立的是联系的，第n个问题和n-1个问题是有关系的，

3 贪心算法很明晰矛盾分主要矛盾和次要矛盾，抓住了主要矛盾就抓住了问题的核心

4 概率算法：事物发展的不确定性，螺旋式发展。舍伍德算法，拉斯维加斯算法，我们经典的抛针算π的算法，蒙特卡洛算法，现在基本都忘记了。

5 线性规划，回溯法，分枝限界法 这些都是通过把问题抽象，合理的布局，解决之，算是事物之间的联系吧。别的暂时没行到。

6np完全性理论和近似算法：图灵机等，应该是事物的发展变化的各个状态，著名的图灵机问题，问题的各个态势的变化，这个算法我不熟。

暂时先想到这里，也算是对自己学过的算法课程的一个回忆。

批量替换一个文件夹下的字符或者其他的应该经常可以见到，近期读《卓有成效的程序员》有点感触，他提到了一些可以加快工作效率的容易让人忽略的小细 节，加速法则，专注法则，自动化 法则，规范化法则。那这个批量替换应该属于自动化法则，有时候文件特别多的是很，替换是个非常容易烦人的事情。显然这些应该是计算机做的事情，下面给出以 上三个版本：

shell:

shell学了个皮也不皮，毛也不毛

for i in `find . -name “*.html”`
do
sed “s|<\!–{if \!empty(\$this->_visiteduser->_gender)&& \(\$this->_visiteduser->_gender\)==’m'}–>他<\!–{else}–> 她<\!-  -{/if}–>|{\1}|g” $i > $i-new
mv $i $i-old
mv $i-new $i
done

当然你可以用sed的i直接替换，尽量替换前做个备份。

python的批量替换脚本：

刚开始学写的特别烂:

import os
import re
def getHtmlFile(rootdir):
allfile=[]
for   parent, dirnames, filenames   in   os.walk(rootdir):
for   filename   in   filenames:
#if os.path.isfile(os.path.join(0)
allfile.append(os.path.join(parent, filename))
return allfile

def replace(filename):
file_object = open(filename)
try:
all_the_text = file_object.read( )
finally:
file_object.close( )
”’
grouped_word = re.compile(’<div id=”header”>([\s\S]*)?</div>’)
all_the_text = re.sub(r’xxxxxxxxxxxxxxxxxx’,all_the_text);
”’
all_the_text = re.sub(’<div id=”header”>[\s\S]+?</div>’,'header’,all_the_text);
all_the_text = re.sub(’<div id=”footer”>[\s\S]+?</div>’,'footer’,all_the_text);
#all_the_text = re.sub(’\r’,”,all_the_text);
open(filename, ‘w’).write(all_the_text)

file=getHtmlFile(’/home/liufb/studypython/gonglue’);
test = re.compile(”\.html$”, re.IGNORECASE)
file = [f for f in file if test.search(f)]
for i in file:
print i+”\n”
replace(i)

学的时间相对比较长，但是依旧比较烂：

function changefile($filename) {
global $text1;
global $text2;
$file = file_get_contents($filename);
$file2 = preg_replace(’@<div id=”header”>([\s\S]*)?</div>@iU’,$text1,$file);
$file3 = preg_replace(’@<div id=”footer”>([\s\S]*)?</div>@iU’,$text2,$file2);
$file3 = preg_replace(’@\r@iu’,”,$file3);
file_put_contents($filename,$file3);

}
function getFile($dirname) {
if ($handle = opendir($dirname)) {
while (false !== ($file = readdir($handle))) {
if ($file != “.” && $file != “..”) {
$file=$dirname.’/’.$file;
if(is_file($file) && substr($file,-5) ==’.html’) {
//echo $file.”\n”;

changefile($file);
}else if(is_dir($dirname.’/’.$file)) {
$dirscan = realpath($file);
//$dirscan = $dirname.’/’.$file;
//echo $dirscan.”\n”;
getFile($dirscan);
}
}
}
}
closedir($handle);
}
getFile(’.');

为什么华夏五千年的文明没有诞生大的科学，没有推动人类社会走向工业文明的社会的发展，为什么近代文明一次次的发展没有中国的影子？

我觉得应该从民族的思维形态和意识来探讨，总得讲西方的科学是一种质测的科学，是一种准确的科学，而中国的则是模糊的追求意境的一种算不上科学的科 学，从我们从小到大也应该感觉到我们教育的不足，就像别人说的主流的意思是一元化的成功，就是在校看成绩，走出学校看名利，社会也是那名利来认可判断一个 人的标准，所以在中国几千年的突然上倒是滋生了官场学问，对这些的追求成为带带不变的，“衣带渐宽终不悔，为伊消得人憔悴”，古代的一些借物用咏志者，官 场不得志者大有人在，我在想如果这些人都没有这些所谓的名利观念，研究下科学该多好。所以我认为几千年的文明贯穿的主线还是孔子的中庸之道，穷则独善其 身，达则兼并天下，当然在中国古代也有科学的发展，比如祖冲之的圆周率，徐光启，等寥若晨星，当他们永远是一小部分人的东西，很少能听说哪个朝代的大臣研 究这些的，诗经，论语，唐诗宋词元明曲 到成了我们的经典，当我们从这里有能学到什么呢？是的做人，但是在现实生活中广做人是不够的，还需要做事，孔子，老子，孙子代表了古典中最经典的文化，孔 子的教我们如何做人，老子具有了朴素的哲学思想，做什么事情都要有个度，而孙子呢？带给了我们《孙子兵法》，教我们做事，很明显我们大多数人忽视了孙子兵 法，但恕不知孙子兵法在世界上备受推崇，从日本的松下等企业的商战，到海湾战争，据说当时胡佛总统桌上两本书，一本就是孙子兵法，可见我们祖先的智慧还是 无穷的，当我们却很少去研究利用他们，看孙子兵法你可以看到好多闪光点，譬如兵势篇，我觉得很有超前的思想，激水之疾，至于漂石者，势也；鸷鸟之疾，至于 毁折者，节也。是故善战者，其势险，其节短。势如NFEEC弩，节如发机。想想我们物理中学到的势能是不是被我们祖先的智慧说折服，还有很多，里面也有好 多的朴素的哲学思想，也有现代的博弈论的思想，毕竟是双方对战吗？这样一本经典的著作，有多少人关注呢？

中西文明还有一大差别是对文化的追求上，中国古典文学里大多追求的意境，经典的例子就是：“你问我爱你有深，月亮代表我的心，你去问一 问。。。。”，而西方这大多会肯定的说 “ I love u ”,这些都在思维方式的不同，哪一个切身的例子，比如以前我们在新光天地地下广场吃饭，经常会去找位置，找凳子，而一般我们去找凳子都会去问,”请问你的 凳子还有人做吗？”，而有一次一个老外有一次向我们借，则说“can  I take the chair”，本来那个凳子没人做，按照我们的习惯思维说，也没太清楚那个人说的话，以为他在说，凳子有人做吗？我们所no，其实相反，闹了一个不大的笑 话。这个就是我们思维习惯的不同，其实也是我们的逻辑体系的不同，看看爱因斯坦的话，爱因斯坦于1953年给斯威泽的信中说，“西方科学的发展是以两个伟 大的成就为基础的，即希腊哲学家发明的形式逻辑体系（在欧几里得几何学中），以及通过 系统的实验发现有可能找出因果关系（在文艺复兴时期）。在我看来，中国的贤哲没有走上这两步，那是用不着惊奇的。若是这些发现（在中国）全都做出来了，那 反倒是令人惊奇的事情。”爱因斯坦实际上指出了：近代科学的发展在方法论上需要两大发现，即“从一般到特殊”的演绎法和以实验为基础的“从特殊到一般”的 分析和归纳法。这些也就是我们的不同。

其实这些都与我们的文化息息相关比如我们的方块字文化和西方的字母文化是不同的，在疾驰的地铁上，你大眼一看就理解看出墙上的模糊的字，而如果是因 为英文，你必须完全看清楚才能下定义，这个就是我们的模糊的，而西方这是准确的，我们追求意境，他们追求质地，王国维的人间词话里对意境的讨论最多，词以 境界为最上，有境界则自成高格，自有名句。大家只知道拿破仑的血腥，不知道拿破仑也是一名数学家，与拉格朗日等经常讨论问题，著名的拿破仑三角形，还记得 以前读书的一个小细节，说笛卡尔的解析几何流行时，当时的贵族人人一本，很流行，他们觉得这个是一种荣耀，而且女王请笛卡尔给他们讲课，可见在西方文化中 他们人人对科学都很重视。

说说西方文明的发源地，源自于古代埃及巴比伦等地域，那时候他们有些地域每年分给奴隶的土地都受河流冲刷，尼罗河的赠礼和这个有关吗？忘记了，导致 他们每年要上交税等的不一样，就这样他们必须测量来决定上交的税等，这样就诞生了几何的雏形，也让人类产生了思考，对大自然的思考，对上帝的思考，一次次 的发展，泰勒斯人类上第一位科学家，托勒密等都在人类文明上作出了卓越的贡献，他们都带我们带入了对自然的思考，对现实世界的抽象，从毕达哥拉斯的勾股定 理的发现，对声乐的思考相处乐声和发生物体的长度有关，到无意间发现罪恶的根号2，无理数，又带入了我们进入了一次次的无穷的探索，毕达哥拉斯和后来的柏 拉图都为科学的发展和传播作出了巨大贡献，毕达哥拉斯学派，到欧几里德独立思考写出了《几何原本》，更加抽象了自然界，虽然是当时看来研究这些是得不到什 么，是纯粹的数学，不想中国的书中自有颜如玉，当他推动了人类文明的发展和进程，西方科学发展也遍地开放，文艺复兴等一次次锲机，走向了更远的地区，特别 是数学的发展，数次转行中心，从古希腊到高斯领头的哥廷根大学，到现在美国为中心的数学中心，拥向了一代代为人类做出卓越贡献的，阿基米德，欧拉，费马， 笛卡尔，乔治康拓，哥德尔， 伽罗瓦，哈牛顿，莱布尼茨，哈代，印度国宝拉马努金，庞加莱，希尔伯特，到现在的冯诺依曼，图灵，每一个名字都曾照亮了我们的人类的行程，太多太多。试想如果他们中有个一个是我们中国人会怎么样？

总之我的思想是以后我们民族应该引导我们学习西方的质测的科学，不止是读三字经，百家姓，也应该读读西方人的譬如《几何原本》，《什么是数学》《西方文化中的数学》，任何事物的精华值得我们去学习的，我们要汲取。也希望我们国家以后会诞生越来越多的科学牛人

tar xzvf /mysql-5.0.67.tar.gz.tar.gz

cd /misc//mysql-5.0.67.tar.gz

./configure --prefix=/usr/local/mysql-master

make

make install

cd /usr/local/mysql-master/bin

./mysql_install_db

cd ../var

cp /misc//mysql-5.0.67.tar.gz/support-files/my-medium.cnf my.cnf

cd ..

groupadd mysql

useradd -g mysql mysql

chown -R root .

chown -R mysql var

[mysqld]

port = 3306

socket = /usr/local/mysql-master/mysql.sock



#skip-networking // we have skip this in our case as we are doing both master and slave on same machine.



# Replication Master Server (default)

# binary logging is required for replication

log-bin



# required unique id between 1 and 2^32 - 1

# defaults to 1 if master-host is not set

# but will not function as a master if omitted

server-id = 1

cd /usr/local/mysql-master/bin

MySQL Slave:

cd /opt/mysql-4.1.12

./configure --prefix=/usr/local/mysql-slave

make

make install

cd /usr/local/mysql-slave

cd bin

./mysql_install_db

cd ../var

cp /opt/mysql-4.1.12/support-files/my-medium.cnf my.cnf

cd ..

groupadd mysql

useradd -g mysql mysql

chown -R root .

chown -R mysql var

chgrp -R mysql .

cd /usr/local/mysql-slave/bin

./mysqld_safe --defaults-file=/usr/local/mysql-slave/var/my.cnf &

Configure Replication:

mysql --sock=/usr/local/mysql-master/mysql.sock

Create account at master for slave:

mysql> GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO slavedb@"192.168.1.27/255.255.255.0" identified by 'q1w2e3r4t5'; Query OK, 0 rows affected (0.28 sec)

mysql --sock=/usr/local/mysql-slave/mysql.sock

mysql> slave start;

编译.
../dist/configure --prefix=/opt/Berkeley
make
make install

最后：

#vi /etc/ld.so.conf 并将berkeleyDB的lib路径加到该文件的最后一行,这样才能找到并加载它的库文件.ld.so.conf是什么东西？它就是系统动态链接库的配 置文件。此文件内,存放着可被LINUX共享的动态链接库所在目录的名字(系统目录/lib,/usr/lib除外)，各个目录名间以空白字符(空格，换 行等)或冒号或逗号分隔。

成功后，测试一段代码是否争：代码为：

编译：

gcc test.c -ggdb -I /opt/Berkeley/include/ -L/opt/Berkeley/lib/ -ldb -lpthread -o test.out
从网上找到的测试代码：红色部分是修改的

#include <db.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h> //添加

/* DB的函数执行完成后，返回0代表成功，否则失败 */
void print_error(int ret)
{
  if(ret != 0)
    printf("ERROR: %s\n",db_strerror(ret));
}

/* 数据结构DBT在使用前，应首先初始化，否则编译可通过但运行时报参数错误 */
void init_DBT(DBT * key, DBT * data)
{
  memset(key, 0, sizeof(DBT));
  memset(data, 0, sizeof(DBT));
}

int  main(){
  DB *dbp;     
  DBT key, data;
  u_int32_t flags;
  int ret;

  char *fruit = "apple";
  int number = 15;

  typedef struct customer
  {
    int c_id;
    char name[10];
    char address[20];
    int age;
  } CUSTOMER;
  CUSTOMER cust;
  int key_cust_c_id = 1;

  cust.c_id = 1;
  strncpy(cust.name, "javer", 9);
  strncpy(cust.address, "chengdu", 19);
  cust.age = 32;

  /* 首先创建数据库句柄 */
  ret = db_create(&dbp, NULL, 0);
  print_error(ret);

  /* 创建数据库标志 */
  flags = DB_CREATE; 

  /* 创建一个名为single.db的数据库，使用B+树访问算法，本段代码演示对简单数据类型的处理
   * */
  ret = dbp->open(dbp, NULL, "single.db", NULL, DB_BTREE, flags, 0);
  print_error(ret);

  init_DBT(&key, &data);

  /* 分别对关键字和数据赋值和规定长度
   * */
  key.data = fruit;
  key.size = strlen(fruit) + 1;
  data.data = &number;
  data.size = sizeof(int);

  /* 把记录写入数据库中，不允许覆盖关键字相同的记录
   * */
  ret = dbp->put(dbp, NULL, &key, &data,DB_NOOVERWRITE);
  print_error(ret);

  /* 手动把缓存中的数据刷新到硬盘文件中，实际上在关闭数据库时，数据会被自动刷新
   * */
  //dbp->sync();//注释掉没找到错误，注释掉后可以运行，原来的拷贝是中文错误

  init_DBT(&key, &data);

  key.data = fruit;
  key.size = strlen(fruit) + 1;

  /* 从数据库中查询关键字为apple的记录
   * */
  ret = dbp->get(dbp, NULL, &key, &data, 0);
  print_error(ret);

  /* 特别要注意数据结构DBT的字段data为void
   * *型，所以在对data赋值和取值时，要做必要的类型转换。
   * */
  printf("The number = %d\n", *(int*)(data.data));

  if(dbp != NULL)
    dbp->close(dbp, 0);

  ret = db_create(&dbp, NULL, 0);
  print_error(ret);

  flags = DB_CREATE; 

  /* 创建一个名为complex.db的数据库，使用HASH访问算法，本段代码演示对复杂数据结构的处理
   * */
  ret = dbp->open(dbp, NULL, "complex.db", NULL, DB_HASH, flags, 0);
  print_error(ret);

  init_DBT(&key, &data);

  key.size = sizeof(int);
  key.data = &(cust.c_id);

  data.size = sizeof(CUSTOMER);
  data.data = &cust;

  ret = dbp->put(dbp, NULL, &key, &data,DB_NOOVERWRITE);
  print_error(ret);

  memset(&cust, 0, sizeof(CUSTOMER));

  key.size = sizeof(int);
  key.data = &key_cust_c_id;

  data.data = &cust;
  data.ulen = sizeof(CUSTOMER);
  data.flags = DB_DBT_USERMEM;

  dbp->get(dbp, NULL, &key, &data, 0);
  print_error(ret);

  printf("c_id = %d name = %s address = %s age = %d\n",
      cust.c_id, cust.name, cust.address, cust.age);

  if(dbp != NULL)
    dbp->close(dbp, 0);
  return 0;
}

运行.test.out:

ERROR: DB_KEYEXIST: Key/data pair already exists
The number = 15
ERROR: DB_KEYEXIST: Key/data pair already exists
ERROR: DB_KEYEXIST: Key/data pair already exists
c_id = 1 name = javer address = chengdu age = 32
说明安装成功：以后研究：

然后安装libevent：

cd libevent:

[root@localhost]#cd libevent-1.2
[root@localhost]#./configure --prefix=/opt/libevent && make && make install

安装成功后，安装crawl

参数为：

 ./configure --prefix=/opt/crall  --with-libevent=/usr/
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking target system type... i686-pc-linux-gnu
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking whether make sets ${MAKE}... yes
checking for working aclocal-1.4... missing
checking for working autoconf... missing
checking for working automake-1.4... missing
checking for working autoheader... missing
checking for working makeinfo... missing
checking for gcc... gcc
checking for C compiler default output... a.out
checking whether the C compiler works... yes
checking whether we are cross compiling... no
checking for suffix of executables... 
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ANSI C... none needed
checking for a BSD-compatible install... /usr/bin/install -c
checking if we may use "-I/usr/include"... no
checking for libevent... /usr/
configure: error: event.h or libevent.a not found in /usr/

转：http://www.smashingmagazine.com/2009/05/06/introduction-to-advanced-regular-expressions/

Regular expressions (or regex) are a powerful way to traverse large strings in order to find information. They rely on underlying patterns in a string’s structure to work their magic. Unfortunately, simple regular expressions are unable to cope with complex patterns and symbols. To deal with this dilemma, you can use advanced regular expressions.

Below, we present an introduction to advanced regular expressions, with eight commonly used concepts and examples. Each example outlines a simple way to match patterns in complex strings. If you do not yet have experience with basic regular expressions, have a look at this article to get started. The syntax used here matches PHP’s Perl-compatible regular expressions.

1. Greediness/Laziness

All regex repetition operators are greedy. They try to match as much as possible in a string. Unfortunately, this might not always be a desired effect. Thus, lazy operators are used to solve this problem. They only match the smallest possible pattern and are used by adding a ‘?’ after the respective greedy operator. Alternatively, the ‘U’ modifier may be used to make all repetiton operators lazy. Differentiating between greediness and laziness is key to fully understanding advanced regular expressions.

Greedy Operators

The * operator matches the previous expression 0 or more times. It is a greedy operator. Consider the following expression:

preg_match( '/<h1>.*<\/h1>/', '<h1>This is a heading.</h1>
<h1>This is another one.</h1>', $matches );

Recall that a . means any character except a new line. The above regular expression is looking for an h1 tag and all of its contents. It uses the . and * operators to constantly match anything inside the tag. This pattern will match:

<h1>This is a heading.</h1><h1>This is another one.</h1>

It returns the whole string. The * operator will continuously match everything — even the middle closing h1 tag — because it is greedy. Matching the whole string is the best it can do.

Lazy Operators

Let’s change the above operator by adding a ‘?’ after it. This will make it lazy:

/<h1>.*?<\/h1>/

The regex now fulfills its duty and matches only the first h1 tag. Another greedy operator that uses this same property is {n,}. This matches the previous expression n or more times. If it is used without a question mark, it looks for the most repetitions possible. Otherwise, it starts from n repetitions:

# Set up a String
$str = 'hihi';

# Match it using the greedy {n,} operator
preg_match( '/(hi){1,}/', $str, $matches ); # matches[0] will be 'hihi'

# Match it with the lazy {n,}? operator
preg_match( '/(hi){1,}?/', $str, $matches ); # matches[0] will be 'hi'

2. Back Referencing

What it does

Back referencing is a way to refer to previously matched patterns inside a regular expression. For example, take a look at this simple regex that matches an expression in quotes:

# Set up an array of matches
$matches = array();

# Create a String
$str = "\"This is a 'string'\"";

# Traverse it with regular expressions
preg_match( "/(\"|').*?(\"|')/", $str, $matches );

# Print the whole match
echo  $matches[0];

Unfortunately, this will not correctly match the string. Instead, it will print:

"This is a '

This regular expression matches the opening double quote but finds a different type of quote to close it. This is because it was given the option of picking a double or single quote at the end. In order to fix this, you can use back referencing. The expressions \1, \2, …., \9 hold references to previously captured subpatterns. The first matched quote, in this case, will be held by the variable \1.

How to Use It

In order to apply this concept to the aforementioned example, use \1 in place of the last quote:

preg_match( '/("|\').*?\1/', $str, $matches );

This will now correctly return:

"This is a 'string'"

Remember that back referencing may also be used by preg_replace. Note that instead of \1 … \9, you should use $1 … $9 … $n (any number of these will work). For example, if you want to replace all paragraph tags with text that represents them, use:

$text = preg_replace( '/<p>(.*?)<\/p>/',
"&lt;p&gt;$1&lt;/p&gt;", $html );

The $1 back reference holds the text inside the paragraph and is being used in the replace pattern itself. This completely valid expression shows an easy way to access matched patterns even while replacing.

3. Named Groups

When using multiple back references, a regular expression can quickly become confusing and hard to understand. An alternative way to back reference is by using named groups. A named group is specified by using (?P<name>pattern), where name is the name of the group and pattern is the regular expression in the group itself. The group can then be referred to by (?P=name). For example, consider the following:

/(?P<quote>"|').*?(?P=quote)/

The above expression will create the same effect as the previous back reference example, but by instead using named groups. It is also significantly easier to read.

Named groups are also useful when sifting through the array of matches. The name given to a specific pattern is also the key of the corresponding matches array.

preg_match( '/(?P<quote>"|\')/', "'String'", $matches );

# This will print "'"
echo $matches[1];

# This will also print "'", as it is a named group
echo $matches['quote'];

Thus, named groups not only make code easier to read but also organize it.

4. Word Boundaries

Word boundaries are places in a string that come between a word character and a non-word character. The specialty of these boundaries is the fact that they don’t actually match a character. Their length is zero. The \b regular expression matches any word boundary.

Unfortunately, boundaries are so often skimmed over that many do not recognize their real significance. For example, let’s say you want to match the word “import”:

/import/

Watch out! Regular expressions can be tricky. The above expression will also match:

important

You may think it is as simple as adding a space before and after import to prevent these bogus matches:

/ import /

But what about this case?

The trader voted for the import

When import is at the beginning or the end of a string, the modified regex will fail. Thus, splitting this up into cases is required:

/(^import | import | import$)/i

Looking back at our regular expression, it does not take periods or other punctuation into account. Just to match this single word, a regular expressions may look like this:

/(^import(:|;|,)? | import(:|;|,)? | import(\.|\?|!)?$)/i

That’s a lot of code to match just a single word. This is why word boundaries are so significant. To accomplish the above statement and many other variations with word boundaries, all that is necessary is:

/\bimport\b/

This will match every case above and more. \b’s flexibility comes from the fact that it matches a zero-length string. All it matches is an imaginary space between two characters. It checks if one of the characters is a non-word character and the other is a word character. If so, it matches it. If the beginning or end of a string is encountered, \b treats it as a non-word character. Because the i in import is still considered a word character, it will match import.

Note that the opposite of \b is \B. This operator will match the space in-between two word or two non-word characters. Thus, if you would like to match ‘hi’ inside another word, you could use:

\Bhi\B

5. Atomic Groups

Atomic groups are special regex groups that are non-capturing. They are usually used to increase the efficiency of a regular expression, but may also be applied to eliminate certain matches. An atomic group is specified by using (?>pattern):

/(?>his|this)/

When the regex engine matches an atomic group, it will discard backtracting positions that came with all tokens inside it. Consider the word ’smashing’. Using the above regular expression, the regex engine will first try to match the pattern ‘his’ in ’smashing’. It will not find a match. At this point, the atomic group will kick in. The engine will discard all backtracking positions. This means that it will not search for ‘this’ inside ’smashing’. Why? If ‘his’ did not return a match, then obviously ‘this’ (which includes ‘his’) will not return positive either.

The above example did not have many practical uses. We might as well have used /t?his?/ instead. Look at the following:

/\b(engineer|engrave|end)\b/

If the regex engine is given the word ‘engineering’, it will correctly match ‘engineer’. The next word boundary, \b, will not match. Thus, it will move on to the next match: engrave. It realizes that the ‘eng’ matches, but the rest do not. Finally, ‘end’ is attempted and also failed. If you look carefully, you will realize that once the engine matches ‘engineer’ and fails the last word boundary, it can not possibly match ‘engrave’ or ‘end’. These two matches are smaller words than ‘engineer’, and thus the regex engine should not continue with the other trials.

/\b(?>engineer|engrave|end)\b/

The above is a much better alternative that will save the regex engine time and improve the code’s efficiency.

6. Recursion

Recursion in regular expressions can be used to match nested constructs, such as parentheses, (this (that)), and HTML tags, <div></div>. They require the use of (?R), an operator that matches recursive sub-patterns. Consider the regular expression that matches nested parentheses:

/\(((?>[^()]+)|(?R))*\)/

The outermost parentheses in this regular expression match the beginning of the nested constructs. Then comes an optional operator, which can either match non-parenthetical characters (?>[^()]+) or the whole expression again in a sub-pattern, (?R). Notice that this operator is repeated as many times as possible to match all nested parentheses.

Another example of recursion at work is the following:

/<([\w]+).*?>((?>[^<>]+)|((?R)))*<\/\1>/

The above expression combines character groups, greedy operators, back-tracking, and atomic groups to match nested tags. The first parenthesized group ([\w]+) matches the tag name for use later in the regular expression. It then proceeds to match the rest of the tag. The next parenthesized sub-expression is very similar to the one above. It either matches non-tag (?>[^<>]+) characters or recurses over another tag (?R). Finally, the last part of the expression matches the close tag.

7. Callbacks

Certain matches in a pattern may require special modifications. In order to apply multiple or complex changes, callbacks can be used. A callback is used for dynamic substitution Strings in the preg_replace_callback function. They take in a function as a parameter to use when a match is found. This function receives the match array as a parameter and returns a modified string that is used as a replacement.

As an example, consider a regular expression that changes all words to uppercase in a given string. Unfortunately, PHP does not have a regex operator that changes a character to a different case. To accomplish this task, a callback may be used. First, the expression must match all letters that need to be capitalized:

/\b\w/

The above uses both word boundaries and character classes to work. Now that we have this expression, we can write a callback function:

function upper_case( $matches ) {
 return strtoupper( $matches[0] );
}

upper_case takes in an array of matches and returns the whole matched pattern in uppercase. $matches[0], in this case, represents the letter that needs to be capitalized. All of this can now be put together using the preg_replace_callback function:

preg_replace_callback( '/\b\w/', "upper_case", $str );

That is the power of a simple callback.

8. Commenting

Commenting is not a way to actually match strings, but it is one of the most important parts of regular expressions. As you dive deep into larger, more complex expressions, it becomes hard to decipher what is actually being matched. Using comments in the middle of regular expressions is the perfect way to minimize such confusion.

To place a comment inside a regular expression, use the (?#comment) format. Replace “comment” with the word(s) of your choice:

/(?#digit)\d/

It is especially important to comment regular expressions that you release to the public. Users of your regex will be able to easily understand and modify the pattern to meet their needs. It can even go so far as to help you decode it when revisiting a program.

Consider using the “x” or (?x) modifier for free-spacing mode with comments. This causes a regular expression to ignore white space between tokens. All spaces can still be represented with [ ] or \ (a backslash and a space):

/
\d    #digit
[ ]   #space
\w+   #word
/x

The above is the same as:

/\d(?#digit)[ ](?#space)\w+(?#word)/

Always create well-documented code.

Further Resources

• Regular-Expressions.info
  Comprehensive website on regular expressions
• Cheat Sheet
  Informative regular expressions cheat sheet
• Regex Generator
  JavaScript regular expressions generator

About the author

在cu上看到一个帖子：http://bbs2.chinaunix.net/viewthread.php?tid=1469980&extra=&page=1

怎样对一个大文件的某个字节进行直接修改

一、dd命令的解释。

dd：用指定大小的块拷贝一个文件，并在拷贝的同时进行指定的转换。

注意：指定数字的地方若以下列字符结尾则乘以相应的数字：b=512；c=1；k=1024；w=2

参数：

1. if=文件名：输入文件名，缺省为标准输入。即指定源文件。< if=input file >

2. of=文件名：输出文件名，缺省为标准输出。即指定目的文件。< of=output file >

3. ibs=bytes：一次读入bytes个字节，即指定一个块大小为bytes个字节。

    obs=bytes：一次输出bytes个字节，即指定一个块大小为bytes个字节。

    bs=bytes：同时设置读入/输出的块大小为bytes个字节。

4. cbs=bytes：一次转换bytes个字节，即指定转换缓冲区大小。

5. skip=blocks：从输入文件开头跳过blocks个块后再开始复制。

6. seek=blocks：从输出文件开头跳过blocks个块后再开始复制。

注意：通常只用当输出文件是磁盘或磁带时才有效，即备份到磁盘或磁带时才有效。

7. count=blocks：仅拷贝blocks个块，块大小等于ibs指定的字节数。

8. conv=conversion：用指定的参数转换文件。

    ascii：转换ebcdic为ascii

     ebcdic：转换ascii为ebcdic

    ibm：转换ascii为alternate ebcdic

    block：把每一行转换为长度为cbs，不足部分用空格填充

    unblock：使每一行的长度都为cbs，不足部分用空格填充

    lcase：把大写字符转换为小写字符

    ucase：把小写字符转换为大写字符

    swab：交换输入的每对字节

     noerror：出错时不停止

     notrunc：不截短输出文件

    sync：将每个输入块填充到ibs个字节，不足部分用空（NUL）字符补齐。

二、dd应用实例。

1.将本地的/dev/hdb整盘备份到/dev/hdd

   dd if=/dev/hdb of=/dev/hdd

2.将/dev/hdb全盘数据备份到指定路径的image文件

   dd if=/dev/hdb of=/root/image

3.将备份文件恢复到指定盘

   dd if=/root/image of=/dev/hdb

4.备份/dev/hdb全盘数据，并利用gzip工具进行压缩，保存到指定路径

    dd if=/dev/hdb | gzip > /root/image.gz

5.将压缩的备份文件恢复到指定盘

   gzip -dc /root/image.gz | dd of=/dev/hdb

6.备份磁盘开始的512个字节大小的MBR信息到指定文件

   dd if=/dev/hda of=/root/image count=1 bs=512

   count=1指仅拷贝一个块；bs=512指块大小为512个字节。

   恢复：dd if=/root/image of=/dev/hda

7.备份软盘

   dd if=/dev/fd0 of=disk.img count=1 bs=1440k (即块大小为1.44M)

8.拷贝内存内容到硬盘

   dd if=/dev/mem of=/root/mem.bin bs=1024 (指定块大小为1k)  

9.拷贝光盘内容到指定文件夹，并保存为cd.iso文件

   dd if=/dev/cdrom(hdc) of=/root/cd.iso

10.增加swap分区文件大小

第一步：创建一个大小为256M的文件：

dd if=/dev/zero of=/swapfile bs=1024 count=262144

第二步：把这个文件变成swap文件：

mkswap /swapfile

第三步：启用这个swap文件：

swapon /swapfile

第四步：编辑/etc/fstab文件，使在每次开机时自动加载swap文件：

/swapfile    swap    swap    default   0 0

11.销毁磁盘数据

     dd if=/dev/urandom of=/dev/hda1

注意：利用随机的数据填充硬盘，在某些必要的场合可以用来销毁数据。

12.测试硬盘的读写速度

     dd if=/dev/zero bs=1024 count=1000000 of=/root/1Gb.file

      dd if=/root/1Gb.file bs=64k | dd of=/dev/null

通过以上两个命令输出的命令执行时间，可以计算出硬盘的读、写速度。

13.确定硬盘的最佳块大小：

     dd if=/dev/zero bs=1024 count=1000000 of=/root/1Gb.file

     dd if=/dev/zero bs=2048 count=500000 of=/root/1Gb.file

     dd if=/dev/zero bs=4096 count=250000 of=/root/1Gb.file

     dd if=/dev/zero bs=8192 count=125000 of=/root/1Gb.file

通过比较以上命令输出中所显示的命令执行时间，即可确定系统最佳的块大小。

14.修复硬盘：

     dd if=/dev/sda of=/dev/sda 或dd if=/dev/hda of=/dev/hda

当硬盘较长时间(一年以上)放置不使用后，磁盘上会产生magnetic flux point，当磁头读到这些区域时会遇到困难，并可能导致I/O错误。当这种情况影响到硬盘的第一个扇区时，可能导致硬盘报废。上边的命令有可能使这些数 据起死回生。并且这个过程是安全、高效的。

/dev/null，外号叫无底洞，你可以向它输出任何数据，它通吃，并且不会撑着！
/dev/zero,是一个输入设备，你可你用它来初始化文件。

oracle@localhost oracle]$if=/dev/zero of=./test.txt bs=1k count=1
oracle@localhost oracle]$ ls -l
total 4
-rw-r--r--    1 oracle   dba          1024 Jul 15 16:56 test.txt

eg,

    find / -name access_log  2>/dev/null

使用/dev/null
把/dev/null看作"黑洞". 它非常等价于一个只写文件. 所有写入它的内容都会永远丢失. 而尝试从它那儿读取内容则什么也读不到. 然而, /dev/null对命令行和脚本都非常的有用.

禁止标准输出.    1 cat $filename >/dev/null
   2 # 文件内容丢失，而不会输出到标准输出.
 

禁止标准错误 (来自例子 12-3).    1 rm $badname 2>/dev/null
   2 #           这样错误信息[标准错误]就被丢到太平洋去了.
 

禁止标准输出和标准错误的输出.    1 cat $filename 2>/dev/null >/dev/null
   2 # 如果"$filename"不存在，将不会有任何错误信息提示.
   3 # 如果"$filename"存在, 文件的内容不会打印到标准输出.
   4 # 因此Therefore, 上面的代码根本不会输出任何信息.
   5 #
   6 #  当只想测试命令的退出码而不想有任何输出时非常有用。
   7 #
   8 #
   9 # cat $filename &>/dev/null
  10 #     也可以, 由 Baris Cicek 指出.
 

Deleting contents of a file, but preserving the file itself, with all attendant permissions (from Example 2-1 and Example 2-3):    1 cat /dev/null > /var/log/messages
   2 #  : > /var/log/messages   有同样的效果, 但不会产生新的进程.（因为:是内建的）
   3
   4 cat /dev/null > /var/log/wtmp
 

自动清空日志文件的内容 (特别适合处理这些由商业Web站点发送的讨厌的"cookies"):

--------------------------------------------------------------------------------

例子 28-1. 隐藏cookie而不再使用

   1 if [ -f ~/.netscape/cookies ]  # 如果存在则删除.
   2 then
   3   rm -f ~/.netscape/cookies
   4 fi
   5
   6 ln -s /dev/null ~/.netscape/cookies
   7 # 现在所有的cookies都会丢入黑洞而不会保存在磁盘上了.
 

--------------------------------------------------------------------------------

使用/dev/zero
像/dev/null一样, /dev/zero也是一个伪文件, 但它实际上产生连续不断的null的流（二进制的零流，而不是ASCII型的）. 写入它的输出会丢失不见, 而从/dev/zero读出一连串的null也比较困难, 虽然这也能通过od或一个十六进制编辑器来做到. /dev/zero主要的用处是用来创建一个指定长度用于初始化的空文件，就像临时交换文件.

--------------------------------------------------------------------------------

例子 28-2. 用/dev/zero创建一个交换临时文件

   1 #!/bin/bash
   2 # 创建一个交换文件.
   3
   4 ROOT_UID=0         # Root 用户的 $UID 是 0.
   5 E_WRONG_USER=65    # 不是 root?
   6
   7 FILE=/swap
   8 BLOCKSIZE=1024
   9 MINBLOCKS=40
  10 SUCCESS=0
  11
  12
  13 # 这个脚本必须用root来运行.
  14 if [ "$UID" -ne "$ROOT_UID" ]
  15 then
  16   echo; echo "You must be root to run this script."; echo
  17   exit $E_WRONG_USER
  18 fi 
  19  
  20
  21 blocks=${1:-$MINBLOCKS}          #  如果命令行没有指定，
  22                                  #+ 则设置为默认的40块.
  23 # 上面这句等同如：
  24 # --------------------------------------------------
  25 # if [ -n "$1" ]
  26 # then
  27 #   blocks=$1
  28 # else
  29 #   blocks=$MINBLOCKS
  30 # fi
  31 # --------------------------------------------------
  32
  33
  34 if [ "$blocks" -lt $MINBLOCKS ]
  35 then
  36   blocks=$MINBLOCKS              # 最少要有 40 个块长.
  37 fi 
  38
  39
  40 echo "Creating swap file of size $blocks blocks (KB)."
  41 dd if=/dev/zero of=$FILE bs=$BLOCKSIZE count=$blocks  # 把零写入文件.
  42
  43 mkswap $FILE $blocks             # 将此文件建为交换文件（或称交换分区）.
  44 swapon $FILE                     # 激活交换文件.
  45
  46 echo "Swap file created and activated."
  47
  48 exit $SUCCESS
 

--------------------------------------------------------------------------------

关于 /dev/zero 的另一个应用是为特定的目的而用零去填充一个指定大小的文件, 如挂载一个文件系统到环回设备 （loopback device） (参考例子 13-8) 或"安全地" 删除一个文件(参考例子 12-55).

--------------------------------------------------------------------------------

例子 28-3. 创建ramdisk

翻译：http://phplens.com/lens/php-book/optimizing-debugging-php.php

今天翻译着翻译着，已经烦了，看来真的持之以恒做一件事很难，尤其是不太喜欢的事情，我略过和跳过，和翻译错了很多。

为php调试你的web服务器

我们将论述在今天两种非常常用的web服务器如何得到最好的性能，apache1.2和iis，当然也有许多关于服务html的建议。

    Php的作者表示apache2.0相对于apache1.3没有性能和架构的优点，特别是多线程模式，但apache2.0以预分配模式运行的时候，下面的讨论依然有关系（2003年11 21）

（a apache1.3/2.0

apache可以运行在unix和windows上面，它是当今世界最流行的服务器，apache1.3在服务器运行时用了预分配模式，但它启动时，它会创建多个子进程来处理http请求，初始化的父进程间就像一个呵护天使，确保每个子进程工作地顺利同时协调所有的事情，越多的http请求过来，越多的子进程出来处理它们，但http请求慢下来的时候，父进程会杀死一个空闲的进程，为别的进程释放资源，这个模式使得apache非常的健壮，即使一个子进程崩溃了，父进程和别的进程是和这个崩溃的进程独立的。

预分配模式不像别的设计的那么快，但对我来说，服务一个php脚本足够了，当apache性能组织非常重大的影响前还有很多别的瓶颈要找。Apache的健壮性和信赖性非常重要。

Apace2.0提供了在执行时采用多线程模式，我的测试表明在这种模式下只有一点性能上的优点。当然好多php的扩展部兼容。Apache2.0.47（2003）。

Apache的配置使用httpd.conf，下面的参数在配置子进程的时候非常重要。

如果是大一点的网站，值设置成下面的会好一点：

MinSpareServers 32

MaxSpareServers 64

Apache在windows有点不一样，它不是用子进程，而是用线程，上面的参数将不会用到，相比我们有一个参数：ThreadsPerChild，默认的是50，这个参数表示apache可以多少个线程交换.在windows的版主中只有一个子进程，默认的设置成50   当前只可以处理50个请求。但web服务器经历高的网络流量时，增加它在256和1024之间，一些有用的参数你可以改变，包括如下：

如果你不需要dns轮询同时你不需要httaccess文件配置你的apache设置你可以设置的私人的目录：

# 禁用dns轮询php脚本只得到ip地址 

HostnameLookups off

# 关闭htaccess的检查

<Directory />

AllowOverride none

</Directory>

但有符号链接的时候，如果你不担心路径的安全，打开FollowSymLinks，关闭SymLinksIfOwnerMatch，防止多余的lstat系统调用，当创造的时候。

Options FollowSymLinks

#Options SymLinksIfOwnerMatch

(b iis 的调试：

跳过

在windows下的高性能：iis和fastcgi
通过多次测试，我发现在windows下最好的性能是iis用fastcgi方式，cgi是个协议为服务器调用其他程序，它不快，因为每次页面请求完后，他就中止了，fastcgi为了高性能，修改了这个协议，使得每个页面请求完，cgi程序永久的，当心的页面过来时重新使用这个程序。

Php4’s zend engine

简略的：工作模式如下：

Php脚本被zend engine加载，编译到zend opcode，执行代码的缩写代码，低级的二进制指令，opcode被执行后，生成html发送到客户端。执行时opcode将被在内存中刷新。

今天有多种产品和技术帮助你加速这个进程，下图我们展现php脚本的工作方式，每个方框都是功能。

中间能加缓存的就加吧，如

一、eAccelerator

二、APC

三、XCache

四 PHP Accelerator

提供如下几个图

翻译：http://phplens.com/lens/php-book/optimizing-debugging-php.php

Php是一门快速的web编程开发语言，远比php代码的执行的速度还有更多需要我们的优化，

这作者的文章中将给你介绍优化你的php有许多和编码不相关的多个因素，调试我们的php需要我们理解更多的和php运行相关的东西，如服务器，找出问题的瓶颈，修复他们，这里将讲述如何调试优化他们，使他们执行的更快。

       获得更好的性能

       当我们将好的性能的时候，我们不止是讲你的脚步运行的有多快，性能是你的架构和速度之间的平衡，脚步可能用少的资源可能比缓存的执行要慢，但是多个复制的同一个脚步在一个服务器上可以同时执行。

       在下面的例子中，A.php是一个短跑的能跑的很快，但是B.php则是一个马拉松选手在一个很长的时间内跑同样的速度，负载比较轻的情况下，A.php相继会很快，但是网络流量增加时，当A.php跑完了气力的时候B.php只是降低了一点。

让我们举更现实的例子来阐述的更透彻，假设我们需要写一个php的脚本，来读取一个250k的文件来生成一个html的大致内容，写两个php来做同样一个事情，hare.php读取一次整个文件到内存，一次性处理文件，tortoise.php读文件，一次读取一行，使内存中不保留更多的内容，tortoise.php但多次读取的时候会变慢，需要更多的系统的调用，hare.php需要0.04秒和10m的ram，toroise.php需要0.06秒和5m的ram，服务器有100m的空内存，这时cpu是99%的空闲，简单的假设没有内存碎片。

    跑10次脚本，hare.php会内存泄漏，在这个时候toroise还有50m的空闲内存，当低11次的时候，hare.php不得不去请开始虚拟内存交换，这使得他的速度将会减少为原来的一般，每次hare.php的执行，将花费cpu的0.08秒，同时，toroise.php将会继续保持原来的0.06秒，在下表中，在不同的负载下快的php将会用粗体标出：

从上面的例子我们将看出，获得好的性能，不仅关系到写好的php脚本，高性能的php需要理解硬件，操作系统，以及他支持的软件，如服务器，数据库。

瓶颈

       上面的share和tororse的例子说明了瓶颈导致慢了下来，有无限多的ram的时候hare.php将会永远的比tortoize.php快，不幸的是，上面的例子有点简单，除了ram还有许多瓶颈影响。

(a)    网络

你的网络将是最大的瓶颈，假设你有10m的连接到因特网上，你能在一秒钟输出1m字节的数据，如果一个页面是30k，只需要一秒钟33个页面就使得你饱和，许多微妙的网络瓶颈包括正常的请求到慢的服务如，dns，分配不够多的内存给网络软件，

(b) cpu

如果你监视你的cpu负载，通过网络发送一个html页面，不单单要耗费你的cpu，就像我们提到的瓶颈是网络，但是php生成的复杂的动态页面，你的cpu的速度将会变成有限度的因素，多核处理器或者服务器集群能做到。

(c) 共享内存

共享内存是用在进程内的交换，在多进程中存储资源，比如缓存数据和代码，如果内存分配的不足，任何连接这些用于内存共享，如数据库连接，代码执行等资源都会有很差的性能。

(d) 文件系统

    从硬盘中读取数据要比ram中慢50到100倍，文件缓存用ram能完成这些，尽管低内存的状态讲减少文件缓存中内存利用的次数，文件系统当然也会带来系统碎片，降低硬盘的读取，过多的使用符号链接在unix系统中将减慢硬盘的读取。

（e）进程管理

在一些操作系统中，比如windows中创建一个新进程将是一个很慢的操作，这就意味这cgi程序需要创建一个新进程在每一个激活的连接中，在这些操作系统中这将非常的慢，在多线程下跑php可能提高反应的时间。（注：老版本的php在多线程下不稳定）。

在你的服务器中避免过多的不需要的进程，比如，如果你的服务器只做web服务器，避免跑甚至装x-winows在机器上，在windows上，避免跑微软的查找部分，和三维的屏保会导致cpu100%.

一些程序包括你考虑移除掉没有用的网络协议，邮件服务器，杀毒扫描，硬件鼠标驱动，红外线端口，等，在unix下，加入你连接你的服务器你用ssh，你可以考虑卸载掉一下：一些守护进程如: telnetd, inetd, atd, ftpd, lpd, sambad,发送邮件的接受mail，portmap for NFS
xfs, fvwm, xinit, X。

你可以禁用一些各种各样的服务通过修改启动文件，这些文件通常保存在/etc/init* 或者/etc/rc*/init*文件下下。

同时查看下你的crontab文件，你是否需要移除他们，或者重新规划。

（f）连接其他服务器

如果你的web服务器需要在其他服务器上运行，可能那些服务器就会成为瓶颈，追普通的例子就是一个很慢的数据库服务器为多个web服务器上的多个复杂的sql语句进行服务。

花絮：何时优化程序？

有些人认为拖延到编码完成时进行，这个建议如果是你的编程团队有高质量的编程，你也对你的应用程序有高效的参数有感觉，这样才会很有意义，不然你将会把你推到重写你的部分代码的风险上，在测试后。

我的建议是在设计软件前，你应该做一些基础的测试在你的硬件和软件上，以来得到一些最大的性能，然后你可以设计开发应用程序，期望的参数在脑中，因为每一步，他将会平衡在性能，可用性，安全性，灵活性。

选择好的测试数据，如果你的数据期望存贮100，000条记录，避免只测试100条记录，不然你将会后悔，这曾经发生 在我们公司的一个程序员身上，我们没有检查这个慢的代码，到了后来，导致花费很多时间去重写许多能工作但是不易扩展的代码