1． CVS初始化
-------------
（1） 创建CVSROOT根目录
编辑有关的环境变量，加入CVSROOT的定义（比如在 /etc/bashrc 文件中加入下面两行）：
CVSROOT=/usr/local/cvsroot
eXPort CVSROOT
然后在相应位置开始创建CVSROOT
$cd /usr/local/
$mkdir cvsroot
$cvs –d /usr/local/cvsroot init
这时就会产生/usr/local/cvsroot/CVSROOT 目录，这下面放着有关CVS的配置文件。同时/usr/local/cvsroot/也作为文件仓库存放所有的文件。
(2） 创建开发项目
如果从头开始一个新的项目，就需要创建一个单独的目录，并把所有要使用的文件做一个有效的组织。而如果在开始使用源文件的目录之前就有了，则只需进入该目录就行了。
$cd /work/tang
$ls cvstest
. .. c/
$cd cvstest
然后，就可以输入源文件目录：
$cvs import –m “Create Source Dir” cvstest/c tang cvstest
这样会生成 $CVSROOT/cvstest/c 目录。 其中 -m 用来指定注释信息，如果后面在命令行不指定注释信息，则会启动缺省编辑器（vi）要求输入注释信息。 tang, cvstest分别标识了厂商和发行标识。
注意，使用import命令会把当前目录下的所有文件和目录（包括子目录）引入到文件仓库中指定模块（目录）下。
Cvs命令行小结
一个项目的首次导入
cvs import -m "write some comments here" project_name vendor_tag release_tag
执行后：会将所有源文件及目录导入到/path/to/cvsroot/project_name目录下
vender_tag: 开发商标记
release_tag: 版本发布标记
项目导出：将代码从CVS库里导出
cvs checkout project_name
cvs 将创建project_name目录，并将最新版本的源代码导出到相应目录中。这个checkout和Virvual SourceSafe中的check out不是一个概念，相对于Virvual SourceSafe的check out是cvs update， check in是cvs commit。
CVS的日常使用
=============
注意：第一次导出以后，就不是通过cvs checkout来同步文件了，而是要进入刚才cvs checkout project_name导出的project_name目录下进行具体文件的版本同步（添加，修改，删除）操作。
将文件同步到最新的版本
cvs update
不制定文件名，cvs将同步所有子目录下的文件，也可以制定某个文件名/目录进行同步
cvs update file_name
最好每天开始工作前或将自己的工作导入到CVS库里前都要做一次，并养成"先同步 后修改"的习惯，和Virvual SourceSafe不同，CVS里没有文件锁定的概念，所有的冲突是在commit之前解决，如果你修改过程中，有其他人修改并commit到了CVS库中，CVS会通知你文件冲突，并自动将冲突部分用
>>>>>> content on cvs server
<<<<<<
content in your file
>>>>>> 标记出来，由你确认冲突内容的取舍。
版本冲突一般是在多个人修改一个文件造成的，但这种项目管理上的问题不应该指望由CVS来解决。
确认修改写入到CVS库里
cvs commit -m "write some comments here" file_name
注意：CVS的很多动作都是通过cvs commit进行最后确认并修改的，最好每次只修改一个文件。在确认的前，还需要用户填写修改注释，以帮助其他开发人员了解修改的原因。如果不用写-m "comments"而直接确认`cvs commit file_name` 的话，cvs会自动调用系统缺省的文字编辑器(一般是vi)要求你写入注释。
注释的质量很重要：所以不仅必须要写，而且必须写一些比较有意义的内容：以方便其他开发人员能够很好的理解
不好的注释，很难让其他的开发人员快速的理解：比如： -m "bug fixed" 甚至 -m ""
好的注释，甚至可以用中文: -m "在用户注册过程中加入了Email地址校验"
修改某个版本注释：每次只确认一个文件到CVS库里是一个很好的习惯，但难免有时候忘了指定文件名，把多个文件以同样注释commit到CVS库里了，以下命令可以允许你修改某个文件某个版本的注释：
cvs admin -m 1.3:"write some comments here" file_name
添加文件
创建好新文件后，比如：touch new_file
cvs add new_file
注意：对于图片，Word文档等非纯文本的项目，需要使用cvs add -b选项按2进制文件方式导入，否则有可能出现文件被破坏的情况
比如：
cvs add -b new_file.gif
cvs add -b readme.doc
然后确认修改并注释
cvs ci -m "write some comments here"
删除文件
将某个源文件物理删除后，比如：rm file_name
cvs rm file_name
然后确认修改并注释
cvs ci -m "write some comments here"
以上面前2步合并的方法为：
cvs rm -f file_name
cvs ci -m "why delete file"
注意：很多cvs命令都有缩写形式：commit=>ci; update=>up; checkout=>co/get; remove=>rm;
添加目录
cvs add dir_name
查看修改历史
cvs log file_name
cvs history file_name
查看当前文件不同版本的区别
cvs diff -r1.3 -r1.5 file_name
查看当前文件（可能已经修改了）和库中相应文件的区别
cvs diff file_name
cvs的web界面提供了更方便的定位文件修改和比较版本区别的方法，具体安装设置请看后面的cvsweb使用
正确的通过CVS恢复旧版本的方法：
如果用cvs update -r1.2 file.name
这个命令是给file.name加一个STICK TAG： "1.2" ，虽然你的本意只是想将它恢复到1.2版本
正确的恢复版本的方法是：cvs update -p -r1.2 file_name >file_name
如果不小心已经加成STICK TAG的话：用cvs update -A 解决
移动文件/文件重命名
cvs里没有cvs move或cvs rename，因为这两个操作是可以由先cvs remove old_file_name，然后cvs add new_file_name实现的。
删除/移动目录
最方便的方法是让管理员直接移动，删除CVSROOT里相应目录（因为CVS一个项目下的子目录都是独立的，移动到$CVSROOT目录下都可以作为新的独立项目：好比一颗树，其实砍下任意一枝都能独立存活），对目录进行了修改后，要求其开发人员重新导出项目cvs checkout project_name 或者用cvs update -dP同步。
项目发布导出不带CVS目录的源文件
做开发的时候你可能注意到了，每个开发目录下，CVS都创建了一个CVS/目录。里面有文件用于记录当前目录和CVS库之间的对应信息。但项目发布的时候你一般不希望把文件目录还带着含有CVS信息的CVS目录吧，这个一次性的导出过程使用cvs export命令，不过export只能针对一个TAG或者日期导出，比如：
cvs export -r release1 project_name
cvs export -D 20021023 project_name
cvs export -D now project_name
CVS Branch：项目多分支同步开发
=============================
确认版本里程碑：多个文件各自版本号不一样，项目到一定阶段，可以给所有文件统一指定一个阶段里程碑版本号，方便以后按照这个阶段里程碑版本号导出项目，同时也是项目的多个分支开发的基础。
cvs tag release_1_0
开始一个新的里程碑：
cvs commit -r 2 标记所有文件开始进入2.x的开发
注意：CVS里的revsion和软件包的发布版本可以没有直接的关系。但所有文件使用和发布版本一致的版本号比较有助于维护。
版本分支的建立
在开发项目的2.x版本的时候发现1.x有问题，但2.x又不敢用，则从先前标记的里程碑：release_1_0导出一个分支release_1_0_patch
cvs rtag -b -r release_1_0 release_1_0_patch proj_dir
一些人先在另外一个目录下导出release_1_0_patch这个分支：解决1.0中的紧急问题，
cvs checkout -r release_1_0_patch
而其他人员仍旧在项目的主干分支2.x上开发
在release_1_0_patch上修正错误后，标记一个1.0的错误修正版本号
cvs tag release_1_0_patch_1
如果2.0认为这些错误修改在2.0里也需要，也可以在2.0的开发目录下合并release_1_0_patch_1中的修改到当前代码中：
cvs update -j release_1_0_patch_1
-------------
（1） 创建CVSROOT根目录
编辑有关的环境变量，加入CVSROOT的定义（比如在 /etc/bashrc 文件中加入下面两行）：
CVSROOT=/usr/local/cvsroot
eXPort CVSROOT
然后在相应位置开始创建CVSROOT
$cd /usr/local/
$mkdir cvsroot
$cvs –d /usr/local/cvsroot init
这时就会产生/usr/local/cvsroot/CVSROOT 目录，这下面放着有关CVS的配置文件。同时/usr/local/cvsroot/也作为文件仓库存放所有的文件。
(2） 创建开发项目
如果从头开始一个新的项目，就需要创建一个单独的目录，并把所有要使用的文件做一个有效的组织。而如果在开始使用源文件的目录之前就有了，则只需进入该目录就行了。
$cd /work/tang
$ls cvstest
. .. c/
$cd cvstest
然后，就可以输入源文件目录：
$cvs import –m “Create Source Dir” cvstest/c tang cvstest
这样会生成 $CVSROOT/cvstest/c 目录。 其中 -m 用来指定注释信息，如果后面在命令行不指定注释信息，则会启动缺省编辑器（vi）要求输入注释信息。 tang, cvstest分别标识了厂商和发行标识。
注意，使用import命令会把当前目录下的所有文件和目录（包括子目录）引入到文件仓库中指定模块（目录）下。
Cvs命令行小结
一个项目的首次导入
cvs import -m "write some comments here" project_name vendor_tag release_tag
执行后：会将所有源文件及目录导入到/path/to/cvsroot/project_name目录下
vender_tag: 开发商标记
release_tag: 版本发布标记
项目导出：将代码从CVS库里导出
cvs checkout project_name
cvs 将创建project_name目录，并将最新版本的源代码导出到相应目录中。这个checkout和Virvual SourceSafe中的check out不是一个概念，相对于Virvual SourceSafe的check out是cvs update， check in是cvs commit。
CVS的日常使用
=============
注意：第一次导出以后，就不是通过cvs checkout来同步文件了，而是要进入刚才cvs checkout project_name导出的project_name目录下进行具体文件的版本同步（添加，修改，删除）操作。
将文件同步到最新的版本
cvs update
不制定文件名，cvs将同步所有子目录下的文件，也可以制定某个文件名/目录进行同步
cvs update file_name
最好每天开始工作前或将自己的工作导入到CVS库里前都要做一次，并养成"先同步 后修改"的习惯，和Virvual SourceSafe不同，CVS里没有文件锁定的概念，所有的冲突是在commit之前解决，如果你修改过程中，有其他人修改并commit到了CVS库中，CVS会通知你文件冲突，并自动将冲突部分用
>>>>>> content on cvs server
<<<<<<
content in your file
>>>>>> 标记出来，由你确认冲突内容的取舍。
版本冲突一般是在多个人修改一个文件造成的，但这种项目管理上的问题不应该指望由CVS来解决。
确认修改写入到CVS库里
cvs commit -m "write some comments here" file_name
注意：CVS的很多动作都是通过cvs commit进行最后确认并修改的，最好每次只修改一个文件。在确认的前，还需要用户填写修改注释，以帮助其他开发人员了解修改的原因。如果不用写-m "comments"而直接确认`cvs commit file_name` 的话，cvs会自动调用系统缺省的文字编辑器(一般是vi)要求你写入注释。
注释的质量很重要：所以不仅必须要写，而且必须写一些比较有意义的内容：以方便其他开发人员能够很好的理解
不好的注释，很难让其他的开发人员快速的理解：比如： -m "bug fixed" 甚至 -m ""
好的注释，甚至可以用中文: -m "在用户注册过程中加入了Email地址校验"
修改某个版本注释：每次只确认一个文件到CVS库里是一个很好的习惯，但难免有时候忘了指定文件名，把多个文件以同样注释commit到CVS库里了，以下命令可以允许你修改某个文件某个版本的注释：
cvs admin -m 1.3:"write some comments here" file_name
添加文件
创建好新文件后，比如：touch new_file
cvs add new_file
注意：对于图片，Word文档等非纯文本的项目，需要使用cvs add -b选项按2进制文件方式导入，否则有可能出现文件被破坏的情况
比如：
cvs add -b new_file.gif
cvs add -b readme.doc
然后确认修改并注释
cvs ci -m "write some comments here"
删除文件
将某个源文件物理删除后，比如：rm file_name
cvs rm file_name
然后确认修改并注释
cvs ci -m "write some comments here"
以上面前2步合并的方法为：
cvs rm -f file_name
cvs ci -m "why delete file"
注意：很多cvs命令都有缩写形式：commit=>ci; update=>up; checkout=>co/get; remove=>rm;
添加目录
cvs add dir_name
查看修改历史
cvs log file_name
cvs history file_name
查看当前文件不同版本的区别
cvs diff -r1.3 -r1.5 file_name
查看当前文件（可能已经修改了）和库中相应文件的区别
cvs diff file_name
cvs的web界面提供了更方便的定位文件修改和比较版本区别的方法，具体安装设置请看后面的cvsweb使用
正确的通过CVS恢复旧版本的方法：
如果用cvs update -r1.2 file.name
这个命令是给file.name加一个STICK TAG： "1.2" ，虽然你的本意只是想将它恢复到1.2版本
正确的恢复版本的方法是：cvs update -p -r1.2 file_name >file_name
如果不小心已经加成STICK TAG的话：用cvs update -A 解决
移动文件/文件重命名
cvs里没有cvs move或cvs rename，因为这两个操作是可以由先cvs remove old_file_name，然后cvs add new_file_name实现的。
删除/移动目录
最方便的方法是让管理员直接移动，删除CVSROOT里相应目录（因为CVS一个项目下的子目录都是独立的，移动到$CVSROOT目录下都可以作为新的独立项目：好比一颗树，其实砍下任意一枝都能独立存活），对目录进行了修改后，要求其开发人员重新导出项目cvs checkout project_name 或者用cvs update -dP同步。
项目发布导出不带CVS目录的源文件
做开发的时候你可能注意到了，每个开发目录下，CVS都创建了一个CVS/目录。里面有文件用于记录当前目录和CVS库之间的对应信息。但项目发布的时候你一般不希望把文件目录还带着含有CVS信息的CVS目录吧，这个一次性的导出过程使用cvs export命令，不过export只能针对一个TAG或者日期导出，比如：
cvs export -r release1 project_name
cvs export -D 20021023 project_name
cvs export -D now project_name
CVS Branch：项目多分支同步开发
=============================
确认版本里程碑：多个文件各自版本号不一样，项目到一定阶段，可以给所有文件统一指定一个阶段里程碑版本号，方便以后按照这个阶段里程碑版本号导出项目，同时也是项目的多个分支开发的基础。
cvs tag release_1_0
开始一个新的里程碑：
cvs commit -r 2 标记所有文件开始进入2.x的开发
注意：CVS里的revsion和软件包的发布版本可以没有直接的关系。但所有文件使用和发布版本一致的版本号比较有助于维护。
版本分支的建立
在开发项目的2.x版本的时候发现1.x有问题，但2.x又不敢用，则从先前标记的里程碑：release_1_0导出一个分支release_1_0_patch
cvs rtag -b -r release_1_0 release_1_0_patch proj_dir
一些人先在另外一个目录下导出release_1_0_patch这个分支：解决1.0中的紧急问题，
cvs checkout -r release_1_0_patch
而其他人员仍旧在项目的主干分支2.x上开发
在release_1_0_patch上修正错误后，标记一个1.0的错误修正版本号
cvs tag release_1_0_patch_1
如果2.0认为这些错误修改在2.0里也需要，也可以在2.0的开发目录下合并release_1_0_patch_1中的修改到当前代码中：
cvs update -j release_1_0_patch_1
本文介绍了vi (vim)的基本使用方法，但对于普通用户来说基本上够了！
vi编辑器是所有Unix及Linux系统下标准的编辑器，它的强大不逊色于任何最新的文本编辑器，这里只是简单地介绍一下它的用法和一小部分指令。由于对Unix及Linux系统的任何版本，vi编辑器是完全相同的，因此您可以在其他任何介绍vi的地方进一步了解它。Vi也是Linux中最基本的文本编辑器，学会它后，您将在Linux的世界里畅行无阻。
1、vi的基本概念
基本上vi可以分为三种状态，分别是命令模式（command mode）、插入模式（Insert mode）和底行模式（last line mode），各模式的功能区分如下：
1) 命令行模式command mode）
控制屏幕光标的移动，字符、字或行的删除，移动复制某区段及进入Insert mode下，或者到 last line mode。
2) 插入模式（Insert mode）
只有在Insert mode下，才可以做文字输入，按「ESC」键可回到命令行模式。
3) 底行模式（last line mode）
将文件保存或退出vi，也可以设置编辑环境，如寻找字符串、列出行号……等。
不过一般我们在使用时把vi简化成两个模式，就是将底行模式（last line mode）也算入命令行模式command mode）。
2、vi的基本操作
a) 进入vi
在系统提示符号输入vi及文件名称后，就进入vi全屏幕编辑画面：
$ vi myfile
不过有一点要特别注意，就是您进入vi之后，是处于「命令行模式（command mode）」，您要切换到「插入模式（Insert mode）」才能够输入文字。初次使用vi的人都会想先用上下左右键移动光标，结果电脑一直哔哔叫，把自己气个半死，所以进入vi后，先不要乱动，转换到「插入模式（Insert mode）」再说吧！
b) 切换至插入模式（Insert mode）编辑文件
在「命令行模式（command mode）」下按一下字母「i」就可以进入「插入模式（Insert mode）」，这时候你就可以开始输入文字了。
c) Insert 的切换
您目前处于「插入模式（Insert mode）」，您就只能一直输入文字，如果您发现输错了字！想用光标键往回移动，将该字删除，就要先按一下「ESC」键转到「命令行模式（command mode）」再删除文字。
d) 退出vi及保存文件
在「命令行模式（command mode）」下，按一下「：」冒号键进入「Last line mode」，例如：
: w filename （输入 「w filename」将文章以指定的文件名filename保存）
: wq (输入「wq」，存盘并退出vi)
: q! (输入q!， 不存盘强制退出vi)
3、命令行模式（command mode）功能键
1）. 插入模式
按「i」切换进入插入模式「insert mode」，按“i”进入插入模式后是从光标当前位置开始输入文件；
按「a」进入插入模式后，是从目前光标所在位置的下一个位置开始输入文字；
按「o」进入插入模式后，是插入新的一行，从行首开始输入文字。
2）. 从插入模式切换为命令行模式
按「ESC」键。
3）. 移动光标
vi可以直接用键盘上的光标来上下左右移动，但正规的vi是用小写英文字母「h」、「j」、「k」、「l」，分别控制光标左、下、上、右移一格。
按「ctrl」+「b」：屏幕往“后”移动一页。
按「ctrl」+「f」：屏幕往“前”移动一页。
按「ctrl」+「u」：屏幕往“后”移动半页。
按「ctrl」+「d」：屏幕往“前”移动半页。
按数字「0」：移到文章的开头。
按「G」：移动到文章的最后。
按「$」：移动到光标所在行的“行尾”。
按「^」：移动到光标所在行的“行首”
按「w」：光标跳到下个字的开头
按「e」：光标跳到下个字的字尾
按「b」：光标回到上个字的开头
按「#l」：光标移到该行的第#个位置，如：5l,56l。
4）. 删除文字
「x」：每按一次，删除光标所在位置的“后面”一个字符。
「#x」：例如，「6x」表示删除光标所在位置的“后面”6个字符。
「X」：大写的X，每按一次，删除光标所在位置的“前面”一个字符。
「#X」：例如，「20X」表示删除光标所在位置的“前面”20个字符。
「dd」：删除光标所在行。
「#dd」：从光标所在行开始删除#行
5）. 复制
「yw」：将光标所在之处到字尾的字符复制到缓冲区中。
「#yw」：复制#个字到缓冲区
「yy」：复制光标所在行到缓冲区。
「#yy」：例如，「6yy」表示拷贝从光标所在的该行“往下数”6行文字。
「p」：将缓冲区内的字符贴到光标所在位置。注意：所有与“y”有关的复制命令都必须与“p”配合才能完成复制与粘贴功能。
6）. 替换
「r」：替换光标所在处的字符。
「R」：替换光标所到之处的字符，直到按下「ESC」键为止。
7）. 回复上一次操作
「u」：如果您误执行一个命令，可以马上按下「u」，回到上一个操作。按多次“u”可以执行多次回复。
8）. 更改
「cw」：更改光标所在处的字到字尾处
「c#w」：例如，「c3w」表示更改3个字
9）. 跳至指定的行
「ctrl」+「g」列出光标所在行的行号。
「#G」：例如，「15G」，表示移动光标至文章的第15行行首。
4、Last line mode下命令简介
在使用「last line mode」之前，请记住先按「ESC」键确定您已经处于「command mode」下后，再按「：」冒号即可进入「last line mode」。
A) 列出行号
「set nu」：输入「set nu」后，会在文件中的每一行前面列出行号。
B) 跳到文件中的某一行
「#」：「#」号表示一个数字，在冒号后输入一个数字，再按回车键就会跳到该行了，如输入数字15，再回车，就会跳到文章的第15行。
C) 查找字符
「/关键字」：先按「/」键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按「n」会往后寻找到您要的关键字为止。
「?关键字」：先按「?」键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按「n」会往前寻找到您要的关键字为止。
D) 保存文件
「w」：在冒号输入字母「w」就可以将文件保存起来。
E) 离开vi
「q」：按「q」就是退出，如果无法离开vi，可以在「q」后跟一个「!」强制离开vi。
「qw」：一般建议离开时，搭配「w」一起使用，这样在退出的时候还可以保存文件。
5、vi命令列表
1、下表列出命令模式下的一些键的功能：
h
左移光标一个字符
l
右移光标一个字符
k
光标上移一行
j
光标下移一行
^
光标移动至行首
0
数字“0”，光标移至文章的开头
G
光标移至文章的最后
$
光标移动至行尾
Ctrl+f
向前翻屏
Ctrl+b
向后翻屏
Ctrl+d
向前翻半屏
Ctrl+u
向后翻半屏
i
在光标位置前插入字符
a
在光标所在位置的后一个字符开始增加
o
插入新的一行，从行首开始输入
ESC
从输入状态退至命令状态
x
删除光标后面的字符
#x
删除光标后的＃个字符
X
(大写X)，删除光标前面的字符
#X
删除光标前面的#个字符
dd
删除光标所在的行
#dd
删除从光标所在行数的#行
yw
复制光标所在位置的一个字
#yw
复制光标所在位置的#个字
yy
复制光标所在位置的一行
#yy
复制从光标所在行数的#行
p
粘贴
u
取消操作
cw
更改光标所在位置的一个字
#cw
更改光标所在位置的#个字
2、下表列出行命令模式下的一些指令
w filename
储存正在编辑的文件为filename
wq filename
储存正在编辑的文件为filename，并退出vi
q!
放弃所有修改，退出vi
set nu
显示行号
/或?
查找，在/后输入要查找的内容
n
与/或?一起使用，如果查找的内容不是想要找的关键字，按n或向后（与/联用）或向前（与?联用）继续查找，直到找到为止。
对于第一次用vi，有几点注意要提醒一下：
1、用vi打开文件，是处于「命令行模式（command mode）」，您要切换到「插入模式（Insert mode）」才能够输入文字。切换方法：在「命令行模式（command mode）」下按一下字母「i」就可以进入「插入模式（Insert mode）」，这时候你就可以开始输入文字了。
2、编辑好后，需从插入模式切换为命令行模式才能对文件进行保存，切换方法：按「ESC」键。
3、保存并退出文件：在命令模式下输入:wq即可！（别忘了wq前面的:）
ps: 为了更加方便地用vim编写程序(C),需要编辑文件 .vimrc 保存至目录/home/host_name/ 下，其内容为：
set ai
set ts=4
if !exists("autocommands_loaded")
let autocommands_loaded = 1
augroup C
autocmd BufRead *.c set cindent
augroup END
endif
set sw=4
set cin
set mouse=a
syntax on
vi编辑器是所有Unix及Linux系统下标准的编辑器，它的强大不逊色于任何最新的文本编辑器，这里只是简单地介绍一下它的用法和一小部分指令。由于对Unix及Linux系统的任何版本，vi编辑器是完全相同的，因此您可以在其他任何介绍vi的地方进一步了解它。Vi也是Linux中最基本的文本编辑器，学会它后，您将在Linux的世界里畅行无阻。
1、vi的基本概念
基本上vi可以分为三种状态，分别是命令模式（command mode）、插入模式（Insert mode）和底行模式（last line mode），各模式的功能区分如下：
1) 命令行模式command mode）
控制屏幕光标的移动，字符、字或行的删除，移动复制某区段及进入Insert mode下，或者到 last line mode。
2) 插入模式（Insert mode）
只有在Insert mode下，才可以做文字输入，按「ESC」键可回到命令行模式。
3) 底行模式（last line mode）
将文件保存或退出vi，也可以设置编辑环境，如寻找字符串、列出行号……等。
不过一般我们在使用时把vi简化成两个模式，就是将底行模式（last line mode）也算入命令行模式command mode）。
2、vi的基本操作
a) 进入vi
在系统提示符号输入vi及文件名称后，就进入vi全屏幕编辑画面：
$ vi myfile
不过有一点要特别注意，就是您进入vi之后，是处于「命令行模式（command mode）」，您要切换到「插入模式（Insert mode）」才能够输入文字。初次使用vi的人都会想先用上下左右键移动光标，结果电脑一直哔哔叫，把自己气个半死，所以进入vi后，先不要乱动，转换到「插入模式（Insert mode）」再说吧！
b) 切换至插入模式（Insert mode）编辑文件
在「命令行模式（command mode）」下按一下字母「i」就可以进入「插入模式（Insert mode）」，这时候你就可以开始输入文字了。
c) Insert 的切换
您目前处于「插入模式（Insert mode）」，您就只能一直输入文字，如果您发现输错了字！想用光标键往回移动，将该字删除，就要先按一下「ESC」键转到「命令行模式（command mode）」再删除文字。
d) 退出vi及保存文件
在「命令行模式（command mode）」下，按一下「：」冒号键进入「Last line mode」，例如：
: w filename （输入 「w filename」将文章以指定的文件名filename保存）
: wq (输入「wq」，存盘并退出vi)
: q! (输入q!， 不存盘强制退出vi)
3、命令行模式（command mode）功能键
1）. 插入模式
按「i」切换进入插入模式「insert mode」，按“i”进入插入模式后是从光标当前位置开始输入文件；
按「a」进入插入模式后，是从目前光标所在位置的下一个位置开始输入文字；
按「o」进入插入模式后，是插入新的一行，从行首开始输入文字。
2）. 从插入模式切换为命令行模式
按「ESC」键。
3）. 移动光标
vi可以直接用键盘上的光标来上下左右移动，但正规的vi是用小写英文字母「h」、「j」、「k」、「l」，分别控制光标左、下、上、右移一格。
按「ctrl」+「b」：屏幕往“后”移动一页。
按「ctrl」+「f」：屏幕往“前”移动一页。
按「ctrl」+「u」：屏幕往“后”移动半页。
按「ctrl」+「d」：屏幕往“前”移动半页。
按数字「0」：移到文章的开头。
按「G」：移动到文章的最后。
按「$」：移动到光标所在行的“行尾”。
按「^」：移动到光标所在行的“行首”
按「w」：光标跳到下个字的开头
按「e」：光标跳到下个字的字尾
按「b」：光标回到上个字的开头
按「#l」：光标移到该行的第#个位置，如：5l,56l。
4）. 删除文字
「x」：每按一次，删除光标所在位置的“后面”一个字符。
「#x」：例如，「6x」表示删除光标所在位置的“后面”6个字符。
「X」：大写的X，每按一次，删除光标所在位置的“前面”一个字符。
「#X」：例如，「20X」表示删除光标所在位置的“前面”20个字符。
「dd」：删除光标所在行。
「#dd」：从光标所在行开始删除#行
5）. 复制
「yw」：将光标所在之处到字尾的字符复制到缓冲区中。
「#yw」：复制#个字到缓冲区
「yy」：复制光标所在行到缓冲区。
「#yy」：例如，「6yy」表示拷贝从光标所在的该行“往下数”6行文字。
「p」：将缓冲区内的字符贴到光标所在位置。注意：所有与“y”有关的复制命令都必须与“p”配合才能完成复制与粘贴功能。
6）. 替换
「r」：替换光标所在处的字符。
「R」：替换光标所到之处的字符，直到按下「ESC」键为止。
7）. 回复上一次操作
「u」：如果您误执行一个命令，可以马上按下「u」，回到上一个操作。按多次“u”可以执行多次回复。
8）. 更改
「cw」：更改光标所在处的字到字尾处
「c#w」：例如，「c3w」表示更改3个字
9）. 跳至指定的行
「ctrl」+「g」列出光标所在行的行号。
「#G」：例如，「15G」，表示移动光标至文章的第15行行首。
4、Last line mode下命令简介
在使用「last line mode」之前，请记住先按「ESC」键确定您已经处于「command mode」下后，再按「：」冒号即可进入「last line mode」。
A) 列出行号
「set nu」：输入「set nu」后，会在文件中的每一行前面列出行号。
B) 跳到文件中的某一行
「#」：「#」号表示一个数字，在冒号后输入一个数字，再按回车键就会跳到该行了，如输入数字15，再回车，就会跳到文章的第15行。
C) 查找字符
「/关键字」：先按「/」键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按「n」会往后寻找到您要的关键字为止。
「?关键字」：先按「?」键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按「n」会往前寻找到您要的关键字为止。
D) 保存文件
「w」：在冒号输入字母「w」就可以将文件保存起来。
E) 离开vi
「q」：按「q」就是退出，如果无法离开vi，可以在「q」后跟一个「!」强制离开vi。
「qw」：一般建议离开时，搭配「w」一起使用，这样在退出的时候还可以保存文件。
5、vi命令列表
1、下表列出命令模式下的一些键的功能：
h
左移光标一个字符
l
右移光标一个字符
k
光标上移一行
j
光标下移一行
^
光标移动至行首
0
数字“0”，光标移至文章的开头
G
光标移至文章的最后
$
光标移动至行尾
Ctrl+f
向前翻屏
Ctrl+b
向后翻屏
Ctrl+d
向前翻半屏
Ctrl+u
向后翻半屏
i
在光标位置前插入字符
a
在光标所在位置的后一个字符开始增加
o
插入新的一行，从行首开始输入
ESC
从输入状态退至命令状态
x
删除光标后面的字符
#x
删除光标后的＃个字符
X
(大写X)，删除光标前面的字符
#X
删除光标前面的#个字符
dd
删除光标所在的行
#dd
删除从光标所在行数的#行
yw
复制光标所在位置的一个字
#yw
复制光标所在位置的#个字
yy
复制光标所在位置的一行
#yy
复制从光标所在行数的#行
p
粘贴
u
取消操作
cw
更改光标所在位置的一个字
#cw
更改光标所在位置的#个字
2、下表列出行命令模式下的一些指令
w filename
储存正在编辑的文件为filename
wq filename
储存正在编辑的文件为filename，并退出vi
q!
放弃所有修改，退出vi
set nu
显示行号
/或?
查找，在/后输入要查找的内容
n
与/或?一起使用，如果查找的内容不是想要找的关键字，按n或向后（与/联用）或向前（与?联用）继续查找，直到找到为止。
对于第一次用vi，有几点注意要提醒一下：
1、用vi打开文件，是处于「命令行模式（command mode）」，您要切换到「插入模式（Insert mode）」才能够输入文字。切换方法：在「命令行模式（command mode）」下按一下字母「i」就可以进入「插入模式（Insert mode）」，这时候你就可以开始输入文字了。
2、编辑好后，需从插入模式切换为命令行模式才能对文件进行保存，切换方法：按「ESC」键。
3、保存并退出文件：在命令模式下输入:wq即可！（别忘了wq前面的:）
ps: 为了更加方便地用vim编写程序(C),需要编辑文件 .vimrc 保存至目录/home/host_name/ 下，其内容为：
set ai
set ts=4
if !exists("autocommands_loaded")
let autocommands_loaded = 1
augroup C
autocmd BufRead *.c set cindent
augroup END
endif
set sw=4
set cin
set mouse=a
syntax on
查询的
#include "ldap.h"
#include "stdio.h"
int main()
{
LDAP *ld;
LDAPMessage *res,*e;
int i,version;
char *server;
int *port;
char *dn;
char *a;
BerElement *ptr;
char **vals;
char **ppValue = NULL;
char *sdn;
server="192.168.1.17";
port = 389;
//联接服务器
if( (ld = ldap_open(server, port )) == NULL )
{
printf("NO CONNECT");
exit( 1 );
}
//设置服务器版本
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
//绑定服务器
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
}
//设置查询的根目录
sdn="dc=starxing,dc=com";
//进行同步查询
if (ldap_search_s(ld,sdn,LDAP_SCOPE_SUBTREE,"(objectclass=*)",NULL,0,&res)
!= LDAP_SUCCESS)
{
ldap_perror(ld,"ldap_search_s");
exit(1);
}
//对条目进行逐条分析
for(e=ldap_first_entry(ld,res);e!=NULL;e=ldap_next_entry(ld,e))
{
//取出DN
dn=ldap_get_dn(ld,e);
printf("dn: %s \n",dn);
ldap_memfree( dn );
//对条目的属性进行逐条分析
for ( a = ldap_first_attribute( ld, e, &ptr );a != NULL;a = ldap_next_attribute( ld, e, ptr ) )
{
printf( " %s: ",a );
vals = ldap_get_values( ld, e, a );
for ( i = 0; vals[i] != NULL; i++ ) {
printf(" %s ",vals[i]);
}
printf("\n");
ldap_value_free( vals );
}
printf("\n");
}
ldap_msgfree(res);
ldap_unbind(ld);
}
插入的
#include "ldap.h"
#include "stdio.h"
int main()
{
LDAP *ld;
char *sdn = "cn=qqq11,dc=starxing,dc=com";//要添加条目的DN
//列出要添加条目各个属性的值
char *cn_values[] = {"qqq11",NULL};
char *sn_values[] = {"qqq11",NULL};
char *userPassword_values[] = {"qqqq",NULL};
char *objectClass_values[] = {"person",NULL};
int version;
LDAPMod mod2 = {LDAP_MOD_ADD,"cn",cn_values};
LDAPMod mod1 = {LDAP_MOD_ADD,"sn",sn_values};
LDAPMod mod0 = {LDAP_MOD_ADD,"objectClass",objectClass_values};
LDAPMod mod3 = {LDAP_MOD_ADD,"userPassword",userPassword_values};
LDAPMod *lmod[] = {&mod0,&mod1,&mod2,&mod3,NULL};
//联接ldap服务器
if( (ld = ldap_open( "192.168.1.17", 389 )) == NULL ){
ldap_perror(ld,"ldapopen");
exit( 1 );
return 1;
}
//设置ldap版本
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
//对ldap服务器进行绑定
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
return 1;
}
//进行同步绑定
if(ldap_add_s(ld,sdn,lmod)!=LDAP_SUCCESS){
ldap_perror(ld,"ldap_add_s error");
return( 1 );
}
ldap_unbind(ld);
return( 0 );
}
删除的
#include "ldap.h"
#include "stdio.h"
int main()
{
LDAP *ld;
int version;
char **ppValue = NULL;
//联接和绑定服务器
if( (ld = ldap_open( "192.168.1.17", 389 )) == NULL )
exit( 1 );
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
}
//进行删除操作
if( ldap_delete_s(ld,"cn=qqq11,dc=starxing,dc=com") == -1)
{
ldap_perror(ld,"ldap_delete_s");
exit(1);
}
ldap_unbind(ld);
return 0;
}
修改的
#include "ldap.h"
#include <stdio.h>;
int main()
{
LDAP *ld;
char *sdn;
//设置要更改的值
char *sn_values[] = {"eeee",NULL};
char *homePhone_values[] = {"12345678",NULL};
int version;
LDAPMod mod1 = {LDAP_MOD_ADD,"homePhome",homePhone_values};
LDAPMod mod2 = {LDAP_MOD_REPLACE,"sn",sn_values};
LDAPMod mod3 = {LDAP_MOD_DELETE,"mail",NULL};
LDAPMod *lmod[4] = {&mod1,&mod2,&mod3,NULL};
//联接服务器和绑定服务器
if( (ld = ldap_open( "192.168.1.17", 389 )) == NULL )
exit( 1 );
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
}
sdn = "cn=qqq11222,dc=starxing,dc=com";
//进行更改
if (ldap_modify_s(ld,sdn,lmod)!=LDAP_SUCCESS) {
ldap_perror( ld, "ldap_modify_s" );
return( 1 );
}
ldap_unbind(ld);
}
#include "ldap.h"
#include "stdio.h"
int main()
{
LDAP *ld;
LDAPMessage *res,*e;
int i,version;
char *server;
int *port;
char *dn;
char *a;
BerElement *ptr;
char **vals;
char **ppValue = NULL;
char *sdn;
server="192.168.1.17";
port = 389;
//联接服务器
if( (ld = ldap_open(server, port )) == NULL )
{
printf("NO CONNECT");
exit( 1 );
}
//设置服务器版本
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
//绑定服务器
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
}
//设置查询的根目录
sdn="dc=starxing,dc=com";
//进行同步查询
if (ldap_search_s(ld,sdn,LDAP_SCOPE_SUBTREE,"(objectclass=*)",NULL,0,&res)
!= LDAP_SUCCESS)
{
ldap_perror(ld,"ldap_search_s");
exit(1);
}
//对条目进行逐条分析
for(e=ldap_first_entry(ld,res);e!=NULL;e=ldap_next_entry(ld,e))
{
//取出DN
dn=ldap_get_dn(ld,e);
printf("dn: %s \n",dn);
ldap_memfree( dn );
//对条目的属性进行逐条分析
for ( a = ldap_first_attribute( ld, e, &ptr );a != NULL;a = ldap_next_attribute( ld, e, ptr ) )
{
printf( " %s: ",a );
vals = ldap_get_values( ld, e, a );
for ( i = 0; vals[i] != NULL; i++ ) {
printf(" %s ",vals[i]);
}
printf("\n");
ldap_value_free( vals );
}
printf("\n");
}
ldap_msgfree(res);
ldap_unbind(ld);
}
插入的
#include "ldap.h"
#include "stdio.h"
int main()
{
LDAP *ld;
char *sdn = "cn=qqq11,dc=starxing,dc=com";//要添加条目的DN
//列出要添加条目各个属性的值
char *cn_values[] = {"qqq11",NULL};
char *sn_values[] = {"qqq11",NULL};
char *userPassword_values[] = {"qqqq",NULL};
char *objectClass_values[] = {"person",NULL};
int version;
LDAPMod mod2 = {LDAP_MOD_ADD,"cn",cn_values};
LDAPMod mod1 = {LDAP_MOD_ADD,"sn",sn_values};
LDAPMod mod0 = {LDAP_MOD_ADD,"objectClass",objectClass_values};
LDAPMod mod3 = {LDAP_MOD_ADD,"userPassword",userPassword_values};
LDAPMod *lmod[] = {&mod0,&mod1,&mod2,&mod3,NULL};
//联接ldap服务器
if( (ld = ldap_open( "192.168.1.17", 389 )) == NULL ){
ldap_perror(ld,"ldapopen");
exit( 1 );
return 1;
}
//设置ldap版本
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
//对ldap服务器进行绑定
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
return 1;
}
//进行同步绑定
if(ldap_add_s(ld,sdn,lmod)!=LDAP_SUCCESS){
ldap_perror(ld,"ldap_add_s error");
return( 1 );
}
ldap_unbind(ld);
return( 0 );
}
删除的
#include "ldap.h"
#include "stdio.h"
int main()
{
LDAP *ld;
int version;
char **ppValue = NULL;
//联接和绑定服务器
if( (ld = ldap_open( "192.168.1.17", 389 )) == NULL )
exit( 1 );
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
}
//进行删除操作
if( ldap_delete_s(ld,"cn=qqq11,dc=starxing,dc=com") == -1)
{
ldap_perror(ld,"ldap_delete_s");
exit(1);
}
ldap_unbind(ld);
return 0;
}
修改的
#include "ldap.h"
#include <stdio.h>;
int main()
{
LDAP *ld;
char *sdn;
//设置要更改的值
char *sn_values[] = {"eeee",NULL};
char *homePhone_values[] = {"12345678",NULL};
int version;
LDAPMod mod1 = {LDAP_MOD_ADD,"homePhome",homePhone_values};
LDAPMod mod2 = {LDAP_MOD_REPLACE,"sn",sn_values};
LDAPMod mod3 = {LDAP_MOD_DELETE,"mail",NULL};
LDAPMod *lmod[4] = {&mod1,&mod2,&mod3,NULL};
//联接服务器和绑定服务器
if( (ld = ldap_open( "192.168.1.17", 389 )) == NULL )
exit( 1 );
version = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,&version);
if(ldap_simple_bind_s(ld,"cn=root,dc=starxing,dc=com","secret")!=LDAP_SUCCESS)
{
ldap_perror( ld, "ldap_simple_bind_s" );
exit( 1 );
}
sdn = "cn=qqq11222,dc=starxing,dc=com";
//进行更改
if (ldap_modify_s(ld,sdn,lmod)!=LDAP_SUCCESS) {
ldap_perror( ld, "ldap_modify_s" );
return( 1 );
}
ldap_unbind(ld);
}
#include <stdlib.h>
#include <string.h>
int main()
{
char *sfrom="1234567890";
char *sto=(char*) malloc(10);
memcpy(sto,sfrom,3);
printf(sto);
strncpy(sto,sfrom,3);
printf("\n");
printf(sto);
printf("\n");
FILE *fp=fopen("du.txt","r");
char ln[100];
char *out=(char*) malloc(10);
while(!feof(fp))
{
fgets(ln,1024,fp);
memcpy(out,ln,4);
printf(out);
printf("\n");
}
return 0;
}
#include <string.h>
int main()
{
char *sfrom="1234567890";
char *sto=(char*) malloc(10);
memcpy(sto,sfrom,3);
printf(sto);
strncpy(sto,sfrom,3);
printf("\n");
printf(sto);
printf("\n");
FILE *fp=fopen("du.txt","r");
char ln[100];
char *out=(char*) malloc(10);
while(!feof(fp))
{
fgets(ln,1024,fp);
memcpy(out,ln,4);
printf(out);
printf("\n");
}
return 0;
}
note: look the sentence which have comments
当父类定义了一个函数，而子类也定义了一个同名的常函数，这时就会存在函数覆盖：
******illustrate********
#include <iostream.h>
class test
{
public:
void output()
{
cout<<"this is base"<<endl;
}
};
class member
{
public:
void greet()
{
cout<<"this is a member"<<endl;
}
};
class derive:public test
{
private:
member x;//because member have not parameters, so don't need constructor
public:
void output()
{
cout<<"this is a derive"<<endl;
x.greet();
}
};
int main()
{
derive de;
de.output();
de.test::output(); //if want to invoking the father class's function, must append the ::
return 0;
}
****the answer******
this is a derive
this is a member
this is base
now, we modify above programe, append the constructor
成员类和父类构造器的初始化，初始化父类时，使用的是类名，初始化成员类时，使用的是成员名
#include <iostream.h>
class test
{
private:
int x;
public:
test(int y)
{
x=y;
}
void output()
{
cout<<"this is base"<<endl;
}
};
class member
{
private:
float f1;
char ch;
public:
member(float f,char ch1)
{
f1=f;
ch=ch1;
}
void greet()
{
cout<<"this is a member"<<endl;
}
};
class derive:public test
{
private:
member x;//because member have not parameters, so don't need constructor
public:
derive(int x1,float y,char chr):test(x1),x(y,chr) //member class and parent class's initialize
{}
void output()
{
cout<<"this is a derive"<<endl;
x.greet();
}
};
int main()
{
derive de(45,12.32,'h');
de.output();
de.test::output();
return 0;
}
构造和析构的调用顺序
先是父类中的成员类的构造函数先调用，然后才是父类的构造函数，接下来就是子类，调用顺序相同，而析构相反。如果继承了多个类（多重继承），则按它们在定义派生类时的声明顺序有关。
*******illustrate***********
#include <iostream.h>
class member
{
public:
member()
{
cout<<"invoking the parent member constructor"<<endl;
}
~member()
{
cout<<"deconstruct"<<endl;
}
};
class test
{
private:
int x;
member xy;
public:
test(int y)
{
cout<<"parent constructor"<<endl;
x=y;
}
~test()
{
cout<<"the parent destruct"<<endl;
}
void output()
{
cout<<"this is base"<<endl;
}
};
class member1
{
private:
float f1;
char ch;
public:
member1(float f,char ch1)
{
f1=f;
ch=ch1;
}
void greet()
{
cout<<"this is a member"<<endl;
}
};
class derive:public test
{
private:
member1 x;//because member have not parameters, so don't need constructor
public:
derive(int x1,float y,char chr):test(x1),x(y,chr)
{cout<<"invoking the derive constructor"<<endl;}
~derive()
{
cout<<"the derive destruct "<<endl;
}
void output()
{
cout<<"this is a derive"<<endl;
x.greet();
}
};
int main()
{
derive de(45,12.32,'h');
de.output();
de.test::output();
return 0;
}
*********over*********
mapping up-----向上映射
we can use the above programe, define a new object
append the follow contents in main:
test te=derive(25,12.36,'a'); //this is mapping up
te.output();
注意：只有公有继承才能向上映射，private, protected不能向上映射
多重继承的二义性
例如：
class base1
{
void display()
{
cout<<"base1"<<endl;
}
};
class base2
{
void display()
{
cout<<"base2";
}
};
class derive:public base1,public base2
{
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der;
der.display(); //现在这个语句就会出现二义性，不知调用父类的哪一个常函数，加上作用域就可以了
der.base1::display();
der.base2::display();// now, it can run rightly
return 0;
}
访问共同基类成员时的二义性
class base
{
public:
base()
{
cout<<"base constructor"<<endl;
}
void common()
{
cout<<"base"<<endl;
}
};
class base1:public base
{
public:
base1()
{
cout<<"base1.constructor"<<endl;
}
void display()
{
cout<<"base1"<<endl;
}
};
class base2:public base
{
public:
base2()
{
cout<<"base2.constructor"<<endl;
}
void display()
{
cout<<"base2";
}
};
class derive:public base1,public base2
{
public:
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der;
//der.common(); //现在这个就会出现二义性，因为不知是通过哪个父类调用父类的父类
//解决办法，仍然是用作用域来解决。只不过会对父类有两次拷贝
der.base1::common();
return 0;}
******the result******
base constructor
base1.constructor
base constructor
base2.constructor
base
从以上结果可以看出，基类的构造函数被调用了两次。
*******虚基类*************
利用上面的程序，只需在继承自共同基类的派生类声明时显示地标明继承方式为虚拟（virtual）继承，其格式为：
<derived name>:<virtual><inherit mode><base name>
******illustrate**********
class base
{
public:
base()
{
cout<<"base constructor"<<endl;
}
void common()
{
cout<<"base"<<endl;
}
};
class base1:virtual public base
{
public:
base1()
{
cout<<"base1.constructor"<<endl;
}
void display()
{
cout<<"base1"<<endl;
}
};
class base2:virtual public base
{
public:
base2()
{
cout<<"base2.constructor"<<endl;
}
void display()
{
cout<<"base2";
}
};
class derive:public base1,public base2
{
public:
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der;
der.common(); //现在这个就不会出现二义性
//der.base1::common();
return 0;}
the result:
base constructor
base1.constructor
base constructor
base2.constructor
base
从以上结果可以看出，父类的构造函数只调用了一次
虚基类的初始化
在虚拟继承中，必须在最晚派生类的构造函数中显式地调用虚基类的构造函数，其格式如下：
<the last derive class constructor><parameter list><direct base's constructor><member object constructor><virtual base class constructor>{define new append members }
*******illustrate*******
#include <iostream.h>
class base
{
private:
int i;
public:
base(int x)
{
i=x;
cout<<"base constructor"<<endl;
cout<<i<<endl;
}
int geti() const
{
return i;
}
void common()
{
cout<<"base"<<endl;
}
};
class base1:virtual public base
{
int y;
public:
base1(int w,int z):base(w)
{
y=z;
cout<<"base1.constructor"<<endl;
}
void display()
{
cout<<"base1"<<endl;
}
};
class base2:virtual public base
{private:
int aa;
public:
base2(int a, int b):base(b)
{
aa=a;
cout<<"base2.constructor"<<endl;
}
void display()
{
cout<<"base2";
}
int geti() const
{
return aa;
}
};
class derive:public base1,public base2
{
public:
derive(int a1,int a2,int a3,int a4):base1(a1,a2),base2(a3,a4),base(a4){}
//initialize the virtual base class constructor
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der(12,25,34,45);
der.common(); //
//
//der.base1::common();
cout<<der.geti()<<endl;
return 0;}
当父类定义了一个函数，而子类也定义了一个同名的常函数，这时就会存在函数覆盖：
******illustrate********
#include <iostream.h>
class test
{
public:
void output()
{
cout<<"this is base"<<endl;
}
};
class member
{
public:
void greet()
{
cout<<"this is a member"<<endl;
}
};
class derive:public test
{
private:
member x;//because member have not parameters, so don't need constructor
public:
void output()
{
cout<<"this is a derive"<<endl;
x.greet();
}
};
int main()
{
derive de;
de.output();
de.test::output(); //if want to invoking the father class's function, must append the ::
return 0;
}
****the answer******
this is a derive
this is a member
this is base
now, we modify above programe, append the constructor
成员类和父类构造器的初始化，初始化父类时，使用的是类名，初始化成员类时，使用的是成员名
#include <iostream.h>
class test
{
private:
int x;
public:
test(int y)
{
x=y;
}
void output()
{
cout<<"this is base"<<endl;
}
};
class member
{
private:
float f1;
char ch;
public:
member(float f,char ch1)
{
f1=f;
ch=ch1;
}
void greet()
{
cout<<"this is a member"<<endl;
}
};
class derive:public test
{
private:
member x;//because member have not parameters, so don't need constructor
public:
derive(int x1,float y,char chr):test(x1),x(y,chr) //member class and parent class's initialize
{}
void output()
{
cout<<"this is a derive"<<endl;
x.greet();
}
};
int main()
{
derive de(45,12.32,'h');
de.output();
de.test::output();
return 0;
}
构造和析构的调用顺序
先是父类中的成员类的构造函数先调用，然后才是父类的构造函数，接下来就是子类，调用顺序相同，而析构相反。如果继承了多个类（多重继承），则按它们在定义派生类时的声明顺序有关。
*******illustrate***********
#include <iostream.h>
class member
{
public:
member()
{
cout<<"invoking the parent member constructor"<<endl;
}
~member()
{
cout<<"deconstruct"<<endl;
}
};
class test
{
private:
int x;
member xy;
public:
test(int y)
{
cout<<"parent constructor"<<endl;
x=y;
}
~test()
{
cout<<"the parent destruct"<<endl;
}
void output()
{
cout<<"this is base"<<endl;
}
};
class member1
{
private:
float f1;
char ch;
public:
member1(float f,char ch1)
{
f1=f;
ch=ch1;
}
void greet()
{
cout<<"this is a member"<<endl;
}
};
class derive:public test
{
private:
member1 x;//because member have not parameters, so don't need constructor
public:
derive(int x1,float y,char chr):test(x1),x(y,chr)
{cout<<"invoking the derive constructor"<<endl;}
~derive()
{
cout<<"the derive destruct "<<endl;
}
void output()
{
cout<<"this is a derive"<<endl;
x.greet();
}
};
int main()
{
derive de(45,12.32,'h');
de.output();
de.test::output();
return 0;
}
*********over*********
mapping up-----向上映射
we can use the above programe, define a new object
append the follow contents in main:
test te=derive(25,12.36,'a'); //this is mapping up
te.output();
注意：只有公有继承才能向上映射，private, protected不能向上映射
多重继承的二义性
例如：
class base1
{
void display()
{
cout<<"base1"<<endl;
}
};
class base2
{
void display()
{
cout<<"base2";
}
};
class derive:public base1,public base2
{
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der;
der.display(); //现在这个语句就会出现二义性，不知调用父类的哪一个常函数，加上作用域就可以了
der.base1::display();
der.base2::display();// now, it can run rightly
return 0;
}
访问共同基类成员时的二义性
class base
{
public:
base()
{
cout<<"base constructor"<<endl;
}
void common()
{
cout<<"base"<<endl;
}
};
class base1:public base
{
public:
base1()
{
cout<<"base1.constructor"<<endl;
}
void display()
{
cout<<"base1"<<endl;
}
};
class base2:public base
{
public:
base2()
{
cout<<"base2.constructor"<<endl;
}
void display()
{
cout<<"base2";
}
};
class derive:public base1,public base2
{
public:
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der;
//der.common(); //现在这个就会出现二义性，因为不知是通过哪个父类调用父类的父类
//解决办法，仍然是用作用域来解决。只不过会对父类有两次拷贝
der.base1::common();
return 0;}
******the result******
base constructor
base1.constructor
base constructor
base2.constructor
base
从以上结果可以看出，基类的构造函数被调用了两次。
*******虚基类*************
利用上面的程序，只需在继承自共同基类的派生类声明时显示地标明继承方式为虚拟（virtual）继承，其格式为：
<derived name>:<virtual><inherit mode><base name>
******illustrate**********
class base
{
public:
base()
{
cout<<"base constructor"<<endl;
}
void common()
{
cout<<"base"<<endl;
}
};
class base1:virtual public base
{
public:
base1()
{
cout<<"base1.constructor"<<endl;
}
void display()
{
cout<<"base1"<<endl;
}
};
class base2:virtual public base
{
public:
base2()
{
cout<<"base2.constructor"<<endl;
}
void display()
{
cout<<"base2";
}
};
class derive:public base1,public base2
{
public:
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der;
der.common(); //现在这个就不会出现二义性
//der.base1::common();
return 0;}
the result:
base constructor
base1.constructor
base constructor
base2.constructor
base
从以上结果可以看出，父类的构造函数只调用了一次
虚基类的初始化
在虚拟继承中，必须在最晚派生类的构造函数中显式地调用虚基类的构造函数，其格式如下：
<the last derive class constructor><parameter list><direct base's constructor><member object constructor><virtual base class constructor>{define new append members }
*******illustrate*******
#include <iostream.h>
class base
{
private:
int i;
public:
base(int x)
{
i=x;
cout<<"base constructor"<<endl;
cout<<i<<endl;
}
int geti() const
{
return i;
}
void common()
{
cout<<"base"<<endl;
}
};
class base1:virtual public base
{
int y;
public:
base1(int w,int z):base(w)
{
y=z;
cout<<"base1.constructor"<<endl;
}
void display()
{
cout<<"base1"<<endl;
}
};
class base2:virtual public base
{private:
int aa;
public:
base2(int a, int b):base(b)
{
aa=a;
cout<<"base2.constructor"<<endl;
}
void display()
{
cout<<"base2";
}
int geti() const
{
return aa;
}
};
class derive:public base1,public base2
{
public:
derive(int a1,int a2,int a3,int a4):base1(a1,a2),base2(a3,a4),base(a4){}
//initialize the virtual base class constructor
void output()
{
cout<<"the derive class"<<endl;
}
};
int main()
{
derive der(12,25,34,45);
der.common(); //
//
//der.base1::common();
cout<<der.geti()<<endl;
return 0;}
http://www.baidu.com/s?ie=gb2312&bs=c%2B%2B+%C0%E0&sr=&z=&cl=3&f=8&wd=sun+directory+server&ct=0
ldap学习笔记：http://linliangyi2007.javaeye.com/blog/167125
安装 Sun ONE Directory Server: http://publib.boulder.ibm.com/tividd/td/ITAME/SC32-1362-00/zh_CN/HTML/am51_install78.htm
折腾sunONE directory server: http://www.ningoo.net/html/2007/install_sun_one_directory_server.html
Sun Java System Directory Server Enterprise Edition 6.2:
http://docs.sun.com/app/docs/coll/1224.3?l=zh_TW
ldap_API_C URL：http://www.diybl.com/course/7_databases/database_other/20071019/78240.html
ldap学习笔记：http://linliangyi2007.javaeye.com/blog/167125
安装 Sun ONE Directory Server: http://publib.boulder.ibm.com/tividd/td/ITAME/SC32-1362-00/zh_CN/HTML/am51_install78.htm
折腾sunONE directory server: http://www.ningoo.net/html/2007/install_sun_one_directory_server.html
Sun Java System Directory Server Enterprise Edition 6.2:
http://docs.sun.com/app/docs/coll/1224.3?l=zh_TW
ldap_API_C URL：http://www.diybl.com/course/7_databases/database_other/20071019/78240.html
Linux的问题往往不是集中在技术或软件的可获得性问题，而是一个选择的问题。用户图形界面(GUI)的选择就体现了这一点。在Linux领域可以选择的GUI很多，商业可用的也有10种左右。当我们面临着如何为LiPS论坛选择可以成为标准的GUI时，技术偏好就必须让位于更多的公共性的因素。常常提起的是，作者个人与主要的GUI提供者例如QT(TrollTech)，MiniGUI(魏老师)，mGUI(移软)都有着相当长的个人和业务关系，所以这个选择就显得更加的“人情化”。如果没有一个科学的和公正的立场，那么结果可想而知。
从标准化角度和行业利益最大化的角度来看，在选择GUI之前我们设立3个原则：
1、自由原则，GUI的技术和授权方式必须能够为其使用者提供的自由度，既能够支持商业版本的应用，又要能够支持开源的应用。所以，LGPL,BSD, Mozilla等的授权方式比起GPL或者私有的授权协议来说更符合这个原则。
2、成熟原则，GUI必须通过极限应用的检验，例如如果应用环境中平均应用的代码行数在10万行的话，那么这个GUI必须通过超过100万行代码的单个应用的检验。通过这种检验我们可以直观地获得GUI在功能的丰富程度和代码的可扩展和鲁棒性。
3、适用原则，GUI必须是能够直接或者通过裁减运行在嵌入式环境中的，其API兼容性不应该因为这种裁减发生重大改变的（理想状况下是不变的）。
在这3个原则的指导下，我们对QT,miniGUI,GTK等GUI进行了对比，对比结果就不一一列举了。结论是，GTK更接近我们的原则，它是LGPL 的，大量的桌面应用都是基于GTK的，在手机中已经有了超过500万部的使用纪录。但是，美中不足的是，GTK的定制和裁减都是厂商的个体行为，没有回馈到开源社区。
所以，我们将工作的重点放在了加强GTK对“适用原则”的符合程度。我们通过与开源社区合作，提供了一个GTK的嵌入式补丁，目的是通过更改公用部分的处理，例如键盘和鼠标输入的替换等，在不改变Widget接口的情况在，达到嵌入场景的适应性。并且，不断的推动相关人士，加强对GTK社区的说复。目前已经取得初步的进展，首先GTK的主要维护者认识到了嵌入式的需求和目前现实的差距，以及相关机构和个人进行嵌入化的努力，同意在今后的版本中考虑嵌入式的需求。这是关键一步，迈向理想的“适用”，即嵌入并兼容。
从标准化角度和行业利益最大化的角度来看，在选择GUI之前我们设立3个原则：
1、自由原则，GUI的技术和授权方式必须能够为其使用者提供的自由度，既能够支持商业版本的应用，又要能够支持开源的应用。所以，LGPL,BSD, Mozilla等的授权方式比起GPL或者私有的授权协议来说更符合这个原则。
2、成熟原则，GUI必须通过极限应用的检验，例如如果应用环境中平均应用的代码行数在10万行的话，那么这个GUI必须通过超过100万行代码的单个应用的检验。通过这种检验我们可以直观地获得GUI在功能的丰富程度和代码的可扩展和鲁棒性。
3、适用原则，GUI必须是能够直接或者通过裁减运行在嵌入式环境中的，其API兼容性不应该因为这种裁减发生重大改变的（理想状况下是不变的）。
在这3个原则的指导下，我们对QT,miniGUI,GTK等GUI进行了对比，对比结果就不一一列举了。结论是，GTK更接近我们的原则，它是LGPL 的，大量的桌面应用都是基于GTK的，在手机中已经有了超过500万部的使用纪录。但是，美中不足的是，GTK的定制和裁减都是厂商的个体行为，没有回馈到开源社区。
所以，我们将工作的重点放在了加强GTK对“适用原则”的符合程度。我们通过与开源社区合作，提供了一个GTK的嵌入式补丁，目的是通过更改公用部分的处理，例如键盘和鼠标输入的替换等，在不改变Widget接口的情况在，达到嵌入场景的适应性。并且，不断的推动相关人士，加强对GTK社区的说复。目前已经取得初步的进展，首先GTK的主要维护者认识到了嵌入式的需求和目前现实的差距，以及相关机构和个人进行嵌入化的努力，同意在今后的版本中考虑嵌入式的需求。这是关键一步，迈向理想的“适用”，即嵌入并兼容。
#include <stdio.h>;
#include <stdlib.h>;
#include <sys/wait.h>;
#include <sys/types.h>;
int main()
{
pid_t status ;
errno = 0 ;
status = system("cp hello.c hello.c.bak") ;
if (status == -1)
printf("system error!") ;
if (WIFEXITED(status)){
printf("cp exit normal![%d]\n", errno) ;
printf("exit staus = [%X]\n", WEXITSTATUS(status)) ;
}else
printf("cp exit illegal![%d]\n", errno) ;
}
[/code]
测试了一把.结果如下
如果hello.c存在,cp也成功将hello.c拷贝到了hello.c.bak则打印
cp exit normal![0]
exit status = [0]
如果hello.c不存在,则打印
cp exit normal![0]
exit status = [1]
我的问题是.
1.在何种情况下会打印cp exit illegal!
2.如果是exit normal,那么exit status的值是否和system调用执行的进程紧密相关(如本例中的cp)
3.如果上个问题的回答是肯定的,那我该如何得到关于cp的各种退出状态.cp的手册页里好象没有相关说明.
老调重弹－－问system返回值
第二个问题我测试了一下,回答是肯定的.
exit status等于被调用程序的用exit(n)或者return n
给出的值.
第一个问题还是不知道.
我在被调用程序运行过程中将他kill掉.
程序还是打印exit normal!可是status取到的值明显是不对的.
faint
老调重弹－－问system返回值
UP
老调重弹－－问system返回值
WIFEXITED(status)
returns true if the child terminated normally, that is, by call-
ing exit() or _exit(), or by returning from main().
老调重弹－－问system返回值
楼上的兄弟谢谢了.
我不明白的正是这个问题.
按照上面的描述,我把被调用的进程kill掉.按照我的理解
WIFEXITED(status)不应该返回真才对.
老调重弹－－问system返回值
没有人知道吗?
老调重弹－－问system返回值
man里面说-->
不管你有没有hello.c文件。你的system都会正常结束，也就都不会返回-1，区别只是cp动作的结束状态不同。
老调重弹－－问system返回值
-->
是的,这个我知道,
我现在想知道的是什么情况下
WIFEXITED(status)不会返回真.
我不明白为什么我把被调用的进程中间KILL掉这个宏的值还是真.
但是WEXITSTATUS(status)的值明显不是被调用进程的返回值.
老调重弹－－问system返回值
你怎么kill掉的呢？cp之间你kill它？^_^，我也不太明白。
老调重弹－－问system返回值
[code]
#include <stdio.h>;
#include <stdlib.h>;
#include <sys/wait.h>;
#include <sys/types.h>;
int main()
{
pid_t status ;
errno = 0 ;
status = system("./hi") ;
if (status == -1)
printf("system error!") ;
if (WIFEXITED(status)){
printf("process exit normal![%d]\n", errno) ;
printf("exit staus = [%X]\n", WEXITSTATUS(status)) ;
}else
printf("process exit illegal![%d]\n", errno) ;
}
[/code]
[code]
int main()
{
printf("HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n") ;
sleep(20) ;
return 4 ;
}
[/code]
这样就可以做到在运行中把进程"hi"kill掉了.
如过是正常退出WEXITSTATUS(status)的值是4
如果是KILL掉
WIFEXITED(status)J还是真,但是WEXITSTATUS(status)的值却是86
这个86真让人faint.
#include <stdlib.h>;
#include <sys/wait.h>;
#include <sys/types.h>;
int main()
{
pid_t status ;
errno = 0 ;
status = system("cp hello.c hello.c.bak") ;
if (status == -1)
printf("system error!") ;
if (WIFEXITED(status)){
printf("cp exit normal![%d]\n", errno) ;
printf("exit staus = [%X]\n", WEXITSTATUS(status)) ;
}else
printf("cp exit illegal![%d]\n", errno) ;
}
[/code]
测试了一把.结果如下
如果hello.c存在,cp也成功将hello.c拷贝到了hello.c.bak则打印
cp exit normal![0]
exit status = [0]
如果hello.c不存在,则打印
cp exit normal![0]
exit status = [1]
我的问题是.
1.在何种情况下会打印cp exit illegal!
2.如果是exit normal,那么exit status的值是否和system调用执行的进程紧密相关(如本例中的cp)
3.如果上个问题的回答是肯定的,那我该如何得到关于cp的各种退出状态.cp的手册页里好象没有相关说明.
老调重弹－－问system返回值
第二个问题我测试了一下,回答是肯定的.
exit status等于被调用程序的用exit(n)或者return n
给出的值.
第一个问题还是不知道.
我在被调用程序运行过程中将他kill掉.
程序还是打印exit normal!可是status取到的值明显是不对的.
faint
老调重弹－－问system返回值
UP
老调重弹－－问system返回值
WIFEXITED(status)
returns true if the child terminated normally, that is, by call-
ing exit() or _exit(), or by returning from main().
老调重弹－－问system返回值
楼上的兄弟谢谢了.
我不明白的正是这个问题.
按照上面的描述,我把被调用的进程kill掉.按照我的理解
WIFEXITED(status)不应该返回真才对.
老调重弹－－问system返回值
没有人知道吗?
老调重弹－－问system返回值
man里面说-->
不管你有没有hello.c文件。你的system都会正常结束，也就都不会返回-1，区别只是cp动作的结束状态不同。
老调重弹－－问system返回值
-->
是的,这个我知道,
我现在想知道的是什么情况下
WIFEXITED(status)不会返回真.
我不明白为什么我把被调用的进程中间KILL掉这个宏的值还是真.
但是WEXITSTATUS(status)的值明显不是被调用进程的返回值.
老调重弹－－问system返回值
你怎么kill掉的呢？cp之间你kill它？^_^，我也不太明白。
老调重弹－－问system返回值
[code]
#include <stdio.h>;
#include <stdlib.h>;
#include <sys/wait.h>;
#include <sys/types.h>;
int main()
{
pid_t status ;
errno = 0 ;
status = system("./hi") ;
if (status == -1)
printf("system error!") ;
if (WIFEXITED(status)){
printf("process exit normal![%d]\n", errno) ;
printf("exit staus = [%X]\n", WEXITSTATUS(status)) ;
}else
printf("process exit illegal![%d]\n", errno) ;
}
[/code]
[code]
int main()
{
printf("HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n") ;
sleep(20) ;
return 4 ;
}
[/code]
这样就可以做到在运行中把进程"hi"kill掉了.
如过是正常退出WEXITSTATUS(status)的值是4
如果是KILL掉
WIFEXITED(status)J还是真,但是WEXITSTATUS(status)的值却是86
这个86真让人faint.
这是一个初学者常问的问题,也是初学者问嵌入式该如何入门的根源。我感觉有两个方面,偏硬和偏软.我不认为嵌入式开发软件占绝对比重,相反,软硬件都懂,才是嵌入式高手所应该追求的,也是高手的必由之路。
硬件道路:
第一步: pcb设计,一般为开发板的电路裁减和扩充,由开发板原理图为基础,画出PCB和封装库,设计自己的电路。
第二步: SOPC技术,一般为FPGA,CPLD开发,利用VHDL等硬件描述语言做专用芯片开发,写出自己的逻辑电路,基于ALTER或XILINUX的FPGA做开发。
第三步: SOC设计,分前端,后端实现,这是硬件设计的核心技术:芯片设计.能做到这步,已经不属于平凡的技术人员。
软件道路:
第一步:bootloader的编写，修改, 通过这步熟悉ARM硬件结构,学习ARM汇编语言,阅读ARM的芯片手册,感觉就是像操作51单片机一样操作ARM芯片.这一步最好的两个参考资料就是:芯片手册和bootloader源代码。
第二步:系统移植, 驱动开发, 我只做过linux方向,所以也推荐学习嵌入式linux系统,作为标准体系,他开源而且可以获得大量学习资料.操作系统是整个计算机科学的核心,熟悉 kernel实属不易,kernel, 驱动开发的学习,没有什么捷径,只有多读代码,多写代码,熟悉系统API.. understanding linux kernel , linux device driver 都是不可多得的好书，值得一看。
第三步:应用程序的编写,各种GUI的移植,qt , minigui都被大量采用,两种思想都类似,熟悉一种就可以。
软件道路中,驱动,系统应该是最深入的部分,不是短时间可以掌握的,需要有勇气和耐心。嵌入式开发,软硬结合,因为硬件条件比PC差很多,所以肯定会遇见不少问题,因此实践的勇气更加重要.有问题就解决问题，无数次的实验,也许是解决问题的必由之路。
硬件道路:
第一步: pcb设计,一般为开发板的电路裁减和扩充,由开发板原理图为基础,画出PCB和封装库,设计自己的电路。
第二步: SOPC技术,一般为FPGA,CPLD开发,利用VHDL等硬件描述语言做专用芯片开发,写出自己的逻辑电路,基于ALTER或XILINUX的FPGA做开发。
第三步: SOC设计,分前端,后端实现,这是硬件设计的核心技术:芯片设计.能做到这步,已经不属于平凡的技术人员。
软件道路:
第一步:bootloader的编写，修改, 通过这步熟悉ARM硬件结构,学习ARM汇编语言,阅读ARM的芯片手册,感觉就是像操作51单片机一样操作ARM芯片.这一步最好的两个参考资料就是:芯片手册和bootloader源代码。
第二步:系统移植, 驱动开发, 我只做过linux方向,所以也推荐学习嵌入式linux系统,作为标准体系,他开源而且可以获得大量学习资料.操作系统是整个计算机科学的核心,熟悉 kernel实属不易,kernel, 驱动开发的学习,没有什么捷径,只有多读代码,多写代码,熟悉系统API.. understanding linux kernel , linux device driver 都是不可多得的好书，值得一看。
第三步:应用程序的编写,各种GUI的移植,qt , minigui都被大量采用,两种思想都类似,熟悉一种就可以。
软件道路中,驱动,系统应该是最深入的部分,不是短时间可以掌握的,需要有勇气和耐心。嵌入式开发,软硬结合,因为硬件条件比PC差很多,所以肯定会遇见不少问题,因此实践的勇气更加重要.有问题就解决问题，无数次的实验,也许是解决问题的必由之路。
原帖地址：http://blog.s135.com/read.php/269.htm
[文章作者：张宴 本文版本：v1.1 最后修改：2007.07.27 转载请注明出处：http://blog.s135.com]
这两天搭建了一组Apache服务器，每台服务器4G内存，采用的是prefork模式，一开始设置的连接数太少了，需要较长的时间去响应用户的请求，后来修改了一下Apache 2.0.59的配置文件httpd.conf：
引用
# prefork MPM
# StartServers: number of server processes to start
# MinSpareServers: minimum number of server processes which are kept spare
# MaxSpareServers: maximum number of server processes which are kept spare
# MaxClients: maximum number of server processes allowed to start
# MaxRequestsPerChild: maximum number of requests a server process serves
StartServers 10
MinSpareServers 10
MaxSpareServers 15
ServerLimit 2000
MaxClients 2000
MaxRequestsPerChild 10000
--------------------------------------------------------------------------------
查看httpd进程数（即prefork模式下Apache能够处理的并发请求数）：
Linux命令：
引用
ps -ef | grep httpd | wc -l
返回结果示例：
1388
表示Apache能够处理1388个并发请求，这个值Apache可根据负载情况自动调整，我这组服务器中每台的峰值曾达到过2002。
--------------------------------------------------------------------------------
查看Apache的并发请求数及其TCP连接状态：
Linux命令：
引用
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
（这条语句是从新浪互动社区事业部技术总监王老大那儿获得的，非常不错）
返回结果示例：
LAST_ACK 5
SYN_RECV 30
ESTABLISHED 1597
FIN_WAIT1 51
FIN_WAIT2 504
TIME_WAIT 1057
其中的SYN_RECV表示正在等待处理的请求数；ESTABLISHED表示正常数据传输状态；TIME_WAIT表示处理完毕，等待超时结束的请求数。
--------------------------------------------------------------------------------
关于TCP状态的变迁，可以从下图形象地看出：
状态：描述
CLOSED：无连接是活动的或正在进行
LISTEN：服务器在等待进入呼叫
SYN_RECV：一个连接请求已经到达，等待确认
SYN_SENT：应用已经开始，打开一个连接
ESTABLISHED：正常数据传输状态
FIN_WAIT1：应用说它已经完成
FIN_WAIT2：另一边已同意释放
ITMED_WAIT：等待所有分组死掉
CLOSING：两边同时尝试关闭
TIME_WAIT：另一边已初始化一个释放
LAST_ACK：等待所有分组死掉
[文章作者：张宴 本文版本：v1.1 最后修改：2007.07.27 转载请注明出处：http://blog.s135.com]
这两天搭建了一组Apache服务器，每台服务器4G内存，采用的是prefork模式，一开始设置的连接数太少了，需要较长的时间去响应用户的请求，后来修改了一下Apache 2.0.59的配置文件httpd.conf：
引用
# prefork MPM
# StartServers: number of server processes to start
# MinSpareServers: minimum number of server processes which are kept spare
# MaxSpareServers: maximum number of server processes which are kept spare
# MaxClients: maximum number of server processes allowed to start
# MaxRequestsPerChild: maximum number of requests a server process serves
StartServers 10
MinSpareServers 10
MaxSpareServers 15
ServerLimit 2000
MaxClients 2000
MaxRequestsPerChild 10000
--------------------------------------------------------------------------------
查看httpd进程数（即prefork模式下Apache能够处理的并发请求数）：
Linux命令：
引用
ps -ef | grep httpd | wc -l
返回结果示例：
1388
表示Apache能够处理1388个并发请求，这个值Apache可根据负载情况自动调整，我这组服务器中每台的峰值曾达到过2002。
--------------------------------------------------------------------------------
查看Apache的并发请求数及其TCP连接状态：
Linux命令：
引用
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
（这条语句是从新浪互动社区事业部技术总监王老大那儿获得的，非常不错）
返回结果示例：
LAST_ACK 5
SYN_RECV 30
ESTABLISHED 1597
FIN_WAIT1 51
FIN_WAIT2 504
TIME_WAIT 1057
其中的SYN_RECV表示正在等待处理的请求数；ESTABLISHED表示正常数据传输状态；TIME_WAIT表示处理完毕，等待超时结束的请求数。
--------------------------------------------------------------------------------
关于TCP状态的变迁，可以从下图形象地看出：
状态：描述
CLOSED：无连接是活动的或正在进行
LISTEN：服务器在等待进入呼叫
SYN_RECV：一个连接请求已经到达，等待确认
SYN_SENT：应用已经开始，打开一个连接
ESTABLISHED：正常数据传输状态
FIN_WAIT1：应用说它已经完成
FIN_WAIT2：另一边已同意释放
ITMED_WAIT：等待所有分组死掉
CLOSING：两边同时尝试关闭
TIME_WAIT：另一边已初始化一个释放
LAST_ACK：等待所有分组死掉
var nameVal = Trim(document.form1.name.value);
if(nameVal == '')
{
alert("ÓʼþÁбíÃû³ÆÊäÈëÎÞЧ£¬ÇëÖØÐÂÊäÈë");
return;
}
if (nameVal.indexOf(" ")>=0)
{
alert("ÓʼþÁбíÃû³ÆÖм䲻Äܺ¬Óпոñ£¬ÇëÖØÐÂÊýÊäÈë");
return;
}
一个是对前后空格的去掉，一个是对中间空格的去掉。
其indexOf是返回其位置，有则大于0，但是前面已经去掉前后空格，因此，可以说这样的alert很准确。。。
if(nameVal == '')
{
alert("ÓʼþÁбíÃû³ÆÊäÈëÎÞЧ£¬ÇëÖØÐÂÊäÈë");
return;
}
if (nameVal.indexOf(" ")>=0)
{
alert("ÓʼþÁбíÃû³ÆÖм䲻Äܺ¬Óпոñ£¬ÇëÖØÐÂÊýÊäÈë");
return;
}
一个是对前后空格的去掉，一个是对中间空格的去掉。
其indexOf是返回其位置，有则大于0，但是前面已经去掉前后空格，因此，可以说这样的alert很准确。。。
Google在Google Code上释放出基于GPL发行的MySQL-4.0.26优化补丁,及两个Python编写的脚本工具. google code的google-mysql-tools页面：http://code.google.com/p/google-mysql-tools/Mysql4Patches Patches for MySQL 4.0IntroductionThese are patches for MySQL 4.0.26. They add many features that enhance the manageability and reliability of MySQL.In a perfect world, each feature would be provided as a separate patch and all code would be as portable as MySQL. We are not there yet. These have been implemented and deployed on Linux. Also, some of these features only work with InnoDB, because we use InnoDB. They could be extended to support other storage engines.The patch should be applied to MySQL 4.0.26 source code. That source is available from the download section for this project. The patch can be applied to the source as: tar xf mysql-4.0.26.tar.gz cd mysql-4.0.26 patch --strip=1 --fuzz=1 < ../mysql-4.0.26-patchesmysql-4.0.26补丁下载地址： http://google-mysql-tools.googlecode.com/files/mysql-4.0.26.tar.gz
1.主频
主频也叫时钟频率，单位是MHz，用来表示CPU的运算速度。CPU的主频＝外频×倍频系数。很多人认为主频就决定着CPU的运行速度，这不仅是个片面的，而且对于服务器来讲，这个认识也出现了偏差。至今，没有一条确定的公式能够实现主频和实际的运算速度两者之间的数值关系，即使是两大处理器厂家Intel和AMD，在这点上也存在着很大的争议，我们从Intel的产品的发展趋势，可以看出Intel很注重加强自身主频的发展。像其他的处理器厂家，有人曾经拿过一快1G的全美达来做比较，它的运行效率相当于2G的Intel处理器。
所以，CPU的主频与CPU实际的运算能力是没有直接关系的，主频表示在CPU内数字脉冲信号震荡的速度。在Intel的处理器产品中，我们也可以看到这样的例子：1 GHz Itanium芯片能够表现得差不多跟2.66 GHz Xeon/Opteron一样快，或是1.5 GHz Itanium 2大约跟4 GHz Xeon/Opteron一样快。CPU的运算速度还要看CPU的流水线的各方面的性能指标。
当然，主频和实际的运算速度是有关的，只能说主频仅仅是CPU性能表现的一个方面，而不代表CPU的整体性能。
2.外频
外频是CPU的基准频率，单位也是MHz。CPU的外频决定着整块主板的运行速度。说白了，在台式机中，我们所说的超频，都是超CPU的外频（当然一般情况下，CPU的倍频都是被锁住的）相信这点是很好理解的。但对于服务器CPU来讲，超频是绝对不允许的。前面说到CPU决定着主板的运行速度，两者是同步运行的，如果把服务器CPU超频了，改变了外频，会产生异步运行，（台式机很多主板都支持异步运行）这样会造成整个服务器系统的不稳定。
目前的绝大部分电脑系统中外频也是内存与主板之间的同步运行的速度，在这种方式下，可以理解为CPU的外频直接与内存相连通，实现两者间的同步运行状态。外频与前端总线(FSB)频率很容易被混为一谈，下面的前端总线介绍我们谈谈两者的区别。
3.前端总线(FSB)频率
前端总线(FSB)频率(即总线频率)是直接影响CPU与内存直接数据交换速度。有一条公式可以计算，即数据带宽＝(总线频率×数据带宽)/8，数据传输最大带宽取决于所有同时传输的数据的宽度和传输频率。比方，现在的支持64位的至强Nocona，前端总线是800MHz，按照公式，它的数据传输最大带宽是6.4GB/秒。
外频与前端总线(FSB)频率的区别：前端总线的速度指的是数据传输的速度，外频是CPU与主板之间同步运行的速度。也就是说，100MHz外频特指数字脉冲信号在每秒钟震荡一千万次；而100MHz前端总线指的是每秒钟CPU可接受的数据传输量是100MHz×64bit÷8Byte/bit=800MB/s。
其实现在“HyperTransport”构架的出现，让这种实际意义上的前端总线(FSB)频率发生了变化。之前我们知道IA-32架构必须有三大重要的构件：内存控制器Hub (MCH) ,I/O控制器Hub和PCI Hub，像Intel很典型的芯片组 Intel 7501、Intel7505芯片组，为双至强处理器量身定做的，它们所包含的MCH为CPU提供了频率为533MHz的前端总线，配合DDR内存，前端总线带宽可达到4.3GB/秒。但随着处理器性能不断提高同时给系统架构带来了很多问题。而“HyperTransport”构架不但解决了问题，而且更有效地提高了总线带宽，比方AMD Opteron处理器，灵活的HyperTransport I/O总线体系结构让它整合了内存控制器，使处理器不通过系统总线传给芯片组而直接和内存交换数据。这样的话，前端总线(FSB)频率在AMD Opteron处理器就不知道从何谈起了。
4、CPU的位和字长
位：在数字电路和电脑技术中采用二进制，代码只有“0”和“1”，其中无论是 “0”或是“1”在CPU中都是 一“位”。
字长：电脑技术中对CPU在单位时间内(同一时间)能一次处理的二进制数的位数叫字长。所以能处理字长为8位数据的CPU通常就叫8位的CPU。同理32位的CPU就能在单位时间内处理字长为32位的二进制数据。字节和字长的区别：由于常用的英文字符用8位二进制就可以表示，所以通常就将8位称为一个字节。字长的长度是不固定的，对于不同的CPU、字长的长度也不一样。8位的CPU一次只能处理一个字节，而32位的CPU一次就能处理4个字节，同理字长为64位的CPU一次可以处理8个字节。
5.倍频系数
倍频系数是指CPU主频与外频之间的相对比例关系。在相同的外频下，倍频越高CPU的频率也越高。但实际上，在相同外频的前提下，高倍频的CPU本身意义并不大。这是因为CPU与系统之间数据传输速度是有限的，一味追求高倍频而得到高主频的CPU就会出现明显的“瓶颈”效应?CPU从系统中得到数据的极限速度不能够满足CPU运算的速度。一般除了工程样版的Intel的CPU都是锁了倍频的，而AMD之前都没有锁
6.缓存
缓存大小也是CPU的重要指标之一，而且缓存的结构和大小对CPU速度的影响非常大，CPU内缓存的运行频率极高，一般是和处理器同频运作，工作效率远远大于系统内存和硬盘。实际工作时，CPU往往需要重复读取同样的数据块，而缓存容量的增大，可以大幅度提升CPU内部读取数据的命中率，而不用再到内存或者硬盘上寻找，以此提高系统性能。但是由于CPU芯片面积和成本的因素来考虑，缓存都很小。
L1 Cache(一级缓存)是CPU第一层高速缓存，分为数据缓存和指令缓存。内置的L1高速缓存的容量和结构对CPU的性能影响较大，不过高速缓冲存储器均由静态RAM组成，结构较复杂，在CPU管芯面积不能太大的情况下，L1级高速缓存的容量不可能做得太大。一般服务器CPU的L1缓存的容量通常在32?256KB。
L2 Cache(二级缓存)是CPU的第二层高速缓存，分内部和外部两种芯片。内部的芯片二级缓存运行速度与主频相同，而外部的二级缓存则只有主频的一半。L2高速缓存容量也会影响CPU的性能，原则是越大越好，现在家庭用CPU容量最大的是512KB，而服务器和工作站上用CPU的L2高速缓存更高达256-1MB，有的高达2MB或者3MB。
L3 Cache(三级缓存)，分为两种，早期的是外置，现在的都是内置的。而它的实际作用即是，L3缓存的应用可以进一步降低内存延迟，同时提升大数据量计算时处理器的性能。降低内存延迟和提升大数据量计算能力对游戏都很有帮助。而在服务器领域增加L3缓存在性能方面仍然有显著的提升。比方具有较大L3缓存的配置利用物理内存会更有效，故它比较慢的磁盘I/O子系统可以处理更多的数据请求。具有较大L3缓存的处理器提供更有效的文件系统缓存行为及较短消息和处理器队列长度。
其实最早的L3缓存被应用在AMD发布的K6-III处理器上，当时的L3缓存受限于制造工艺，并没有被集成进芯片内部，而是集成在主板上。在只能够和系统总线频率同步的L3缓存同主内存其实差不了多少。后来使用L3缓存的是英特尔为服务器市场所推出的Itanium处理器。接着就是P4EE和至强MP。Intel还打算推出一款9MB L3缓存的Itanium2处理器，和以后24MB L3缓存的双核心Itanium2处理器。
但基本上L3缓存对处理器的性能提高显得不是很重要，比方配备1MB L3缓存的Xeon MP处理器却仍然不是Opteron的对手，由此可见前端总线的增加，要比缓存增加带来更有效的性能提升。
7.CPU扩展指令集
CPU依靠指令来计算和控制系统，每款CPU在设计时就规定了一系列与其硬件电路相配合的指令系统。指令的强弱也是CPU的重要指标，指令集是提高微处理器效率的最有效工具之一。从现阶段的主流体系结构讲，指令集可分为复杂指令集和精简指令集两部分，而从具体运用看，如Intel的MMX（Multi Media Extended）、SSE、 SSE2（Streaming-Single instruction multiple data-Extensions 2）、SEE3和AMD的3DNow!等都是CPU的扩展指令集，分别增强了CPU的多媒体、图形图象和Internet等的处理能力。我们通常会把CPU的扩展指令集称为"CPU的指令集"。SSE3指令集也是目前规模最小的指令集，此前MMX包含有57条命令，SSE包含有50条命令，SSE2包含有144条命令，SSE3包含有13条命令。目前SSE3也是最先进的指令集，英特尔Prescott处理器已经支持SSE3指令集，AMD会在未来双核心处理器当中加入对SSE3指令集的支持，全美达的处理器也将支持这一指令集。
8.CPU内核和I/O工作电压
从586CPU开始，CPU的工作电压分为内核电压和I/O电压两种，通常CPU的核心电压小于等于I/O电压。其中内核电压的大小是根据CPU的生产工艺而定，一般制作工艺越小，内核工作电压越低；I/O电压一般都在1.6~5V。低电压能解决耗电过大和发热过高的问题。
9.制造工艺
制造工艺的微米是指IC内电路与电路之间的距离。制造工艺的趋势是向密集度愈高的方向发展。密度愈高的IC电路设计，意味着在同样大小面积的IC中，可以拥有密度更高、功能更复杂的电路设计。现在主要的180nm、130nm、90nm。最近官方已经表示有65nm的制造工艺了。
10.指令集
（1）CISC指令集
CISC指令集，也称为复杂指令集，英文名是CISC，（Complex Instruction Set Computer的缩写）。在CISC微处理器中，程序的各条指令是按顺序串行执行的，每条指令中的各个操作也是按顺序串行执行的。顺序执行的优点是控制简单，但计算机各部分的利用率不高，执行速度慢。其实它是英特尔生产的x86系列（也就是IA-32架构）CPU及其兼容CPU，如AMD、VIA的。即使是现在新起的X86-64（也被成AMD64）都是属于CISC的范畴。
要知道什么是指令集还要从当今的X86架构的CPU说起。X86指令集是Intel为其第一块16位CPU(i8086)专门开发的，IBM1981年推出的世界第一台PC机中的CPU?i8088(i8086简化版)使用的也是X86指令，同时电脑中为提高浮点数据处理能力而增加了X87芯片，以后就将X86指令集和X87指令集统称为X86指令集。
虽然随着CPU技术的不断发展，Intel陆续研制出更新型的i80386、i80486直到过去的PII至强、PIII至强、Pentium 3，最后到今天的Pentium 4系列、至强（不包括至强Nocona），但为了保证电脑能继续运行以往开发的各类应用程序以保护和继承丰富的软件资源，所以Intel公司所生产的所有CPU仍然继续使用X86指令集，所以它的CPU仍属于X86系列。由于Intel X86系列及其兼容CPU（如AMD Athlon MP、）都使用X86指令集，所以就形成了今天庞大的X86系列及兼容CPU阵容。x86CPU目前主要有intel的服务器CPU和AMD的服务器CPU两类。
（2）RISC指令集
RISC是英文“Reduced Instruction Set Computing ” 的缩写，中文意思是“精简指令集”。它是在CISC指令系统基础上发展起来的，有人对CISC机进行测试表明，各种指令的使用频度相当悬殊，最常使用的是一些比较简单的指令，它们仅占指令总数的20％，但在程序中出现的频度却占80％。复杂的指令系统必然增加微处理器的复杂性，使处理器的研制时间长，成本高。并且复杂指令需要复杂的操作，必然会降低计算机的速度。基于上述原因，20世纪80年代RISC型CPU诞生了，相对于CISC型CPU ,RISC型CPU不仅精简了指令系统，还采用了一种叫做“超标量和超流水线结构”，大大增加了并行处理能力。RISC指令集是高性能CPU的发展方向。它与传统的CISC(复杂指令集)相对。相比而言，RISC的指令格式统一，种类比较少，寻址方式也比复杂指令集少。当然处理速度就提高很多了。目前在中高档服务器中普遍采用这一指令系统的CPU，特别是高档服务器全都采用RISC指令系统的CPU。RISC指令系统更加适合高档服务器的操作系统UNIX，现在Linux也属于类似UNIX的操作系统。RISC型CPU与Intel和AMD的CPU在软件和硬件上都不兼容。
目前，在中高档服务器中采用RISC指令的CPU主要有以下几类：PowerPC处理器、SPARC处理器、PA-RISC处理器、MIPS处理器、Alpha处理器。
（3）IA-64
EPIC（Explicitly Parallel Instruction Computers，精确并行指令计算机）是否是RISC和CISC体系的继承者的争论已经有很多，单以EPIC体系来说，它更像Intel的处理器迈向RISC体系的重要步骤。从理论上说，EPIC体系设计的CPU，在相同的主机配置下，处理Windows的应用软件比基于Unix下的应用软件要好得多。
Intel采用EPIC技术的服务器CPU是安腾Itanium（开发代号即Merced）。它是64位处理器，也是IA－64系列中的第一款。微软也已开发了代号为Win64的操作系统，在软件上加以支持。在Intel采用了X86指令集之后，它又转而寻求更先进的64-bit微处理器，Intel这样做的原因是，它们想摆脱容量巨大的x86架构,从而引入精力充沛而又功能强大的指令集，于是采用EPIC指令集的IA-64架构便诞生了。IA-64 在很多方面来说，都比x86有了长足的进步。突破了传统IA32架构的许多限制，在数据的处理能力，系统的稳定性、安全性、可用性、可观理性等方面获得了突破性的提高。
IA-64微处理器最大的缺陷是它们缺乏与x86的兼容，而Intel为了IA-64处理器能够更好地运行两个朝代的软件，它在IA-64处理器上（Itanium、Itanium2 ……)引入了x86-to-IA-64的解码器，这样就能够把x86指令翻译为IA-64指令。这个解码器并不是最有效率的解码器，也不是运行x86代码的最好途径（最好的途径是直接在x86处理器上运行x86代码），因此Itanium 和Itanium2在运行x86应用程序时候的性能非常糟糕。这也成为X86-64产生的根本原因。
（4）X86-64 （AMD64 / EM64T）
AMD公司设计，可以在同一时间内处理64位的整数运算，并兼容于X86-32架构。其中支持64位逻辑定址，同时提供转换为32位定址选项；但数据操作指令默认为32位和8位，提供转换成64位和16位的选项；支持常规用途寄存器，如果是32位运算操作，就要将结果扩展成完整的64位。这样，指令中有“直接执行”和“转换执行”的区别，其指令字段是8位或32位，可以避免字段过长。
x86-64（也叫AMD64）的产生也并非空穴来风，x86处理器的32bit寻址空间限制在4GB内存，而IA-64的处理器又不能兼容x86。AMD充分考虑顾客的需求，加强x86指令集的功能，使这套指令集可同时支持64位的运算模式，因此AMD把它们的结构称之为x86-64。在技术上AMD在x86-64架构中为了进行64位运算，AMD为其引入了新增了R8-R15通用寄存器作为原有X86处理器寄存器的扩充，但在而在32位环境下并不完全使用到这些寄存器。原来的寄存器诸如EAX、EBX也由32位扩张至64位。在SSE单元中新加入了8个新寄存器以提供对SSE2的支持。寄存器数量的增加将带来性能的提升。与此同时，为了同时支持32和64位代码及寄存器，x86-64架构允许处理器工作在以下两种模式：Long Mode(长模式)和Legacy Mode(遗传模式)，Long模式又分为两种子模式(64bit模式和Compatibility mode兼容模式)。该标准已经被引进在AMD服务器处理器中的Opteron处理器。
而今年也推出了支持64位的EM64T技术，再还没被正式命为EM64T之前是IA32E，这是英特尔64位扩展技术的名字,用来区别X86指令集。Intel的EM64T支持64位sub-mode，和AMD的X86-64技术类似，采用64位的线性平面寻址，加入8个新的通用寄存器（GPRs），还增加8个寄存器支持SSE指令。与AMD相类似，Intel的64位技术将兼容IA32和IA32E，只有在运行64位操作系统下的时候，才将会采用IA32E。IA32E将由2个sub-mode组成：64位sub-mode和32位sub-mode，同AMD64一样是向下兼容的。Intel的EM64T将完全兼容AMD的X86-64技术。现在Nocona处理器已经加入了一些64位技术，Intel的Pentium 4E处理器也支持64位技术。
应该说，这两者都是兼容x86指令集的64位微处理器架构，但EM64T与AMD64还是有一些不一样的地方，AMD64处理器中的NX位在Intel的处理器中将没有提供。
11.超流水线与超标量
在解释超流水线与超标量前，先了解流水线(pipeline)。流水线是Intel首次在486芯片中开始使用的。流水线的工作方式就象工业生产上的装配流水线。在CPU中由5?6个不同功能的电路单元组成一条指令处理流水线，然后将一条X86指令分成5?6步后再由这些电路单元分别执行，这样就能实现在一个CPU时钟周期完成一条指令，因此提高CPU的运算速度。经典奔腾每条整数流水线都分为四级流水，即指令预取、译码、执行、写回结果，浮点流水又分为八级流水。
超标量是通过内置多条流水线来同时执行多个处理器，其实质是以空间换取时间。而超流水线是通过细化流水、提高主频，使得在一个机器周期内完成一个甚至多个操作，其实质是以时间换取空间。例如Pentium 4的流水线就长达20级。将流水线设计的步(级)越长，其完成一条指令的速度越快，因此才能适应工作主频更高的CPU。但是流水线过长也带来了一定副作用，很可能会出现主频较高的CPU实际运算速度较低的现象，Intel的奔腾4就出现了这种情况，虽然它的主频可以高达1.4G以上，但其运算性能却远远比不上AMD 1.2G的速龙甚至奔腾III。
12.封装形式
CPU封装是采用特定的材料将CPU芯片或CPU模块固化在其中以防损坏的保护措施，一般必须在封装后CPU才能交付用户使用。CPU的封装方式取决于CPU安装形式和器件集成设计，从大的分类来看通常采用Socket插座进行安装的CPU使用PGA(栅格阵列)方式封装，而采用Slot x槽安装的CPU则全部采用SEC(单边接插盒)的形式封装。现在还有PLGA(Plastic Land Grid Array)、OLGA(Organic Land Grid Array)等封装技术。由于市场竞争日益激烈，目前CPU封装技术的发展方向以节约成本为主。
13、多线程
同时多线程Simultaneous multithreading，简称SMT。SMT可通过复制处理器上的结构状态，让同一个处理器上的多个线程同步执行并共享处理器的执行资源，可最大限度地实现宽发射、乱序的超标量处理，提高处理器运算部件的利用率，缓和由于数据相关或Cache未命中带来的访问内存延时。当没有多个线程可用时，SMT处理器几乎和传统的宽发射超标量处理器一样。SMT最具吸引力的是只需小规模改变处理器核心的设计，几乎不用增加额外的成本就可以显著地提升效能。多线程技术则可以为高速的运算核心准备更多的待处理数据，减少运算核心的闲置时间。这对于桌面低端系统来说无疑十分具有吸引力。Intel从3.06GHz Pentium 4开始，所有处理器都将支持SMT技术。
14、多核心
多核心，也指单芯片多处理器（Chip multiprocessors，简称CMP）。CMP是由美国斯坦福大学提出的，其思想是将大规模并行处理器中的SMP（对称多处理器）集成到同一芯片内，各个处理器并行执行不同的进程。与CMP比较， SMT处理器结构的灵活性比较突出。但是，当半导体工艺进入0.18微米以后，线延时已经超过了门延迟，要求微处理器的设计通过划分许多规模更小、局部性更好的基本单元结构来进行。相比之下，由于CMP结构已经被划分成多个处理器核来设计，每个核都比较简单，有利于优化设计，因此更有发展前途。目前，IBM 的Power 4芯片和Sun的 MAJC5200芯片都采用了CMP结构。多核处理器可以在处理器内部共享缓存，提高缓存利用率，同时简化多处理器系统设计的复杂度。
2005年下半年，Intel和AMD的新型处理器也将融入CMP结构。新安腾处理器开发代码为Montecito，采用双核心设计，拥有最少18MB片内缓存，采取90nm工艺制造，它的设计绝对称得上是对当今芯片业的挑战。它的每个单独的核心都拥有独立的L1，L2和L3 cache，包含大约10亿支晶体管。
15、SMP
SMP（Symmetric Multi-Processing），对称多处理结构的简称，是指在一个计算机上汇集了一组处理器(多CPU),各CPU之间共享内存子系统以及总线结构。在这种技术的支持下，一个服务器系统可以同时运行多个处理器，并共享内存和其他的主机资源。像双至强，也就是我们所说的二路，这是在对称处理器系统中最常见的一种（至强MP可以支持到四路，AMD Opteron可以支持1-8路）。也有少数是16路的。但是一般来讲，SMP结构的机器可扩展性较差，很难做到100个以上多处理器，常规的一般是8个到16个，不过这对于多数的用户来说已经够用了。在高性能服务器和工作站级主板架构中最为常见，像UNIX服务器可支持最多256个CPU的系统。
构建一套SMP系统的必要条件是：支持SMP的硬件包括主板和CPU；支持SMP的系统平台，再就是支持SMP的应用软件。
为了能够使得SMP系统发挥高效的性能，操作系统必须支持SMP系统，如WINNT、LINUX、以及UNIX等等32位操作系统。即能够进行多任务和多线程处理。多任务是指操作系统能够在同一时间让不同的CPU完成不同的任务；多线程是指操作系统能够使得不同的CPU并行的完成同一个任务。
要组建SMP系统，对所选的CPU有很高的要求，首先、CPU内部必须内置APIC（Advanced Programmable Interrupt Controllers）单元。Intel 多处理规范的核心就是高级可编程中断控制器（Advanced Programmable Interrupt Controllers--APICs）的使用；再次，相同的产品型号，同样类型的CPU核心，完全相同的运行频率；最后，尽可能保持相同的产品序列编号，因为两个生产批次的CPU作为双处理器运行的时候，有可能会发生一颗CPU负担过高，而另一颗负担很少的情况，无法发挥最大性能，更糟糕的是可能导致死机。
16、NUMA技术
NUMA即非一致访问分布共享存储技术，它是由若干通过高速专用网络连接起来的独立节点构成的系统，各个节点可以是单个的CPU或是SMP系统。在NUMA中，Cache 的一致性有多种解决方案，需要操作系统和特殊软件的支持。图2中是Sequent公司NUMA系统的例子。这里有3个SMP模块用高速专用网络联起来，组成一个节点，每个节点可以有12个CPU。像Sequent的系统最多可以达到64个CPU甚至256个CPU。显然，这是在SMP的基础上，再用NUMA的技术加以扩展，是这两种技术的结合。
17、乱序执行技术
乱序执行（out-of-orderexecution），是指CPU允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理的技术。这样将根据个电路单元的状态和各指令能否提前执行的具体情况分析后，将能提前执行的指令立即发送给相应电路单元执行，在这期间不按规定顺序执行指令，然后由重新排列单元将各执行单元结果按指令顺序重新排列。采用乱序执行技术的目的是为了使CPU内部电路满负荷运转并相应提高了CPU的运行程序的速度。分枝技术：（branch）指令进行运算时需要等待结果，一般无条件分枝只需要按指令顺序执行，而条件分枝必须根据处理后的结果，再决定是否按原先顺序进行。
18、CPU内部的内存控制器
许多应用程序拥有更为复杂的读取模式（几乎是随机地，特别是当cache hit不可预测的时候），并且没有有效地利用带宽。典型的这类应用程序就是业务处理软件，即使拥有如乱序执行（out of order execution）这样的CPU特性，也会受内存延迟的限制。这样CPU必须得等到运算所需数据被除数装载完成才能执行指令（无论这些数据来自CPU cache还是主内存系统）。当前低段系统的内存延迟大约是120－150ns，而CPU速度则达到了3GHz以上，一次单独的内存请求可能会浪费200－300次CPU循环。即使在缓存命中率（cache hit rate）达到99％的情况下，CPU也可能会花50％的时间来等待内存请求的结束－ 比如因为内存延迟的缘故。
你可以看到Opteron整合的内存控制器，它的延迟，与芯片组支持双通道DDR内存控制器的延迟相比来说，是要低很多的。英特尔也按照计划的那样在处理器内部整合内存控制器，这样导致北桥芯片将变得不那么重要。但改变了处理器访问主存的方式，有助于提高带宽、降低内存延时和提升处理器性能。
主频也叫时钟频率，单位是MHz，用来表示CPU的运算速度。CPU的主频＝外频×倍频系数。很多人认为主频就决定着CPU的运行速度，这不仅是个片面的，而且对于服务器来讲，这个认识也出现了偏差。至今，没有一条确定的公式能够实现主频和实际的运算速度两者之间的数值关系，即使是两大处理器厂家Intel和AMD，在这点上也存在着很大的争议，我们从Intel的产品的发展趋势，可以看出Intel很注重加强自身主频的发展。像其他的处理器厂家，有人曾经拿过一快1G的全美达来做比较，它的运行效率相当于2G的Intel处理器。
所以，CPU的主频与CPU实际的运算能力是没有直接关系的，主频表示在CPU内数字脉冲信号震荡的速度。在Intel的处理器产品中，我们也可以看到这样的例子：1 GHz Itanium芯片能够表现得差不多跟2.66 GHz Xeon/Opteron一样快，或是1.5 GHz Itanium 2大约跟4 GHz Xeon/Opteron一样快。CPU的运算速度还要看CPU的流水线的各方面的性能指标。
当然，主频和实际的运算速度是有关的，只能说主频仅仅是CPU性能表现的一个方面，而不代表CPU的整体性能。
2.外频
外频是CPU的基准频率，单位也是MHz。CPU的外频决定着整块主板的运行速度。说白了，在台式机中，我们所说的超频，都是超CPU的外频（当然一般情况下，CPU的倍频都是被锁住的）相信这点是很好理解的。但对于服务器CPU来讲，超频是绝对不允许的。前面说到CPU决定着主板的运行速度，两者是同步运行的，如果把服务器CPU超频了，改变了外频，会产生异步运行，（台式机很多主板都支持异步运行）这样会造成整个服务器系统的不稳定。
目前的绝大部分电脑系统中外频也是内存与主板之间的同步运行的速度，在这种方式下，可以理解为CPU的外频直接与内存相连通，实现两者间的同步运行状态。外频与前端总线(FSB)频率很容易被混为一谈，下面的前端总线介绍我们谈谈两者的区别。
3.前端总线(FSB)频率
前端总线(FSB)频率(即总线频率)是直接影响CPU与内存直接数据交换速度。有一条公式可以计算，即数据带宽＝(总线频率×数据带宽)/8，数据传输最大带宽取决于所有同时传输的数据的宽度和传输频率。比方，现在的支持64位的至强Nocona，前端总线是800MHz，按照公式，它的数据传输最大带宽是6.4GB/秒。
外频与前端总线(FSB)频率的区别：前端总线的速度指的是数据传输的速度，外频是CPU与主板之间同步运行的速度。也就是说，100MHz外频特指数字脉冲信号在每秒钟震荡一千万次；而100MHz前端总线指的是每秒钟CPU可接受的数据传输量是100MHz×64bit÷8Byte/bit=800MB/s。
其实现在“HyperTransport”构架的出现，让这种实际意义上的前端总线(FSB)频率发生了变化。之前我们知道IA-32架构必须有三大重要的构件：内存控制器Hub (MCH) ,I/O控制器Hub和PCI Hub，像Intel很典型的芯片组 Intel 7501、Intel7505芯片组，为双至强处理器量身定做的，它们所包含的MCH为CPU提供了频率为533MHz的前端总线，配合DDR内存，前端总线带宽可达到4.3GB/秒。但随着处理器性能不断提高同时给系统架构带来了很多问题。而“HyperTransport”构架不但解决了问题，而且更有效地提高了总线带宽，比方AMD Opteron处理器，灵活的HyperTransport I/O总线体系结构让它整合了内存控制器，使处理器不通过系统总线传给芯片组而直接和内存交换数据。这样的话，前端总线(FSB)频率在AMD Opteron处理器就不知道从何谈起了。
4、CPU的位和字长
位：在数字电路和电脑技术中采用二进制，代码只有“0”和“1”，其中无论是 “0”或是“1”在CPU中都是 一“位”。
字长：电脑技术中对CPU在单位时间内(同一时间)能一次处理的二进制数的位数叫字长。所以能处理字长为8位数据的CPU通常就叫8位的CPU。同理32位的CPU就能在单位时间内处理字长为32位的二进制数据。字节和字长的区别：由于常用的英文字符用8位二进制就可以表示，所以通常就将8位称为一个字节。字长的长度是不固定的，对于不同的CPU、字长的长度也不一样。8位的CPU一次只能处理一个字节，而32位的CPU一次就能处理4个字节，同理字长为64位的CPU一次可以处理8个字节。
5.倍频系数
倍频系数是指CPU主频与外频之间的相对比例关系。在相同的外频下，倍频越高CPU的频率也越高。但实际上，在相同外频的前提下，高倍频的CPU本身意义并不大。这是因为CPU与系统之间数据传输速度是有限的，一味追求高倍频而得到高主频的CPU就会出现明显的“瓶颈”效应?CPU从系统中得到数据的极限速度不能够满足CPU运算的速度。一般除了工程样版的Intel的CPU都是锁了倍频的，而AMD之前都没有锁
6.缓存
缓存大小也是CPU的重要指标之一，而且缓存的结构和大小对CPU速度的影响非常大，CPU内缓存的运行频率极高，一般是和处理器同频运作，工作效率远远大于系统内存和硬盘。实际工作时，CPU往往需要重复读取同样的数据块，而缓存容量的增大，可以大幅度提升CPU内部读取数据的命中率，而不用再到内存或者硬盘上寻找，以此提高系统性能。但是由于CPU芯片面积和成本的因素来考虑，缓存都很小。
L1 Cache(一级缓存)是CPU第一层高速缓存，分为数据缓存和指令缓存。内置的L1高速缓存的容量和结构对CPU的性能影响较大，不过高速缓冲存储器均由静态RAM组成，结构较复杂，在CPU管芯面积不能太大的情况下，L1级高速缓存的容量不可能做得太大。一般服务器CPU的L1缓存的容量通常在32?256KB。
L2 Cache(二级缓存)是CPU的第二层高速缓存，分内部和外部两种芯片。内部的芯片二级缓存运行速度与主频相同，而外部的二级缓存则只有主频的一半。L2高速缓存容量也会影响CPU的性能，原则是越大越好，现在家庭用CPU容量最大的是512KB，而服务器和工作站上用CPU的L2高速缓存更高达256-1MB，有的高达2MB或者3MB。
L3 Cache(三级缓存)，分为两种，早期的是外置，现在的都是内置的。而它的实际作用即是，L3缓存的应用可以进一步降低内存延迟，同时提升大数据量计算时处理器的性能。降低内存延迟和提升大数据量计算能力对游戏都很有帮助。而在服务器领域增加L3缓存在性能方面仍然有显著的提升。比方具有较大L3缓存的配置利用物理内存会更有效，故它比较慢的磁盘I/O子系统可以处理更多的数据请求。具有较大L3缓存的处理器提供更有效的文件系统缓存行为及较短消息和处理器队列长度。
其实最早的L3缓存被应用在AMD发布的K6-III处理器上，当时的L3缓存受限于制造工艺，并没有被集成进芯片内部，而是集成在主板上。在只能够和系统总线频率同步的L3缓存同主内存其实差不了多少。后来使用L3缓存的是英特尔为服务器市场所推出的Itanium处理器。接着就是P4EE和至强MP。Intel还打算推出一款9MB L3缓存的Itanium2处理器，和以后24MB L3缓存的双核心Itanium2处理器。
但基本上L3缓存对处理器的性能提高显得不是很重要，比方配备1MB L3缓存的Xeon MP处理器却仍然不是Opteron的对手，由此可见前端总线的增加，要比缓存增加带来更有效的性能提升。
7.CPU扩展指令集
CPU依靠指令来计算和控制系统，每款CPU在设计时就规定了一系列与其硬件电路相配合的指令系统。指令的强弱也是CPU的重要指标，指令集是提高微处理器效率的最有效工具之一。从现阶段的主流体系结构讲，指令集可分为复杂指令集和精简指令集两部分，而从具体运用看，如Intel的MMX（Multi Media Extended）、SSE、 SSE2（Streaming-Single instruction multiple data-Extensions 2）、SEE3和AMD的3DNow!等都是CPU的扩展指令集，分别增强了CPU的多媒体、图形图象和Internet等的处理能力。我们通常会把CPU的扩展指令集称为"CPU的指令集"。SSE3指令集也是目前规模最小的指令集，此前MMX包含有57条命令，SSE包含有50条命令，SSE2包含有144条命令，SSE3包含有13条命令。目前SSE3也是最先进的指令集，英特尔Prescott处理器已经支持SSE3指令集，AMD会在未来双核心处理器当中加入对SSE3指令集的支持，全美达的处理器也将支持这一指令集。
8.CPU内核和I/O工作电压
从586CPU开始，CPU的工作电压分为内核电压和I/O电压两种，通常CPU的核心电压小于等于I/O电压。其中内核电压的大小是根据CPU的生产工艺而定，一般制作工艺越小，内核工作电压越低；I/O电压一般都在1.6~5V。低电压能解决耗电过大和发热过高的问题。
9.制造工艺
制造工艺的微米是指IC内电路与电路之间的距离。制造工艺的趋势是向密集度愈高的方向发展。密度愈高的IC电路设计，意味着在同样大小面积的IC中，可以拥有密度更高、功能更复杂的电路设计。现在主要的180nm、130nm、90nm。最近官方已经表示有65nm的制造工艺了。
10.指令集
（1）CISC指令集
CISC指令集，也称为复杂指令集，英文名是CISC，（Complex Instruction Set Computer的缩写）。在CISC微处理器中，程序的各条指令是按顺序串行执行的，每条指令中的各个操作也是按顺序串行执行的。顺序执行的优点是控制简单，但计算机各部分的利用率不高，执行速度慢。其实它是英特尔生产的x86系列（也就是IA-32架构）CPU及其兼容CPU，如AMD、VIA的。即使是现在新起的X86-64（也被成AMD64）都是属于CISC的范畴。
要知道什么是指令集还要从当今的X86架构的CPU说起。X86指令集是Intel为其第一块16位CPU(i8086)专门开发的，IBM1981年推出的世界第一台PC机中的CPU?i8088(i8086简化版)使用的也是X86指令，同时电脑中为提高浮点数据处理能力而增加了X87芯片，以后就将X86指令集和X87指令集统称为X86指令集。
虽然随着CPU技术的不断发展，Intel陆续研制出更新型的i80386、i80486直到过去的PII至强、PIII至强、Pentium 3，最后到今天的Pentium 4系列、至强（不包括至强Nocona），但为了保证电脑能继续运行以往开发的各类应用程序以保护和继承丰富的软件资源，所以Intel公司所生产的所有CPU仍然继续使用X86指令集，所以它的CPU仍属于X86系列。由于Intel X86系列及其兼容CPU（如AMD Athlon MP、）都使用X86指令集，所以就形成了今天庞大的X86系列及兼容CPU阵容。x86CPU目前主要有intel的服务器CPU和AMD的服务器CPU两类。
（2）RISC指令集
RISC是英文“Reduced Instruction Set Computing ” 的缩写，中文意思是“精简指令集”。它是在CISC指令系统基础上发展起来的，有人对CISC机进行测试表明，各种指令的使用频度相当悬殊，最常使用的是一些比较简单的指令，它们仅占指令总数的20％，但在程序中出现的频度却占80％。复杂的指令系统必然增加微处理器的复杂性，使处理器的研制时间长，成本高。并且复杂指令需要复杂的操作，必然会降低计算机的速度。基于上述原因，20世纪80年代RISC型CPU诞生了，相对于CISC型CPU ,RISC型CPU不仅精简了指令系统，还采用了一种叫做“超标量和超流水线结构”，大大增加了并行处理能力。RISC指令集是高性能CPU的发展方向。它与传统的CISC(复杂指令集)相对。相比而言，RISC的指令格式统一，种类比较少，寻址方式也比复杂指令集少。当然处理速度就提高很多了。目前在中高档服务器中普遍采用这一指令系统的CPU，特别是高档服务器全都采用RISC指令系统的CPU。RISC指令系统更加适合高档服务器的操作系统UNIX，现在Linux也属于类似UNIX的操作系统。RISC型CPU与Intel和AMD的CPU在软件和硬件上都不兼容。
目前，在中高档服务器中采用RISC指令的CPU主要有以下几类：PowerPC处理器、SPARC处理器、PA-RISC处理器、MIPS处理器、Alpha处理器。
（3）IA-64
EPIC（Explicitly Parallel Instruction Computers，精确并行指令计算机）是否是RISC和CISC体系的继承者的争论已经有很多，单以EPIC体系来说，它更像Intel的处理器迈向RISC体系的重要步骤。从理论上说，EPIC体系设计的CPU，在相同的主机配置下，处理Windows的应用软件比基于Unix下的应用软件要好得多。
Intel采用EPIC技术的服务器CPU是安腾Itanium（开发代号即Merced）。它是64位处理器，也是IA－64系列中的第一款。微软也已开发了代号为Win64的操作系统，在软件上加以支持。在Intel采用了X86指令集之后，它又转而寻求更先进的64-bit微处理器，Intel这样做的原因是，它们想摆脱容量巨大的x86架构,从而引入精力充沛而又功能强大的指令集，于是采用EPIC指令集的IA-64架构便诞生了。IA-64 在很多方面来说，都比x86有了长足的进步。突破了传统IA32架构的许多限制，在数据的处理能力，系统的稳定性、安全性、可用性、可观理性等方面获得了突破性的提高。
IA-64微处理器最大的缺陷是它们缺乏与x86的兼容，而Intel为了IA-64处理器能够更好地运行两个朝代的软件，它在IA-64处理器上（Itanium、Itanium2 ……)引入了x86-to-IA-64的解码器，这样就能够把x86指令翻译为IA-64指令。这个解码器并不是最有效率的解码器，也不是运行x86代码的最好途径（最好的途径是直接在x86处理器上运行x86代码），因此Itanium 和Itanium2在运行x86应用程序时候的性能非常糟糕。这也成为X86-64产生的根本原因。
（4）X86-64 （AMD64 / EM64T）
AMD公司设计，可以在同一时间内处理64位的整数运算，并兼容于X86-32架构。其中支持64位逻辑定址，同时提供转换为32位定址选项；但数据操作指令默认为32位和8位，提供转换成64位和16位的选项；支持常规用途寄存器，如果是32位运算操作，就要将结果扩展成完整的64位。这样，指令中有“直接执行”和“转换执行”的区别，其指令字段是8位或32位，可以避免字段过长。
x86-64（也叫AMD64）的产生也并非空穴来风，x86处理器的32bit寻址空间限制在4GB内存，而IA-64的处理器又不能兼容x86。AMD充分考虑顾客的需求，加强x86指令集的功能，使这套指令集可同时支持64位的运算模式，因此AMD把它们的结构称之为x86-64。在技术上AMD在x86-64架构中为了进行64位运算，AMD为其引入了新增了R8-R15通用寄存器作为原有X86处理器寄存器的扩充，但在而在32位环境下并不完全使用到这些寄存器。原来的寄存器诸如EAX、EBX也由32位扩张至64位。在SSE单元中新加入了8个新寄存器以提供对SSE2的支持。寄存器数量的增加将带来性能的提升。与此同时，为了同时支持32和64位代码及寄存器，x86-64架构允许处理器工作在以下两种模式：Long Mode(长模式)和Legacy Mode(遗传模式)，Long模式又分为两种子模式(64bit模式和Compatibility mode兼容模式)。该标准已经被引进在AMD服务器处理器中的Opteron处理器。
而今年也推出了支持64位的EM64T技术，再还没被正式命为EM64T之前是IA32E，这是英特尔64位扩展技术的名字,用来区别X86指令集。Intel的EM64T支持64位sub-mode，和AMD的X86-64技术类似，采用64位的线性平面寻址，加入8个新的通用寄存器（GPRs），还增加8个寄存器支持SSE指令。与AMD相类似，Intel的64位技术将兼容IA32和IA32E，只有在运行64位操作系统下的时候，才将会采用IA32E。IA32E将由2个sub-mode组成：64位sub-mode和32位sub-mode，同AMD64一样是向下兼容的。Intel的EM64T将完全兼容AMD的X86-64技术。现在Nocona处理器已经加入了一些64位技术，Intel的Pentium 4E处理器也支持64位技术。
应该说，这两者都是兼容x86指令集的64位微处理器架构，但EM64T与AMD64还是有一些不一样的地方，AMD64处理器中的NX位在Intel的处理器中将没有提供。
11.超流水线与超标量
在解释超流水线与超标量前，先了解流水线(pipeline)。流水线是Intel首次在486芯片中开始使用的。流水线的工作方式就象工业生产上的装配流水线。在CPU中由5?6个不同功能的电路单元组成一条指令处理流水线，然后将一条X86指令分成5?6步后再由这些电路单元分别执行，这样就能实现在一个CPU时钟周期完成一条指令，因此提高CPU的运算速度。经典奔腾每条整数流水线都分为四级流水，即指令预取、译码、执行、写回结果，浮点流水又分为八级流水。
超标量是通过内置多条流水线来同时执行多个处理器，其实质是以空间换取时间。而超流水线是通过细化流水、提高主频，使得在一个机器周期内完成一个甚至多个操作，其实质是以时间换取空间。例如Pentium 4的流水线就长达20级。将流水线设计的步(级)越长，其完成一条指令的速度越快，因此才能适应工作主频更高的CPU。但是流水线过长也带来了一定副作用，很可能会出现主频较高的CPU实际运算速度较低的现象，Intel的奔腾4就出现了这种情况，虽然它的主频可以高达1.4G以上，但其运算性能却远远比不上AMD 1.2G的速龙甚至奔腾III。
12.封装形式
CPU封装是采用特定的材料将CPU芯片或CPU模块固化在其中以防损坏的保护措施，一般必须在封装后CPU才能交付用户使用。CPU的封装方式取决于CPU安装形式和器件集成设计，从大的分类来看通常采用Socket插座进行安装的CPU使用PGA(栅格阵列)方式封装，而采用Slot x槽安装的CPU则全部采用SEC(单边接插盒)的形式封装。现在还有PLGA(Plastic Land Grid Array)、OLGA(Organic Land Grid Array)等封装技术。由于市场竞争日益激烈，目前CPU封装技术的发展方向以节约成本为主。
13、多线程
同时多线程Simultaneous multithreading，简称SMT。SMT可通过复制处理器上的结构状态，让同一个处理器上的多个线程同步执行并共享处理器的执行资源，可最大限度地实现宽发射、乱序的超标量处理，提高处理器运算部件的利用率，缓和由于数据相关或Cache未命中带来的访问内存延时。当没有多个线程可用时，SMT处理器几乎和传统的宽发射超标量处理器一样。SMT最具吸引力的是只需小规模改变处理器核心的设计，几乎不用增加额外的成本就可以显著地提升效能。多线程技术则可以为高速的运算核心准备更多的待处理数据，减少运算核心的闲置时间。这对于桌面低端系统来说无疑十分具有吸引力。Intel从3.06GHz Pentium 4开始，所有处理器都将支持SMT技术。
14、多核心
多核心，也指单芯片多处理器（Chip multiprocessors，简称CMP）。CMP是由美国斯坦福大学提出的，其思想是将大规模并行处理器中的SMP（对称多处理器）集成到同一芯片内，各个处理器并行执行不同的进程。与CMP比较， SMT处理器结构的灵活性比较突出。但是，当半导体工艺进入0.18微米以后，线延时已经超过了门延迟，要求微处理器的设计通过划分许多规模更小、局部性更好的基本单元结构来进行。相比之下，由于CMP结构已经被划分成多个处理器核来设计，每个核都比较简单，有利于优化设计，因此更有发展前途。目前，IBM 的Power 4芯片和Sun的 MAJC5200芯片都采用了CMP结构。多核处理器可以在处理器内部共享缓存，提高缓存利用率，同时简化多处理器系统设计的复杂度。
2005年下半年，Intel和AMD的新型处理器也将融入CMP结构。新安腾处理器开发代码为Montecito，采用双核心设计，拥有最少18MB片内缓存，采取90nm工艺制造，它的设计绝对称得上是对当今芯片业的挑战。它的每个单独的核心都拥有独立的L1，L2和L3 cache，包含大约10亿支晶体管。
15、SMP
SMP（Symmetric Multi-Processing），对称多处理结构的简称，是指在一个计算机上汇集了一组处理器(多CPU),各CPU之间共享内存子系统以及总线结构。在这种技术的支持下，一个服务器系统可以同时运行多个处理器，并共享内存和其他的主机资源。像双至强，也就是我们所说的二路，这是在对称处理器系统中最常见的一种（至强MP可以支持到四路，AMD Opteron可以支持1-8路）。也有少数是16路的。但是一般来讲，SMP结构的机器可扩展性较差，很难做到100个以上多处理器，常规的一般是8个到16个，不过这对于多数的用户来说已经够用了。在高性能服务器和工作站级主板架构中最为常见，像UNIX服务器可支持最多256个CPU的系统。
构建一套SMP系统的必要条件是：支持SMP的硬件包括主板和CPU；支持SMP的系统平台，再就是支持SMP的应用软件。
为了能够使得SMP系统发挥高效的性能，操作系统必须支持SMP系统，如WINNT、LINUX、以及UNIX等等32位操作系统。即能够进行多任务和多线程处理。多任务是指操作系统能够在同一时间让不同的CPU完成不同的任务；多线程是指操作系统能够使得不同的CPU并行的完成同一个任务。
要组建SMP系统，对所选的CPU有很高的要求，首先、CPU内部必须内置APIC（Advanced Programmable Interrupt Controllers）单元。Intel 多处理规范的核心就是高级可编程中断控制器（Advanced Programmable Interrupt Controllers--APICs）的使用；再次，相同的产品型号，同样类型的CPU核心，完全相同的运行频率；最后，尽可能保持相同的产品序列编号，因为两个生产批次的CPU作为双处理器运行的时候，有可能会发生一颗CPU负担过高，而另一颗负担很少的情况，无法发挥最大性能，更糟糕的是可能导致死机。
16、NUMA技术
NUMA即非一致访问分布共享存储技术，它是由若干通过高速专用网络连接起来的独立节点构成的系统，各个节点可以是单个的CPU或是SMP系统。在NUMA中，Cache 的一致性有多种解决方案，需要操作系统和特殊软件的支持。图2中是Sequent公司NUMA系统的例子。这里有3个SMP模块用高速专用网络联起来，组成一个节点，每个节点可以有12个CPU。像Sequent的系统最多可以达到64个CPU甚至256个CPU。显然，这是在SMP的基础上，再用NUMA的技术加以扩展，是这两种技术的结合。
17、乱序执行技术
乱序执行（out-of-orderexecution），是指CPU允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理的技术。这样将根据个电路单元的状态和各指令能否提前执行的具体情况分析后，将能提前执行的指令立即发送给相应电路单元执行，在这期间不按规定顺序执行指令，然后由重新排列单元将各执行单元结果按指令顺序重新排列。采用乱序执行技术的目的是为了使CPU内部电路满负荷运转并相应提高了CPU的运行程序的速度。分枝技术：（branch）指令进行运算时需要等待结果，一般无条件分枝只需要按指令顺序执行，而条件分枝必须根据处理后的结果，再决定是否按原先顺序进行。
18、CPU内部的内存控制器
许多应用程序拥有更为复杂的读取模式（几乎是随机地，特别是当cache hit不可预测的时候），并且没有有效地利用带宽。典型的这类应用程序就是业务处理软件，即使拥有如乱序执行（out of order execution）这样的CPU特性，也会受内存延迟的限制。这样CPU必须得等到运算所需数据被除数装载完成才能执行指令（无论这些数据来自CPU cache还是主内存系统）。当前低段系统的内存延迟大约是120－150ns，而CPU速度则达到了3GHz以上，一次单独的内存请求可能会浪费200－300次CPU循环。即使在缓存命中率（cache hit rate）达到99％的情况下，CPU也可能会花50％的时间来等待内存请求的结束－ 比如因为内存延迟的缘故。
你可以看到Opteron整合的内存控制器，它的延迟，与芯片组支持双通道DDR内存控制器的延迟相比来说，是要低很多的。英特尔也按照计划的那样在处理器内部整合内存控制器，这样导致北桥芯片将变得不那么重要。但改变了处理器访问主存的方式，有助于提高带宽、降低内存延时和提升处理器性能。
http://download.chinaunix.net/download.php?id=14464&ResourceID=7159
