耍了一段时间的Ubuntu，现在又换回Windows了。

   最终还是得出结论Windows的易用性才是最好的！    

   起初是因为想认识一下传说中的Linux之Ubuntu到底有多酷。不可否认，Ubuntu确实已经做得很完美了！界面做得很好，某些方面确实可以说超过Windows。但它毕竟属于Linux，想操纵它你必须懂Linux，必须熟悉命令行，必须认识Shell。否则，真就像开车只打最底档。

   刚接触Linux时，安装过Ubuntu，但由于对Linux没什么认识，很难接触那种操作和思路。公司有很多Ubuntu高手，难道我就用都用不会吗？  慢慢的，熟了。我重新安装了Ubuntu！这次，很顺利，用了公司内部的源，更新超快，非常爽！而且每天都会有新的发现。舒服了一阵子，经常设法把平常用习惯了的Windows软件移到Ubuntu下。很多Windows的软件都有Ubuntu版本，Ubuntu还有个Wine程序可以模拟Windows系统环境，可以安装和运行一些Windows程序。

   就这样，我一些办公软件也移到Ubuntu下了，唯必须的.net framework移不过去。

  那当然，如果连.net framework都移过去了，那微软还吃什么啊？！

   回头想想，为什么要移呢？你不是正要使用Linux吗？那么想要Windows软件，直接使用Windows就可以啦……  

   这些都不是我换回Windows，因为Ubuntu的多桌面、3D桌面、方便的命令行、更安全，感觉也挺好挺自在的。

   不幸的是，昨天我在Ubuntu下发了一个报告。结果报告在某些人机器上显示乱码（编码不对）。其实根本原因是由于当时我想在邮件里插入一个表格，“雷鸟”没有这个功能，而且从OpenSource里复制出来的表格显示有点问题，最好还是用了Excel搞定了。文字编辑还是在OpenSource里搞定的，贴粘“雷鸟”时编码实际上已经错了。

   今天，我转发一个邮件，又出现图片和文字分享的情况。我十分的郁闷！发个邮件都这么复杂么？！  

   我还是没有换到Windows下，接着我找了一些其它邮件客户端，据说“雷鸟”还是非常好用的，汗一个！

   此刻，我的Ubuntu正在播放音乐。看到乱码的显示，我回想起“不是ubuntu不如Windows，而是Windows乱来，创造自己的格式”。音乐播放器里显示的是MP3文件里的信息，由于编码不一样，一些在Windows下的MP3文件在Ubuntu下不能正确显示，全部显示为乱码。在Ubuntu下执行一个命令转换一下就可以正常显示了，不过被转换的文件返回Windows后，在Windows下又显示为“?????”了。   或许，Windows很有嫌疑也很有可能，或者根本就是事实。

   但现在绝大部分人都在用Windows，我的东东，在我的机器上正常显示，在别人机器上不正常。别人看到的只是你的不对，有多少人知道Ubuntu呢？又有多少人知道错误的根本原因呢？于是，我返回了Windows。

   刚返回Windows不久，又一封邮件显示错位（在别人机器上）。原因：MS Internet Explorer的混淆解析。在Mozilla Firefox和一些开源的邮件客户端中显示错位。这个邮件内容肯定是从其它编辑器里复制出来的，Hoho....   

   算了，还有更多更重要的事等着做了，不想在这上面再花多时间了，还是用回我的FoxMail吧，还是国产免费软件呢！

功能测试是开发周期的一个阶段，在这个阶段中将测试软件应用程序以确保软件的函数如预期的那样，同时能正确处理代码中错误。此项工作通常在单个模块的单元测试结束之后，在负载／重压条件下整个产品的系统测试之前进行的。

市场上有许多测试工具提供了有助于功能测试的功能。然而，首先要获取它们，然后再安装、配置，这将占用您宝贵的时间和精力。Bash 可以帮您免去这些烦琐的事从而可以加快测试的进程。

使用 Bash shell 脚本进行功能测试的优点在于：

• Bash shell 脚本已经在 Linux 系统中安装和配置好了。不必再花时间准备它。
• 可以使用由 Linux 提供的文本编辑器如 vi 创建和修改 Bash shell 脚本。不需要再为创建测试程序而获取专门的工具。
• 如果已经知道了如何开发 Bourne 或 Korn shell 脚本，那对于如何运用 Bash shell 脚本已经足够了。对您来说，学习曲线已不存在了。
• Bash shell 提供了大量的编程构造用于开发从非常简单到中等复杂的脚本。

将脚本从 Korn 移植到 Bash 时的建议

如果已有现成的 Korn shell 脚本，而想要将它们移植到 Bash，就需要考虑下列情况：

• Korn 的 "print" 命令在 Bash 中不能使用；而是改为使用 "echo" 命令。
• 需要将脚本的第一行：
  #!/usr/bin/ksh
  修改成：
  #!/bin/bash

创建 Bash shell 脚本进行功能测试

这些基本的步骤和建议适用于许多在 Linux 上运行的客户机／服务器应用程序。

1. 记录运行脚本的先决条件和主要步骤
2. 将操作分成若干个逻辑组
3. 基于一般方案制定执行步骤
4. 在每个 shell 脚本中提供注释和说明
5. 做一个初始备份以创建基准线
6. 检查输入参数和环境变量
7. 尝试提供 "usuage" 反馈
8. 尝试提供一个“安静”的运行模式
9. 当出现错误时，提供一个函数终止脚本
10. 如可能，提供可以执行单个任务的函数
11. 当显示正在生成的输出时，捕获每个脚本的输出
12. 在每个脚本内，捕获每个行命令的返回码
13. 计算失败事务的次数
14. 在输出文件中，突出显示错误消息，以便于标识
15. 如有可能，“实时”生成文件
16. 在执行脚本的过程中提供反馈
17. 提供脚本执行的摘要
18. 提供一个容易解释的输出文件
19. 如有可能，提供清除脚本及返回基准线的方法

下面详细讲述了每一条建议以及用于说明问题的脚本。

1. 记录运行脚本的先决条件和主要步骤
记录，尤其是以有自述标题的单个文件（例如 "README-testing.txt"）记录功能测试的主要想法是很重要的，包括，如先决条件、服务器和客户机的设置、脚本遵循的整个（或详细的）步骤、如何检查脚本的成功／失败、如何执行清除和重新启动测试。

2. 将操作分成若干个逻辑组
如果仅仅执行数量非常少的操作，可以将它们全部放在一个简单的 shell 脚本中。

但是，如果需要执行一些数量很多的操作，那最好是将它们分成若干个逻辑集合，例如将一些服务器操作放在一个文件而将客户机操作放在在另一个文件中。通过这种方法，划分适当的颗粒度来执行测试和维护测试。

