编译.
../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条记录，不然你将会后悔，这曾经发生 在我们公司的一个程序员身上，我们没有检查这个慢的代码，到了后来，导致花费很多时间去重写许多能工作但是不易扩展的代码

然后在学习的过程中，发现一篇更好的文章
http://lserinol.blogspot.com/2009/03/speeding-up-your-nginx-server-with.html
nginx 的memcache的modual，豆瓣就是用的这个缓存小图片，减少磁盘的io操作，Serving content from memory will be faster than serving it from disk
首先需要定义一个反向代理请求的的server，
92.168.2.3 的性能要比
92.168.2.4的好，所以我们他的权重写一些。

upstream backend {
     server 192.168.2.3 weight=2;
     server 192.168.2.4;
} 

然后写他的配置文件 ：

location ~* \.(jpg|png|gif)$ {
access_log   off;
expires      max;
add_header   Last-Modified "Thu, 26 Mar 2000 17:35:45 GMT";
set $memcached_key $uri;
memcached_pass     127.0.0.1:11211;
error_page         404 = /fetch;
}
把图片文件重定向过来，然后查找在memcache中是否存在，不存在调到404,然后404错误页面会找到fetch
location /fetch {
internal;
access_log   off;
expires      max;
add_header   Last-Modified "Thu, 26 Mar 2000 17:35:45 GMT";
proxy_pass http://backend;
break;
}
然后fetch就会反向代理到后端backend后面。这时候就需要负载均衡到相应的server。可以看出他的原生的memcache只能
获取，而不能设置，所以我们需要自己手工完成如对图片存贮到memcache ，写个对应的脚本：

<?php

function rscandir($base='', &$data=array()) {
$array = array_diff(scandir($base), array('.', '..'));

foreach($array as $value) :
  if (is_dir($base.$value)) {
    $data = rscandir($base.$value.'/', $data);

  }
  elseif (is_file($base.$value)) {
   $rest = substr($value, -4);
   if ((!strcmp($rest,'.jpg')) || (!strcmp($rest,'.png'))
                                || (!strcmp($rest,'.gif')) ){
         $data[] = $base.$value;
   }
 }

endforeach;
return $data;
}

$mylist=rscandir("/var/www/mysite");

$srch = array('/var/www/mysite');
$newval = array('');

$memcache_obj = memcache_connect("192.168.2.1", 11211);

while (list($key, $val) = each($mylist)) {
  $url=str_replace($srch,$newval,$val);
  echo "$key => $val -> ".filesize($val)."\n";
  $value = file_get_contents($val);
  memcache_add($memcache_obj, $url, $value, false, 0);
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>

int main( void )
  {
    struct stat buf;

    if( stat( "file", &buf ) != -1 ) {
      printf( "File size = %d\n", buf.st_size );
    }
    return EXIT_SUCCESS;


  }