3. 基于一般方案制定执行步骤
一旦决定对操作进行分组，需要根据一般方案考虑执行操作的步骤。此想法是模拟实际生活中最终用户的情形。作为一个总体原则，只需集中测试 80% 最常调用函数的 20% 用法即可。

例如，假设应用程序要求 3 个测试组以某个特定的顺序排列。每个测试组可以放在一个带有自我描述文件名（如果可能）的文件中，并用号码来帮助识别每个文件的顺序，例如：

1.  fvt-setup-1:    To perform initial setup.
2.  fvt-server-2:   To perform server commands.
3.  fvt-client-3:   To perform client commands.
4.  fvt-cleanup:    To cleanup the temporary files, 
                        in order to prepare for the repetition
                        of the above test cases.

4. 在每个 shell 脚本中提供注释和说明
在每个 shell 脚本的头文件中提供相关的注释和说明是一个良好的编码习惯。这样的话，当另一个测试者运行该脚本时，测试者就能清楚地了解每个脚本中测试的范围、所有先决条件和警告。

下面是一个 Bash 脚本 "test-bucket-1" 的示例 。

#!/bin/bash
#
# Name: test-bucket-1
#
# Purpose:
#    Performs the test-bucket number 1 for Product X.
#    (Actually, this is a sample shell script, 
#     which invokes some system commands 
#     to illustrate how to construct a Bash script) 
#
# Notes:
# 1) The environment variable TEST_VAR must be set 
#    (as an example).
# 2) To invoke this shell script and redirect standard 
#    output and standard error to a file (such as 
#    test-bucket-1.out) do the following (the -s flag 
#    is "silent mode" to avoid prompts to the user):
#
#    ./test-bucket-1  -s  2>&1  | tee test-bucket-1.out
#
# Return codes:
#  0 = All commands were successful
#  1 = At least one command failed, see the output file 
#      and search for the keyword "ERROR".
#
########################################################

5. 做一个初始备份以创建基准线
您可能需要多次执行功能测试。第一次运行它时，也许会找到脚本或进程中的一些错误。因而，为了避免因从头重新创建服务器环境而浪费大量时间 -- 特别是如果涉及到数据库 -- 您在测试之前或许想做个备份。

在运行完功能测试之后，就可以从备份中恢复服务器了，同时也为下一轮测试做好了准备。

6. 检查输入参数和环境变量
最好校验一下输入参数，并检查环境变量是否设置正确。如果有问题，显示问题的原因及其修复方法，然后终止脚本。

当测试者准备运行脚本，而此时如果没有正确设置脚本所调用的环境变量，但由于发现及时，终止了脚本，那测试者会相当感谢。没有人喜欢等待脚本执行了很久却发现没有正确设置变量。

# --------------------------------------------
# Main routine for performing the test bucket
# --------------------------------------------
CALLER=`basename $0`         # The Caller name
SILENT="no"                  # User wants prompts
let "errorCounter = 0"
# ----------------------------------
# Handle keyword parameters (flags).
# ----------------------------------
# For more sophisticated usage of getopt in Linux, 
# see the samples file: /usr/lib/getopt/parse.bash
TEMP=`getopt hs $*`
if [ $? != 0 ]
then
 echo "$CALLER: Unknown flag(s)"
  usage
fi 
# Note quotes around `$TEMP': they are essential! 
eval set -- "$TEMP"
while true                   
 do
  case "$1" in
   -h) usage "HELP";    shift;; # Help requested
   -s) SILENT="yes";    shift;; # Prompt not needed
   --) shift ; break ;; 
   *) echo "Internal error!" ; exit 1 ;;
  esac
 done
# ------------------------------------------------
# The following environment variables must be set
# ------------------------------------------------
if [ -z "$TEST_VAR" ]
then
  echo "Environment variable TEST_VAR is not set."
  usage
fi 

关于此脚本的说明如下：

• 使用语句 CALLER=`basename $0` 可以得到正在运行的脚本名称。这样的话，无须在脚本中硬编码脚本名称。因此当复制脚本时，采用新派生的脚本可以减少工作量。
• 调用脚本时，语句 TEMP=`getopt hs $*` 用于得到输入变量（例如 -h 代表帮助，-s 代表安静模式）。
• 语句 [ -z "$X" ] 和 echo "The environment variable X is not set." 以及 usage 都是用于检测字符串是否为空 (-z)，如果为空，随后就执行 echo 语句以显示未设置字符串并调用下面要讨论的 "usage" 函数。
• 若脚本未使用标志，可以使用变量 "$#"，它可以返回正在传递到脚本的变量数量。

7. 尝试提供“usage”反馈
脚本中使用 "usage" 语句是个好主意，它用来说明如何使用脚本。

# ----------------------------
# Subroutine to echo the usage
# ----------------------------
usage()
{
 echo "USAGE: $CALLER [-h] [-s]"
 echo "WHERE: -h = help       "
 echo "       -s = silent (no prompts)"
 echo "PREREQUISITES:"
 echo "* The environment variable TEST_VAR must be set,"
 echo "* such as: "
 echo "   export TEST_VAR=1"
 echo "$CALLER: exiting now with rc=1."
  exit 1
}

调用脚本时，使用“-h”标志可以调用 "usage" 语句，如下所示：
./test-bucket-1 -h

8. 尝试使用“安静”的运行模式
您或许想让脚本有两种运行模式：

• 在 "verbose" 模式（您也许想将此作为缺省值）中提示用户输入值，或者只需按下 Enter 继续运行。
• 在 "silent" 模式中将不提示用户输入数据。

下列摘录说明了在安静模式下运用所调用标志 "-s" 来运行脚本：

# -------------------------------------------------
# Everything seems OK, prompt for confirmation
# -------------------------------------------------
if [ "$SILENT" = "yes" ]
then
 RESPONSE="y"
else
 echo "The $CALLER will be performed."
 echo "Do you wish to proceed [y or n]? "
 read RESPONSE                  # Wait for response
 [ -z "$RESPONSE" ] && RESPONSE="n"
fi 
case "$RESPONSE" in
 [yY]|[yY][eE]|[yY][eE][sS])
 ;;
 *)
  echo "$CALLER terminated with rc=1."
  exit 1
 ;;
esac

9. 当出现错误时，提供一个函数终止脚本
遇到严重错误时，提供一个中心函数以终止运行的脚本不失为一个好主意。此函数还可提供附加的说明，用于指导在此情况下应做些什么：

# ----------------------------------
# Subroutine to terminate abnormally
# ----------------------------------
terminate()
{
 echo "The execution of $CALLER was not successful."
 echo "$CALLER terminated, exiting now with rc=1."
 dateTest=`date`
 echo "End of testing at: $dateTest"
 echo ""
  exit 1
}

10. 如有可能，提供可以执行简单任务的函数
例如，不使用许多很长的行命令，如：

# --------------------------------------------------
echo ""
echo "Creating Access lists..."
# --------------------------------------------------
 Access -create -component Development -login ted -authority plead -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component Development -login ted 
    -authority plead"
     let "errorCounter = errorCounter + 1" 
 fi
 Access -create -component Development -login pat -authority general -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component Development -login pat 
    -authority general"
     let "errorCounter = errorCounter + 1" 
 fi
 Access -create -component Development -login jim -authority general -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component Development -login jim 
    -authority general"
     let "errorCounter = errorCounter + 1" 
 fi

……而是创建一个如下所示的函数，此函数也可以处理返回码，如果有必要，还可以增加错误计数器：

CreateAccess()
{
 Access -create -component $1 -login $2 -authority $3 -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component $1 -login $2 -authority $3"
     let "errorCounter = errorCounter + 1" 
 fi
}

……然后，以易读和易扩展的方式调用此函数：

# ------------------------------------------- 
echo ""
echo "Creating Access lists..."
# ------------------------------------------- 
CreateAccess Development ted    projectlead
CreateAccess Development pat    general
CreateAccess Development jim    general

11. 当显示正在生成的输出时，捕获每个脚本的输出
如果脚本不能自动地将输出发送到文件的话，可以利用 Bash shell 的一些函数来捕获所执行脚本的输出，如：

./test-bucket-1  -s  2>&1  | tee test-bucket-1.out

让我们来分析上面的命令：

• "2>&1" 命令：

  使用 "2>&1" 将标准错误重定向到标准输出。字符串 "2>&1" 表明任何错误都应送到标准输出，即 UNIX/Linux 下 2 的文件标识代表标准错误，而 1 的文件标识代表标准输出。如果不用此字符串，那么所捕捉到的仅仅是正确的信息，错误信息会被忽略。

• 管道 "|" 和 "tee" 命令：

  UNIX/Linux 进程和简单的管道概念很相似。既然这样，可以做一个管道将期望脚本的输出作为管道的输入。下一个要决定的是如何处理管道所输出的内容。在这种情况下，我们会将它捕获到输出文件中，在此示例中将之称为 "test-bucket-1.out"。

  但是，除了要捕获到输出结果外，我们还想监视脚本运行时产生的输出。为达到此目的，我们连接允许两件事同时进行的 "tee" （T- 形管道）：将输出结果放在文件中同时将输出结果显示在屏幕上。 其管道类似于：

  process --> T ---> output file | V screen

  
  

  如果 只 想捕获输出结果而不想在屏幕上看到输出结果，那可以忽略多余的管道： ./test-bucket-1 -s 2>&1 > test-bucket-1.out

  假若这样，相类似的管道如下：

  process --> output file

  
  

12. 在每个脚本内，捕获每个行命令所返回码
决定功能测试成功还是失败的一种方法是计算已失败行命令的数量，即返回码不是 0。变量 "$?" 提供最近所调用命令的返回码；在下面的示例中，它提供了执行 "ls" 命令的返回码。

# -------------------------------------------
# The commands are called in a subroutine 
# so that return code can be
# checked for possible errors.
# -------------------------------------------
ListFile()
{ 
 echo "ls -al $1"
 ls -al $1
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in: ls -al $1"
     let "errorCounter = errorCounter + 1" 
fi 
} 

13. 记录失败事务的次数
在功能测试中决定其成功或失败的一个方法是计算返回值不是 0 的行命令数量。但是，从我个人的经验而言，我习惯于在我的 Bash shell 脚本中仅使用字符串而不是整数。在我所参考的手册中没有清楚地说明如何使用整数，这就是我为什么想在此就关于如何使用整数和计算错误（行命令失败）数量的方面多展开讲的原因：

首先，需要按如下方式对计数器变量进行初始化：

let "errorCounter = 0"

然后，发出行命令并使用 $? 变量捕获返回码。如果返回码不是 0，那么计数器增加 1（见蓝色粗体语句）：

ListFile()
{
 echo "ls -al $1"
 ls -al $1
  if [ $? -ne 0 ] 
  then 
  
        echo "ERROR found in: ls -al $1"
  let "errorCounter = errorCounter + 1"
 fi
}
      

顺便说一下，与其它变量一样，可以使用 "echo" 显示整数变量。

14. 在输出文件中，为了容易标识，突出显示错误消息
当遇到错误（或失败的事务）时，除了错误计数器的数量会增加外，最好标识出此处有错。较理想的做法是，字符串有一个如 ERROR 或与之相似的子串（见蓝色粗体的语句），这个子串允许测试者很快地在输出文件中查找到错误。此输出文件可能很大，而且它对于迅速找到错误非常重要。

ListFile()
{
 echo "ls -al $1"
 ls -al $1
  if [ $? -ne 0 ] 
  then 
  
        echo "ERROR found in: ls -al $1"
     let "errorCounter = errorCounter + 1" 
 fi
}
      

15. 如有可能，“实时”生成文件
在某些情况下，有必要处理应用程序使用的文件。可以使用现有文件，也可以在脚本中添加语句来创建文件。如果要使用的文件很长，那最好将其作为独立的实体。如果文件很小而且内容简单或不相关（重要的一点是文本文件而不考虑它的内容），那就可以决定“实时”创建这些临时文件。

下面几行代码显示如何“实时”创建临时文件：

cd $HOME/fvt
echo "Creating file softtar.c"
echo "Subject: This is softtar.c" >  softtar.c
echo "This is line 2 of the file" >> softtar.c

第一个 echo 语句使用单个的 > 强行创建新文件。第二个 echo 语句使用两个 >> 将数据附加到现有文件的后面。顺便说一下，如果该文件不存在，那么会创建一个文件。

16. 在执行脚本的过程中提供反馈
最好在脚本中包含 echo 语句以表明它执行的逻辑进展状况。可以添加一些能迅速表明输出目的的语句。

如果脚本要花费一些时间执行，那或许应在执行脚本的开始和结束的地方打印时间。这样可以计算出所花费的时间。

在脚本样本中，一些提供进展说明的 echo 语句如下所示：

# --------------------------------------------
echo "Subject: Product X, FVT testing"
dateTest=`date`
echo "Begin testing at: $dateTest"
echo ""
echo "Testcase: $CALLER"
echo ""
# --------------------------------------------
# --------------------------------------------
echo ""
echo "Listing files..."
# --------------------------------------------
# The following file should be listed:
ListFile   $HOME/.profile
...
# --------------------------------------------
echo ""
echo "Creating file 1"
# --------------------------------------------

17. 提供脚本执行的摘要
如果正在计算错误或失败事务的次数，那最好表明是否有错误。此方法使得测试者在看到输出文件的最后能迅速地辨认出是否存在错误。

在下面的脚本示例中，代码语句提供了上述脚本的执行摘要：

# --------------
# Exit
# --------------
if [ $errorCounter -ne 0 ]
then
 echo ""
 echo "*** $errorCounter ERRORS found during ***"
 echo "*** the execution of this test case.  ***"
 terminate
else
 echo ""
 echo "*** Yeah! No errors were found during ***"
 echo "*** the execution of this test case. Yeah! ***"
fi 
echo ""
echo "$CALLER complete."
echo ""
dateTest=`date`
echo "End of testing at: $dateTest"
echo ""
exit 0
# end of file

18. 提供一个容易解释的输出文件
在脚本生成的实际输出中提供一些关键信息是非常有用的。那样，测试者就可以很容易地确定正在查看的文件是否与自己所做的相关以及它是否是当前产生的。附加 的时间戳记对于是否是当前状态是很重要的。摘要报告对于确定是否有错误也是很有帮助的；如果有错误，那么测试者就必须搜索指定的关键字，例如 ERROR，并确认出个别失败的事务。

以下是一段输出文件样本的片段：

Subject: CMVC 2.3.1, FVT testing, Common, Part 1 
Begin testing at: Tue Apr 18 12:50:55 EDT 2000   
                                                 
Database: DB2                                    
Family:   cmpc3db2                               
Testcase: fvt-common-1                           
                                                 
                                                 
Creating Users...                                
User pat was created successfully.               
...
Well done! No errors were found during the 
execution of this test case :)
                                                                           
fvt-common-1 complete.                                                      
                                                                            
End of testing at: Tue Apr 18 12:56:33 EDT 2000

当遇到错误时输出文件最后部分的示例如下所示：

ERROR found in Report -view DefectView
*** 1 ERRORS found during the execution of this test case. ***           
The populate action for the CMVC family was not successful.               
Recreating the family may be necessary before 
running fvt-client-3 again, that is, you must use 'rmdb', 
'rmfamily', 'mkfamily' and 'mkdb -d',       
then issue: fvt-common-1 and optionally, fvt-server-2.                    
fvt-client-3 terminated, exiting now with rc=1.                           
End of testing at: Wed Jan 24 17:06:06 EST 2001

19. 如有可能，提供清除脚本及返回基准线的方法
测试脚本可以生成临时文件；假若这样，最好能让脚本删除所有临时文件。这就会避免由于测试者也许没有删除所有临时文件而引起的错误，更糟糕的是将所需要的文件当作临时文件而删除了。

运行功能测试的 Bash shell 脚本

本节描述如何运用 Bash shell 脚本进行功能测试。假设您已经执行了在前面部分中所述步骤。

设置必要的环境变量
根据需要在 .profile 中或手工指定下列环境变量。该变量用于说明在脚本中如何处理，所需环境变量的验证必须在脚本执行前定义。

  export TEST_VAR=1

将 Bash shell 脚本复制到正确的目录下
Bash shell 脚本和相关文件需要复制到要进行功能测试的用户标识的目录结构下。

1. 登录进某个帐户。您应该在主目录下。假设它是 /home/tester。
2. 为测试案例创建目录： mkdir fvt
3. 复制 Bash shell 脚本和相关文件。获取压缩文件并将其放在 $HOME 下。然后将其按下列方式解压： unzip trfvtbash.zip
4. 为了执行这个文件，更改文件的许可权： chmod u+x *
5. 更改名称以除去文件的后缀： mv test-bucket-1.bash test-bucket-1

运行脚本
执行下列步骤以运行脚本：

1. 以测试者的用户标识登录
2. 更改目录至所复制脚本的位置： cd $HOME/fvt
3. 从 $HOME/fvt 运行脚本： ./test-bucket-1 -s 2>&1 | tee test-bucket-1.out
4. 看一下输出文件 "test-bucket-1.out" 的尾部并查看摘要报告的结论。

　　在一两年前CPU领域就出现了一个叫做超线程的技术，具备了超线程技术的CPU可以更高效的运行程序，特别是支持对程序的并发执行。而如今在个人计算机和服务器市场又出现了一个叫做双核心CPU的概念，他和超线程有哪些区别?性能提升情况如何呢?他又能否和传统的双CPU画等号呢?我们先要对这三者的概念进行了解。

　　一、三者的工作原理和概念:

　　(1)超线程(HT):

　　超线程(Hyperthreading Technology)技术就是通过采用特殊的硬件指令，可以把两个逻辑内核模拟成两个物理芯片，在单处理器中实现线程级的并行计算，同时在相应的软硬件的支持下大幅度的提高运行效能，从而实现在单处理器上模拟双处理器的效能。其实，从实质上说，超线程是一种可以将CPU内部暂时闲置处理资源充分“调动” 起来的技术。

　　“超线程”的实现条件需要CPU的支持，主板芯片组和主板BIOS的支持，另外操作系统和应用软件方面也需得到应有的支持。说白了超线程就是通过软件的手段模拟出双个逻辑内核进行工作，运行效果尽量接近两个物理核心的性能。

　　不过超线程也存在着致命的不足，首先他在windows 2000下无法使用，因为WIN2000不支持超线程，只有WIN XP以上的系统才可以使用HT。另外由于HT是软件模拟出两个核心，所以模拟出来后的两个核心是分享物理缓存的，从而使物理缓存大小减半，另外因为超线程技术是对多任务处理有优势，因此当运行单线程运用软件时，超线程技术将会降低系统性能，尤其在多线程操作系统运行单线程软件时将容易出现此问题。

　　(2)双核心:

　　所谓双核心处理器，简单地说就是在一块CPU基板上集成两个处理器核心，并通过并行总线将各处理器核心连接起来。双核心并不是一个新概念，而只是CMP(Chip Multi Processors ，单芯片多处理器) 中最基本、最简单、最容易实现的一种类型。

　　换言之双核心处理器就是基于单个半导体的一个处理器上拥有两个一样功能的处理器核心。这样就将两个物理处理器核心整合入一个核中，在任务繁重时，两个核心能相互配合，让CPU发挥最大效力。两个能互补的核心运行起来性能是非常不错的，例如使用Intel奔腾D双核处理器就相当于你有了两台采用奔腾4的主机。

　　如果说超线程是用软件来模拟出双核的效果，那么现在所说的双核心就是真正意义上的两个核心。他弥补了超线程适用系统比较少的缺点，可以广泛用于windows操作系统的多个版本;他还有效的解决了双核运算中出现的缓存分离与数据冲突错误问题。

　　(3)双CPU:

　　前面所说的双核心是在一个处理器里拥有两个处理器核心，核心是两个，但是其他硬件还都是两个核心在共同拥有，而双CPU则是真正意义上的双核心，不光是处理器核心是两个，其他例如缓存等硬件配置也都是双份的。

　　二、三者的布局结构:

　　如果我们把CPU比做一套住房的话，那么超线程技术实际上就相当于把一间房子人为的通过添加屏风或者推拉门来划分成两小间，虽然表面上每间居住者可以自己干自

己的事，不互相影响，但是在出门时都要走同一个大门。

　　而双核心的实际上就相当于一套两居室，房子里有两个屋子，每个屋子都是独立存在的，不互相干扰。出门时也可以各走各的卧室门到大门口。不过如果因为某些原因，例如放音响声音过大等情况，在同一套两居室里的两个屋子之间也会相互影响。

　　接下来我们再看看双CPU，他就是名副其实的两套房子，每个房子有每个房子的大门，我们出入大门不会像超线程那样共用一个门，也不会出现双核心那样一个房间因为某些原因影响另一间，即使某个房子播放音响也不会影响到另外一套房子。

　　不过从价格上讲自己划分出一个房间的超线程无疑是最最便宜的，而需要花费高额银子购买两套房子住的双CPU是最贵的。

　　三、三者运行性能比较:

　　CPU运行性能最关键的就是运行速度，那么究竟这三者在运行速度方面表现如何呢?我们依然通过比喻的方法来区分。

　　假设CPU是一个运输卡车，货物就是我们要计算的信息，CPU运算就类似于卡车运输货物。同一时间运送的货物越多，说明CPU运算能力越强。

　　单CPU系统---相当于一辆卡车在一条车道上跑。由于车少，所以运输能力有限。以往CPU生产厂商都是在不断的提高卡车的载重即主频来提高他的运输能力。

　　双CPU系统---相当于两辆卡车在两条相交的车道上跑。每辆车大部分都在自己的路上跑，但偶尔会相遇、停车避让。由于车多路宽，所以双CPU运输能力最强。

　　HT(超线程)系统---相当于一辆双层卡车在一条车道上跑。由于是双层的，所以猛地一看以为是两辆车在跑，其实只有一辆。不过因为双层涉及到车高以及捆绑等问题，有的时候遇到限高的桥梁，需要人为的将货物卸下，手工搬运。所以说HT超线程适用的条件比较苛刻。

　　双核心CPU系统，相当于两辆卡车在一条车道上跑。虽然他运输的货物能力提高了，而且也不会频繁产生类似于HT超线程那样的冲突，但是因为他们都在一条车道上跑，所以互相避让减速的频率要比双CPU高得多。所以他的运输能力要比真正的双CPU系统差。

对于双核，AMD与Intel的原理略不一样。看下图：

2、CPU发展历史
    CPU的起源可以一直追溯到1971年。在那一年，当时还处在起步阶段的Intel公司推出了世界上第一颗微处理器4004。这不但是第一个用于计算器的4位微处理器，也是第一款个人有能力买得起的电脑处理器！
　　4004含有2300个晶体管，功能相当有限，而且速度还很慢，当时的蓝色巨人IBM以及大部分商业用户对此不屑一顾。但它毕竟是划时代的产品，从此以后，INTEL便与微处理器结下了不解之缘。可以这么说，CPU的历史发展历程一定意义上也就是Intel公司x86系列CPU的发展历程。
    1974年，英特尔公司又在8008的基础上研制出了8080处理器、拥有16位地址总线和8位数据总线，包含7个8位寄存器(A,B,C,D,E,F,G,其中BC,DE,HL组合可组成16位数据寄存器)，支持16位内存，同时它也包含一些输入输出端口，这是一个相当成功的设计，还有效解决了外部设备在内存寻址能力不足的问题。
　　1978年，Intel公司再次领导潮流，首次生产出16位的微处理器，并命名为i8086，同时还生产出与之相配合的数学协处理器i8087，这两种芯片使用相互兼容的指令集，但在i8087指令集中增加了一些专门用于对数、指数和三角函数等的数学计算指令。
    1979年，英特尔公司又开发出了8088。8086和8088在芯片内部均采用16位数据传输，所以都称为16位微处理器，但8086每周期能传送或接收16位数据，而8088每周期只采用8位。因为最初的大部分设备和芯片是8位的，而8088的外部8位数据传送、接收能与这些设备相兼容。
 　　8086和8088问世后不久，英特尔公司就开始对他们进行改进，他们将更多功能集成在芯片上，这样就诞生了80186和80188。这两款微处理器内部均以16位工作，在外部输入输出上80186采用16位，而80188和8088一样是采用8位工作。
　　1981年，美国IBM公司将8088芯片用于其研制的PC机中，从而开创了全新的微机时代。也正是从8088开始，个人电脑(PC)的概念开始在全世界范围内发展起来。从8088应用到IBM PC机上开始,个人电脑真正走进了人们的工作和生活之中，它也标志着一个新时代的开始。
　　1982年，英特尔公司在8086的基础上，研制出了80286微处理器，该微处理器的最大主频为20MHz，内、外部数据传输均为16位，使用24位内存储器的寻址，内存寻址能力为16MB。
　　8086～80286这个时代是个人电脑起步的时代，当时在国内使用甚至见到过PC机的人很少，它在人们心中是一个神秘的东西。到九十年代初，国内才开始普及计算机。
　　1985年春天的时候，英特尔公司已经成为了第一流的芯片公司，它决心全力开发新一代的32位核心的CPU—80386。Intel给80386设计了三个技术要点：使用“类286”结构，开发80387微处理器增强浮点运算能力，开发高速缓存解决内存速度瓶颈。
　　1985年10月17日，英特尔划时代的产品——80386DX正式发布了，其内部包含27.5万个晶体管，时钟频率为12.5MHz，后逐步提高到20MHz、25MHz、33MHz，最后还有少量的40MHz产品。由于32位微处理器的强大运算能力，PC的应用扩展到很多的领域，如商业办公和计算、工程设计和计算、数据中心、个人娱乐。80386使32位CPU成为了PC工业的标准。
　　1989年，我们大家耳熟能详的80486芯片由英特尔推出。这款经过四年开发和3亿美元资金投入的芯片的伟大之处在于它首次实破了100万个晶体管的界限，集成了120万个晶体管，使用1微米的制造工艺。80486的时钟频率从25MHz逐步提高到33MHz、40MHz、50MHz。
   随着芯片技术的不断发展，CPU的频率越来越快，而PC机外部设备受工艺限制，能够承受的工作频率有限，这就阻碍了CPU主频的进一步提高。在这种情况下，出现了CPU倍频技术，该技术使CPU内部工作频率为微处理器外频的2～3倍，486 DX2、486 DX4的名字便是由此而来。
　　1993年，全面超越486的新一代586 CPU问世，为了摆脱486时代微处理器名称混乱的困扰，英特尔公司把自己的新一代产品命名为Pentium(奔腾)以区别AMD和Cyrix的产品。AMD和Cyrix也分别推出了K5和6x86微处理器来对付芯片巨人，但是由于奔腾微处理器的性能最佳，英特尔逐渐占据了大部分市场。
　　为了提高电脑在多媒体、3D图形方面的应用能力，许多新指令集应运而生，其中最著名的三种便是英特尔的MMX、SSE和AMD的3D NOW!。 MMX（MultiMedia Extensions，多媒体扩展指令集）是英特尔于1996年发明的一项多媒体指令增强技术，包括57条多媒体指令，这些指令可以一次处理多个数据，MMX技术在软件的配合下，就可以得到更好的性能。
　　多能奔腾(Pentium MMX)的正式名称就是“带有MMX技术的Pentium”，是在1996年底发布的。从多能奔腾开始，英特尔就对其生产的CPU开始锁倍频了，但是MMX的CPU超外频能力特别强，而且还可以通过提高核心电压来超倍频，所以那个时候超频是一个很时髦的行动。超频这个词语也是从那个时候开始流行的。

3、CPU厂商
        Intel公司的最初取为是由摩尔命名的，“Intel”这个字是由“Integrated Electronics(集成/电子)”两个英文单词組合成的，象征新公司的主要业务将在集成电路市场上。Intel是生产X86架构CPU的老大哥，它占有80%多的市场份额，Intel生产的CPU就成了事实上的x86CPU技术规范和标准。

        AMD公司（Advanced Micro Devices<高级微型仪器>）超微半导体公司

        IBM和Cyrix
        IBM是International Business Machines Corporation<公司>(国际机器公司)的缩写,也就是简称。

        IBM在服务器芯片上一向占有强势地位，但对于微机芯片却迟迟不能打开市场份额。和Cyrix公司合并后，使其终于拥有了自己的X86芯片生产线，其成品将会日益完善和完备。现在的MII性能也不错，尤其是它的价格很低。

        IDT公司
        IDT是处理器厂商的后起之秀，但现在还不太成熟。
        事实上，idt和cyrix已经被中国台湾的via威盛公司所收购。目前威盛公司的cpu产品主要面向嵌入式设备。

        苹果机的CPU厂商
        由IBM供货

        主要的服务器CPU厂商
        主要服务器CPU商包括：SUN，IBM,HP。

         中国的CPU厂商
         中国一向有不少的芯片厂商，但是在通用PC芯片市场上一直没有什么市场份额。0520就是80年代自己生产的286兼容芯片。现在龙芯等芯片也开始进入通用PC的市场。

4、CPU主要的性能指标有：
        对于一个CPU来说，性能是否强大是它能否在市场上生存下去的第一要素，那么CPU的性能是由哪些因素决定的咧？下面就列出影响CPU性能的主要技术指标：

主频
　　CPU的主频，即CPU内核工作的时钟频率（CPU Clock Speed）。通常所说的某某CPU是多少兆赫的，而这个多少兆赫就是“CPU的主频”。很多人认为CPU的主频就是其运行速度，其实不然。CPU的主频表示在CPU内数字脉冲信号震荡的速度，与CPU实际的运算能力并没有直接关系。主频和实际的运算速度存在一定的关系，但目前还没有一个确定的公式能够定量两者的数值关系，因为CPU的运算速度还要看CPU的流水线的各方面的性能指标（缓存、指令集，CPU的位数等等）。由于主频并不直接代表运算速度，所以在一定情况下，很可能会出现主频较高的CPU实际运算速度较低的现象。比如AMD公司的AthlonXP系列CPU大多都能以较低的主频，达到英特尔公司的Pentium 4系列CPU较高主频的CPU性能，所以AthlonXP系列CPU才以PR值的方式来命名。因此主频仅是CPU性能表现的一个方面，而不代表CPU的整体性能。
　　CPU的主频不代表CPU的速度，但提高主频对于提高CPU运算速度却是至关重要的。举个例子来说，假设某个CPU在一个时钟周期内执行一条运算指令，那么当CPU运行在100MHz主频时，将比它运行在50MHz主频时速度快一倍。因为100MHz的时钟周期比50MHz的时钟周期占用时间减少了一半，也就是工作在100MHz主频的CPU执行一条运算指令所需时间仅为10ns比工作在50MHz主频时的20ns缩短了一半，自然运算速度也就快了一倍。只不过电脑的整体运行速度不仅取决于CPU运算速度，还与其它各分系统的运行情况有关，只有在提高主频的同时，各分系统运行速度和各分系统之间的数据传输速度都能得到提高后，电脑整体的运行速度才能真正得到提高。
　　提高CPU工作主频主要受到生产工艺的限制。由于CPU是在半导体硅片上制造的，在硅片上的元件之间需要导线进行联接，由于在高频状态下要求导线越细越短越好，这样才能减小导线分布电容等杂散干扰以保证CPU运算正确。因此制造工艺的限制，是CPU主频发展的最大障碍之一。

前端总线      
    总线是将信息以一个或多个源部件传送到一个或多个目的部件的一组传输线。通俗的说，就是多个部件间的公共连线，用于在各个部件之间传输信息。人们常常以MHz表示的速度来描述总线频率。总线的种类很多，前端总线的英文名字是Front Side Bus，通常用FSB表示，是将CPU连接到北桥芯片的总线。计算机的前端总线频率是由CPU和北桥芯片共同决定的。
    北桥芯片负责联系内存、显卡等数据吞吐量最大的部件，并和南桥芯片连接。CPU就是通过前端总线（FSB）连接到北桥芯片，进而通过北桥芯片和内存、显卡交换数据。前端总线是CPU和外界交换数据的最主要通道，因此前端总线的数据传输能力对计算机整体性能作用很大，如果没足够快的前端总线，再强的CPU也不能明显提高计算机整体速度。数据传输最大带宽取决于所有同时传输的数据的宽度和传输频率，即数据带宽＝（总线频率×数据位宽）÷8。目前PC机上所能达到的前端总线频率有266MHz、333MHz、400MHz、533MHz、800MHz几种，前端总线频率越大，代表着CPU与北桥芯片之间的数据传输能力越大，更能充分发挥出CPU的功能。现在的CPU技术发展很快，运算速度提高很快，而足够大的前端总线可以保障有足够的数据供给给CPU，较低的前端总线将无法供给足够的数据给CPU，这样就限制了CPU性能得发挥，成为系统瓶颈。

外频  
    外频是CPU乃至整个计算机系统的基准频率，单位是MHz（兆赫兹）。在早期的电脑中，内存与主板之间的同步运行的速度等于外频，在这种方式下，可以理解为CPU外频直接与内存相连通，实现两者间的同步运行状态。对于目前的计算机系统来说，两者完全可以不相同，但是外频的意义仍然存在，计算机系统中大多数的频率都是在外频的基础上，乘以一定的倍数来实现，这个倍数可以是大于1的，也可以是小于1的。
    说到处理器外频，就要提到与之密切相关的两个概念：倍频与主频，主频就是CPU的时钟频率；倍频即主频与外频之比的倍数。主频、外频、倍频，其关系式：主频＝外频×倍频。

倍频   
　　CPU的倍频，全称是倍频系数。CPU的核心工作频率与外频之间存在着一个比值关系，这个比值就是倍频系数，简称倍频。理论上倍频是从1.5一直到无限的，但需要注意的是，倍频是以0.5为一个间隔单位。外频与倍频相乘就是主频，所以其中任何一项提高都可以使CPU的主频上升。
　　原先并没有倍频概念，CPU的主频和系统总线的速度是一样的，但CPU的速度越来越快，倍频技术也就应允而生。它可使系统总线工作在相对较低的频率上，而CPU速度可以通过倍频来无限提升。那么CPU主频的计算方式变为：主频 = 外频 x 倍频。也就是倍频是指CPU和系统总线之间相差的倍数，当外频不变时，提高倍频，CPU主频也就越高。
   

   外频与前端总线频率的区别：前端总线的速度指的是CPU和北桥芯片间总线的速度，更实质性的表示了CPU和外界数据传输的速度。而外频的概念是建立在数字脉冲信号震荡速度基础之上的，也就是说，100MHz外频特指数字脉冲信号在每秒钟震荡一万万次，它更多的影响了PCI及其他总线的频率。之所以前端总线与外频这两个概念容易混淆，主要的原因是在以前的很长一段时间里（主要是在Pentium 4出现之前和刚出现Pentium 4时），前端总线频率与外频是相同的，因此往往直接称前端总线为外频，最终造成这样的误会。随着计算机技术的发展，人们发现前端总线频率需要高于外频，因此采用了QDR（Quad Date Rate）技术，或者其他类似的技术实现这个目的。这些技术的原理类似于AGP的2X或者4X，它们使得前端总线的频率成为外频的2倍、4倍甚至更高，从此之后前端总线和外频的区别才开始被人们重视起来。

缓存
　CPU缓存（Cache Memory）位于CPU与内存之间的临时存储器，它的容量比内存小但交换速度快。在缓存中的数据是内存中的一小部分，但这一小部分是短时间内CPU即将访问的，当CPU调用大量数据时，就可避开内存直接从缓存中调用，从而加快读取速度。由此可见，在CPU中加入缓存是一种高效的解决方案，这样整个内存储器（缓存+内存）就变成了既有缓存的高速度，又有内存的大容量的存储系统了。缓存对CPU的性能影响很大，主要是因为CPU的数据交换顺序和CPU与缓存间的带宽引起的。
　　最早先的CPU缓存是个整体的，而且容量很低，英特尔公司从Pentium时代开始把缓存进行了分类。当时集成在CPU内核中的缓存已不足以满足CPU的需求，而制造工艺上的限制又不能大幅度提高缓存的容量。因此出现了集成在与CPU同一块电路板上或主板上的缓存，此时就把 CPU内核集成的缓存称为一级缓存，而外部的称为二级缓存。一级缓存中还分数据缓存（Data Cache，D-Cache）和指令缓存（Instruction Cache，I-Cache）。二者分别用来存放数据和执行这些数据的指令，而且两者可以同时被CPU访问，减少了争用Cache所造成的冲突，提高了处理器效能。

核心类型      
　　核心（Die）又称为内核，是CPU最重要的组成部分。CPU中心那块隆起的芯片就是核心，是由单晶硅以一定的生产工艺制造出来的，CPU所有的计算、接受/存储命令、处理数据都由核心执行。各种CPU核心都具有固定的逻辑结构，一级缓存、二级缓存、执行单元、指令级单元和总线接口等逻辑单元都会有科学的布局。
　　为了便于CPU设计、生产、销售的管理，CPU制造商会对各种CPU核心给出相应的代号，这也就是所谓的CPU核心类型。
    不同的CPU（不同系列或同一系列）都会有不同的核心类型（例如Pentium 4的Northwood，Willamette以及K6-2的CXT和K6-2+的ST-50等等），甚至同一种核心都会有不同版本的类型（例如Northwood核心就分为B0和C1等版本），核心版本的变更是为了修正上一版存在的一些错误，并提升一定的性能，而这些变化普通消费者是很少去注意的。一般说来，新的核心类型往往比老的核心类型具有更好的性能。因此，核心类型在某种程度上决定了CPU的工作性能。

制作工艺   
　　通常我们所说的CPU的“制作工艺”指得是在生产CPU过程中，要进行加工各种电路和电子元件，制造导线连接各个元器件。通常其生产的精度以微米（长度单位，1微米等于千分之一毫米）来表示，未来有向纳米（1纳米等于千分之一微米）发展的趋势，精度越高，生产工艺越先进。在同样的材料中可以制造更多的电子元件，连接线也越细，提高CPU的集成度，CPU的功耗也越小。
　　制造工艺的微米是指IC内电路与电路之间的距离。制造工艺的趋势是向密集度愈高的方向发展。密度愈高的IC电路设计，意味着在同样大小面积的IC中，可以拥有密度更高、功能更复杂的电路设计。微电子技术的发展与进步，主要是靠工艺技术的不断改进，使得器件的特征尺寸不断缩小，从而集成度不断提高，功耗降低，器件性能得到提高。芯片制造工艺在1995年以后，从0.5微米、0.35微米、0.25微米、0.18微米、0.15微米、0.13微米、0.09微米，而0.065微米（65纳米）的制造工艺将是下一代CPU的发展目标。
 
封装技术    
　　所谓“封装技术”是一种将集成电路用绝缘的塑料或陶瓷材料打包的技术。以CPU为例，我们实际看到的体积和外观并不是真正的CPU内核的大小和面貌，而是CPU内核等元件经过封装后的产品。
　　封装对于芯片来说是必须的，也是至关重要的。因为芯片必须与外界隔离，以防止空气中的杂质对芯片电路的腐蚀而造成电气性能下降。另一方面，封装后的芯片也更便于安装和运输。由于封装技术的好坏还直接影响到芯片自身性能的发挥和与之连接的PCB（印制电路板）的设计和制造，因此它是至关重要的。封装也可以说是指安装半导体集成电路芯片用的外壳，它不仅起着安放、固定、密封、保护芯片和增强导热性能的作用，而且还是沟通芯片内部世界与外部电路的桥梁——芯片上的接点用导线连接到封装外壳的引脚上，这些引脚又通过印刷电路板上的导线与其他器件建立连接。因此，对于很多集成电路产品而言，封装技术都是非常关键的一环。

超线程技术
　　超线程技术是在一颗CPU同时执行多个程序而共同分享一颗CPU内的资源，理论上要像两颗CPU一样在同一时间执行两个线程，P4处理器需要多加入一个Logical CPU Pointer（逻辑处理单元）。因此新一代的P4 HT的die的面积比以往的P4增大了5%。而其余部分如ALU（整数运算单元）、FPU（浮点运算单元）、L2 Cache（二级缓存）则保持不变，这些部分是被分享的。
　　虽然采用超线程技术能同时执行两个线程，但它并不象两个真正的CPU那样，每各CPU都具有独立的资源。当两个线程都同时需要某一个资源时，其中一个要暂时停止，并让出资源，直到这些资源闲置后才能继续。因此超线程的性能并不等于两颗CPU的性能。
　　需要注意的是，含有超线程技术的CPU需要芯片组、软件支持，才能比较理想的发挥该项技术的优势。
 
双核心类型     
        在2005年以前，主频一直是两大处理器巨头Intel和AMD争相追逐的焦点。而且处理器主频也在Intel和AMD的推动下达到了一个又一个的高峰就在处理器主频提升速度的同时，也发现在目前的情况下，单纯主频的提升已经无法为系统整体性能的提升带来明显的好处，并且高主频带来了处理器巨大的发热量，更为不利是Intel和AMD两家在处理器主频提升上已经有些力不从心了。在这种情况下，Intel和AMD都不约而同地将投向了多核心的发展方向在不用进行大规模开发的情况下将现有产品发展成为理论性能更为强大的多核心处理器系统，无疑是相当明智的选择。
    双核处理器就基于单个半导体的一个处理器上拥有两个一样功能的处理器核心，即是将两个物理处理器核心整合入一个内核中。事实上，双核架构并不是什么新技术，不过此前双核心处理器一直是服务器的专利，现在已经开始普及之中。

64位技术   
        这里的64位技术是相对于32位而言的，这个位数指的是CPU GPRs（General-Purpose Registers，通用寄存器）的数据宽度为64位，CPU在单位时间内能一次处理的二进制数的位数。64位指令集就是运行64位数据的指令，也就是说处理器一次可以运行64bit数据。64bit计算主要有两大优点：可以进行更大范围的整数运算；可以支持更大的内存。
 

    这个月，我感冒了。初步分析，原因和上述完全一致。

    忽然听说空调温度不能低于气温6度为宜，平常听得耳朵发麻的一句话，让我顿时眼前一亮！

    上次老婆感冒，是我在宿舍，她去外面买菜，当时很热太阳大。周末就感冒严重暴发，这次刚好相反。

    明白、理解往往真是不够的，要尝试，要深刻理解！

    俗话说“三十岁前你找病，三十岁后病找你”。眼前就快奔三了，还是好好珍惜眼前吧  

  现在项目没那么紧，时间却没以前那么多。

  为什么呢？    

  想要配一个PHP环境，至少需要Apache+PHP，这两个组件一般在安装LINUX操作系统的时候就已经安装上了。不过版本已经旧，可以先卸载再安装新版本。

编译Apache

去官方网下载最新版本Apache，解压后进入安装目录：

# ./configure --prefix=/usr/local/apache --enable-so

# make

# make install

# cp /usr/local/apache/bin/* /usr/bin/

# cp /usr/local/apache/bin/apachectl /etc/init.d/httpd

使用编辑器打开httpd文件，并在第一行#!/bin/sh下增加两行文字如下

# chkconfig: 345 80 15

# description: Apache

接着注册该服务

#chkconfig --add httpd

编译PHP   

去官方网下载最新版本PHP，解压后进入安装目录：

# ./configure --prefix=/usr/local/php --with-apxs2=/usr/local/apache/bin/apxs --with-mysql=/usr/local/mysql --with-mysql-sock=/tmp/mysql.sock --with-mysqli=/usr/local/mysql/bin/mysql_config --with-xmlpc --enable-sockets --enable-mbstring --with-pcre-regex --with-ldap=/usr/local/ldap //保证各配置路径是正确的，可手动修改。

# make && make install

# cp /usr/local/php/bin/* /usr/bin

# cp php.ini-dist /usr/local/php/lib/php.ini

# vi /usr/local/apach/conf/httpd.conf

添加如下2行：（添在AddType *** 之后）

AddType application/x-httpd-php .php .phtml .php3 .php4

AddType application/x-httpd-php-source .phps

到此你的PHP环境就配好了，在Apache文档目录新建一个test.PHP文件，内容：“<?phpinfo()?> ”。

此时访问http://ip/test.php如果出现PHP的版本信息，即表示PHP环境配置正常。

1. 从http://www.mysql.com 下载的Mysql安装包   

2.将mysql的压缩包复制到/usr/local/ 目录

    # cp mysql-standard-5.0.15-linux-gnu-i686-glibc23.tar.gz /usr/local

3. 解压缩到/usr/ocal/下并改名为mysql，并为了节省空间，删除mysql安装包

    # tar xzvf mysql-standard-5.0.15-linux-gnu-i686-glibc23.tar.gz

    # mv mysql-standard-5.0.15-linux-gnu-i686-glibc23 mysql

    # rm mysql-standard-5.0.15-linux-gnu-i686-glibc23

4.建立mysql组，建立mysql用户并且加入到mysql组中

    # groupadd mysql

    # useradd mysql -g mysql

5. 覆盖/etc/my.cnf

    # cp /usr/local/mysql/support-files/my-medium.cnf /etc/my.cnf

6. 进入mysql目录初试化表并且规定用mysql用户来访问。初始化表以后就开始给mysql和root用户设定访问权限

    # cd /usr/local/mysql

    # ./scripts/mysql_install_db --user=mysql

7. 设定root能访问/usr/local/mysql

    # chown -R root .

8. 设定mysql用户能访问/usr/local/mysql/data ,里面存的是mysql的数据库文件.这个目录是在/etc/my.cnf中有配置，在mysql_install_db时产生

    # chown -R mysql data

9. 设定mysql用户能访问/usr/local/mysql/data/mysql下的所有文件

    # chown -R mysql data/.

10.设定mysql组能够访问/usr/local/mysql

    # chgrp -R mysql .

11. 运行mysql，如果没有问题的话,应该会出现类似这样的提示:

    [1] 42264

    Starting mysqld daemon with databases from /usr/local/mysql/var

    # /usr/local/mysql/bin/mysqld_safe --user=mysql &

如果出现 mysql ended这样的语句，表示Mysql没有正常启动，你可以到log中查找问题，Log文件的通常在/etc/my.cnf中配置。大多数问题是权限设置不正确引起的。

12. 用如下命令修改MYSQL密

    # /usr/local/mysql/bin/mysqladmin -u root password yourpassword

13. copy编译目录的一个脚本，设置使mysql每次启动都能自动运行

    # cp support-files/mysql.server /etc/rc.d/init.d/mysqld

    # chmod 700 /etc/init.d/mysqld

    # chkconfig --add mysqld

    # chkconfig --level 345 mysqld on

14. 启动mysqld服务  

    # service mysqld start