工作时间久了，对于知识经验的归类很管理的需求就很迫切。这东西说容易也容易，拿个本子一记就行，说难也难，如何快速的找出三年前的解决方案？
以前一直是拿个本子记得，厚厚的一本，记了有三大本，不过问题就是查询不是很方便，虽然也贴了标签，但是标签一多还是分不出来。有些经验技巧什么的记录在文件里，公司推荐在网上wiki page，好处是别人也能参考，坏处是写给自己明白，但要让别人也明白不容易。而且英文毕竟没有中文熟悉，页面一多，记不住地址还是白搭。去年开始把这个方式拓展到工作日记的形式，即把自己每天干的事儿都记录下来，几个月下来，不看不知道，一看吓一跳：原来自己每天其实没干什么事情，一个问题能改好几天。而且有个现象是问题没解决的时候记得多，一旦找到解决方案了，忙check in代码，忙着写信，就懒得再写些什么了，导致日记中记得都是问题，少有答案。
而且这样还有个问题就是一个文件同步比较麻烦，需要考来考去的。后来从其他Toastmasters俱乐部那里学到了用Google Doc，只要开个文件，就可以同时从家里和在公司进行更新。不足之处是需要有网络，而且从国内访问需要翻墙。
由此再进一步，就是Evernote。这个是专门为知识管理准备的工具，可以支持文档图片网页等多种格式，在ipad和手机上也有相应的客户端。其同步功能比较强大，如果没有网络的话可以先在本地添加，等到了有网的地方再进行同步。其不足之处我觉得是格式比较封闭，对免费用户有流量限制，不过不失为一个好工具。国内也有类似的软件，比如麦库。
博客本身也是一个很好的回顾整理工具。
以上所说都是外物，真正对知识的掌握还要依赖对知识的不断探索与回顾。
2012年3月20日星期二
2010年6月17日星期四
《Manage It!项目管理修炼之道》读书笔记
软件项目永恒的敌人就是不能按期交付，项目经理的任务在掌握有限资源的情况下，不断地同它做斗争。这需要注意多个方面：
首先最重要的是确定方向，同时要细化最终的完成目标，即可交付物是什么。讨论项目的关键驱动因素、约束和浮动因素，列出项目的优先级。这可以在两难的时候帮助取舍，要让你的上级和投资人都进入到这个环节中，这有助于将来抵制出资人过多的功能变更需求等外部压力。其中的难点在于预测未来，识别真正的驱动因素。之后制定项目章程模板，主要包括远景、需求、目标、成功标准、ROI（投资回报率）估算。
然后细化其中的每项，配备人员，制定发布条件以及项目风险列表。
从项目本身来说，新Bug的发现与修正是早成延期的主要原因，所以要采用先进的生命周期组织方式来管理项目，安排好日程，尽量预测未来风险，同时让项目组内的每个人都意识到这一点。反馈及时，迅速发现错误并修正。将错误留到最后会消耗比当初多几倍的经历成本。
安排项目日程也很有学问，原则是注重实效、简单。使用低技术含量的工具安排项目日程，比如贴纸、白板等。识别和避免日程安排游戏，主要就是自欺欺人，盲目乐观可以在某个时间点完成。
估算工作的一个技巧就是使用“小石子”，即把项目分成一个一个可以在一两天之内完成的小单元，单元内部应该不可再分，只有“完成”和“未完成”两种状态。
要掌控项目，及时回顾。保持项目节奏，持续集成。重点强调，减少技术债务。创建并使用项目仪表板，量化指标。尽量不要在同一时间管理多个项目，项目结束时无论成功与否都要进行总结。
会议不可避免，管理会议，需要举行的和不需要举行的。每次会议都能达到目的，不要浪费整个组的时间。
人的因素是另外一个主要因素：创建出色的项目团队，招募需要的人，形成团队凝聚力。知道如何应对人。
首先最重要的是确定方向，同时要细化最终的完成目标，即可交付物是什么。讨论项目的关键驱动因素、约束和浮动因素，列出项目的优先级。这可以在两难的时候帮助取舍，要让你的上级和投资人都进入到这个环节中，这有助于将来抵制出资人过多的功能变更需求等外部压力。其中的难点在于预测未来，识别真正的驱动因素。之后制定项目章程模板，主要包括远景、需求、目标、成功标准、ROI（投资回报率）估算。
然后细化其中的每项，配备人员，制定发布条件以及项目风险列表。
从项目本身来说，新Bug的发现与修正是早成延期的主要原因，所以要采用先进的生命周期组织方式来管理项目，安排好日程，尽量预测未来风险，同时让项目组内的每个人都意识到这一点。反馈及时，迅速发现错误并修正。将错误留到最后会消耗比当初多几倍的经历成本。
安排项目日程也很有学问，原则是注重实效、简单。使用低技术含量的工具安排项目日程，比如贴纸、白板等。识别和避免日程安排游戏，主要就是自欺欺人，盲目乐观可以在某个时间点完成。
估算工作的一个技巧就是使用“小石子”，即把项目分成一个一个可以在一两天之内完成的小单元，单元内部应该不可再分，只有“完成”和“未完成”两种状态。
要掌控项目，及时回顾。保持项目节奏，持续集成。重点强调，减少技术债务。创建并使用项目仪表板，量化指标。尽量不要在同一时间管理多个项目，项目结束时无论成功与否都要进行总结。
会议不可避免，管理会议，需要举行的和不需要举行的。每次会议都能达到目的，不要浪费整个组的时间。
人的因素是另外一个主要因素：创建出色的项目团队，招募需要的人，形成团队凝聚力。知道如何应对人。
2010年5月11日星期二
即兴演讲技巧笔记（Impromptu Speech）
TQA原则：Think（想），Question（提问），Act（展现）
思路：横向、纵向、对象感
方法：抽取、组合、替换
常用技巧：
机智架桥: 未知到已知;陌生到熟悉;事物连接，唤起同类记忆;联想
巧妙转换：转换论述的层面;点明要害;揭示意义;启发思考
收敛聚焦：UA（Unified analysis）
开门见山：先答案，后论证
缺点：例子只能证明观点，而非观点的替代品
思路：横向、纵向、对象感
方法：抽取、组合、替换
常用技巧：
机智架桥: 未知到已知;陌生到熟悉;事物连接，唤起同类记忆;联想
巧妙转换：转换论述的层面;点明要害;揭示意义;启发思考
收敛聚焦：UA（Unified analysis）
开门见山：先答案，后论证
缺点：例子只能证明观点，而非观点的替代品
2010年2月26日星期五
如何得到短网址（Shorten URLs）
之前提过，在上Twitter的时候因为每条信息不能超过140个字符，所以经常看到许多短网址，一开始不知道是怎么做出来的，后来发现其实很简单，不需要申请用户名或者下载客户端。
主要功能是将较长的URL地址缩短为更少字符组成的链接，使共享、发邮件给朋友更容易。好处有：
稳定 – 确保该服务具有很好的正常运行时间
安全 – 保护用户免受恶意软件和网络仿冒的攻击或骚扰的页面
速度 – 快速的短URL解析
常用的缩写网站是直接登陆，然后输入你的网址，点生成，就会得到新的短网址。这类网站很多，谁能够收集所有缩写链接的最统一标准意见，谁就是最后的胜者。
http://bit.ly/
http://to.ly/
http://ow.ly/
http://tinyurl.com/create.php
Google的网址缩写服务叫goo.gl，但仅被用于Google工具栏和Feedburner，不能直接访问。所以不如上面的好用。
主要功能是将较长的URL地址缩短为更少字符组成的链接，使共享、发邮件给朋友更容易。好处有：
稳定 – 确保该服务具有很好的正常运行时间
安全 – 保护用户免受恶意软件和网络仿冒的攻击或骚扰的页面
速度 – 快速的短URL解析
常用的缩写网站是直接登陆，然后输入你的网址，点生成，就会得到新的短网址。这类网站很多，谁能够收集所有缩写链接的最统一标准意见，谁就是最后的胜者。
http://bit.ly/
http://to.ly/
http://ow.ly/
http://tinyurl.com/create.php
Google的网址缩写服务叫goo.gl，但仅被用于Google工具栏和Feedburner，不能直接访问。所以不如上面的好用。
2008年11月20日星期四
Linux下的C编程实战――驱动程序设计（zz）
1.引言
设备驱动程序是操作系统内核和机器硬件之间的接口，它为应用程序屏蔽硬件的细节，一般来说，Linux的设备驱动程序需要完成如下功能：
（1）初始化设备；
（2）提供各类设备服务；
（3）负责内核和设备之间的数据交换；
（4）检测和处理设备工作过程中出现的错误。
妙不可言的是，Linux下的设备驱动程序被组织为一组完成不同任务的函数的集合，通过这些函数使得Windows的设备操作犹如文件一般。在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。本系列文章的第2章文件系统编程中已经看到了这些函数的真面目，它们就是open ()、close ()、read ()、write () 等。
Linux主要将设备分为二类：字符设备和块设备（当然网络设备及USB等其它设备的驱动编写方法又稍有不同）。这两类设备的不同点在于：在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，而块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备主要针对磁盘等慢速设备。以字符设备的驱动较为简单，因此本章主要阐述字符设备的驱动编写。
2.驱动模块函数
init 函数用来完成对所控设备的初始化工作，并调用register_chrdev() 函数注册字符设备。假设有一字符设备“exampledev”，则其init函数为：
其中，register_chrdev函数中的参数MAJOR_NUM为主设备号,“exampledev”为设备名，exampledev_fops为包含基本函数入口点的结构体，类型为file_operations。当执行exampledev_init时，它将调用内核函数register_chrdev，把驱动程序的基本入口点指针存放在内核的字符设备地址表中，在用户进程对该设备执行系统调用时提供入口地址。
file_operations结构体定义为：
struct file_operations
{
int (*lseek)();
int (*read)();
int (*write)();
int (*readdir)();
int (*select)();
int (*ioctl)();
int (*mmap)();
int (*open)();
void(*release)();
int (*fsync)();
int (*fasync)();
int (*check_media_change)();
void(*revalidate)();
};
大多数的驱动程序只是利用了其中的一部分，对于驱动程序中无需提供的功能，只需要把相应位置的值设为NULL。对于字符设备来说，要提供的主要入口有：open ()、release ()、read ()、write ()、ioctl ()。
open()函数 对设备特殊文件进行open()系统调用时，将调用驱动程序的open () 函数：
int open(struct inode * inode ,struct file * file);
其中参数inode为设备特殊文件的inode (索引结点) 结构的指针，参数file是指向这一设备的文件结构的指针。open()的主要任务是确定硬件处在就绪状态、验证次设备号的合法性(次设备号可以用MINOR(inode-> i - rdev) 取得)、控制使用设备的进程数、根据执行情况返回状态码(0表示成功，负数表示存在错误) 等；
release()函数 当最后一个打开设备的用户进程执行close ()系统调用时，内核将调用驱动程序的release () 函数：
void release (struct inode * inode ,struct file * file) ;
release 函数的主要任务是清理未结束的输入/输出操作、释放资源、用户自定义排他标志的复位等。
read()函数 当对设备特殊文件进行read() 系统调用时，将调用驱动程序read() 函数：
void read(struct inode * inode ,struct file * file ,char * buf ,int count) ;
参数buf是指向用户空间缓冲区的指针，由用户进程给出，count 为用户进程要求读取的字节数，也由用户给出。
read() 函数的功能就是从硬设备或内核内存中读取或复制count个字节到buf 指定的缓冲区中。在复制数据时要注意，驱动程序运行在内核中，而buf指定的缓冲区在用户内存区中，是不能直接在内核中访问使用的，因此，必须使用特殊的复制函数来完成复制工作，这些函数在中定义：
void put_user_byte (char data_byte ,char * u_addr) ;
void put_user_word (short data_word ,short * u_addr) ;
void put_user_long(long data_long ,long * u_addr) ;
void memcpy_tofs (void * u_addr ,void * k_addr ,unsigned long cnt) ;
参数u_addr为用户空间地址，k_addr 为内核空间地址，cnt为字节数。
write( ) 函数 当设备特殊文件进行write () 系统调用时，将调用驱动程序的write () 函数：
void write (struct inode * inode ,struct file * file ,char * buf ,int count) ;
write ()的功能是将参数buf 指定的缓冲区中的count 个字节内容复制到硬件或内核内存中，和read() 一样，复制工作也需要由特殊函数来完成：
unsigned char_get_user_byte (char * u_addr) ;
unsigned char_get_user_word (short * u_addr) ;
unsigned char_get_user_long(long * u_addr) ;
unsigned memcpy_fromfs(void * k_addr ,void * u_addr ,unsigned long cnt) ;
ioctl() 函数 该函数是特殊的控制函数，可以通过它向设备传递控制信息或从设备取得状态信息，函数原型为：
int ioctl (struct inode * inode ,struct file * file ,unsigned int cmd ,unsigned long arg);
参数cmd为设备驱动程序要执行的命令的代码，由用户自定义，参数arg 为相应的命令提供参数，类型可以是整型、指针等。
同样，在驱动程序中，这些函数的定义也必须符合命名规则，按照本文约定，设备“exampledev”的驱动程序的这些函数应分别命名为
exampledev_open、exampledev_ release、exampledev_read、exampledev_write、exampledev_ioctl，因此设备“exampledev”的基本入口点
结构变量exampledev_fops 赋值如下：
struct file_operations exampledev_fops {
NULL ,
exampledev_read ,
exampledev_write ,
NULL ,
NULL ,
exampledev_ioctl ,
NULL ,
exampledev_open ,
exampledev_release ,
NULL ,
NULL ,
NULL ,
NULL
} ;
3.内存分配
由于Linux驱动程序在内核中运行，因此在设备驱动程序需要申请/释放内存时，不能使用用户级的malloc/free函数，而需由内核级的函数kmalloc/kfree () 来实现，kmalloc()函数的原型为：
void kmalloc (size_t size ,int priority);
参数size为申请分配内存的字节数；参数priority说明若kmalloc()不能马上分配内存时用户进程要采用的动作：GFP_KERNEL 表示等待，即等kmalloc()函数将一些内存安排到交换区来满足你的内存需要，GFP_ATOMIC 表示不等待，如不能立即分配到内存则返回0 值；函数的返回值指向已分配内存的起始地址，出错时，返回0。
kmalloc ()分配的内存需用kfree()函数来释放，kfree ()被定义为：
# define kfree (n) kfree_s( (n) ,0)
其中kfree_s () 函数原型为：
void kfree_s (void * ptr ,int size);
参数ptr为kmalloc()返回的已分配内存的指针，size是要释放内存的字节数，若为0 时，由内核自动确定内存的大小。
4.中断
许多设备涉及到中断操作，因此，在这样的设备的驱动程序中需要对硬件产生的中断请求提供中断服务程序。与注册基本入口点一样，驱动程序也要请求内核将特定的中断请求和中断服务程序联系在一起。在Linux中，用request_irq()函数来实现请求：
int request_irq (unsigned int irq ,void( * handler) int ,unsigned long type ,char * name);
参数irq为要中断请求号，参数handler为指向中断服务程序的指针，参数type 用来确定是正常中断还是快速中断（正常中断指中断服务子程序返回后，内核可以执行调度程序来确定将运行哪一个进程；而快速中断是指中断服务子程序返回后，立即执行被中断程序，正常中断type 取值为0 ，快速中断type 取值为SA_INTERRUPT），参数name是设备驱动程序的名称。
梦想与现实的落差，就是我们离成功的距离~
设备驱动程序是操作系统内核和机器硬件之间的接口，它为应用程序屏蔽硬件的细节，一般来说，Linux的设备驱动程序需要完成如下功能：
（1）初始化设备；
（2）提供各类设备服务；
（3）负责内核和设备之间的数据交换；
（4）检测和处理设备工作过程中出现的错误。
妙不可言的是，Linux下的设备驱动程序被组织为一组完成不同任务的函数的集合，通过这些函数使得Windows的设备操作犹如文件一般。在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。本系列文章的第2章文件系统编程中已经看到了这些函数的真面目，它们就是open ()、close ()、read ()、write () 等。
Linux主要将设备分为二类：字符设备和块设备（当然网络设备及USB等其它设备的驱动编写方法又稍有不同）。这两类设备的不同点在于：在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，而块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备主要针对磁盘等慢速设备。以字符设备的驱动较为简单，因此本章主要阐述字符设备的驱动编写。
2.驱动模块函数
init 函数用来完成对所控设备的初始化工作，并调用register_chrdev() 函数注册字符设备。假设有一字符设备“exampledev”，则其init函数为：
void exampledev_init(void)
{
if (register_chrdev(MAJOR_NUM, " exampledev ", &exampledev_fops))
TRACE_TXT("Device exampledev driver registered error");
else
TRACE_TXT("Device exampledev driver registered successfully");
…//设备初始化
}
其中，register_chrdev函数中的参数MAJOR_NUM为主设备号,“exampledev”为设备名，exampledev_fops为包含基本函数入口点的结构体，类型为file_operations。当执行exampledev_init时，它将调用内核函数register_chrdev，把驱动程序的基本入口点指针存放在内核的字符设备地址表中，在用户进程对该设备执行系统调用时提供入口地址。
file_operations结构体定义为：
struct file_operations
{
int (*lseek)();
int (*read)();
int (*write)();
int (*readdir)();
int (*select)();
int (*ioctl)();
int (*mmap)();
int (*open)();
void(*release)();
int (*fsync)();
int (*fasync)();
int (*check_media_change)();
void(*revalidate)();
};
大多数的驱动程序只是利用了其中的一部分，对于驱动程序中无需提供的功能，只需要把相应位置的值设为NULL。对于字符设备来说，要提供的主要入口有：open ()、release ()、read ()、write ()、ioctl ()。
open()函数 对设备特殊文件进行open()系统调用时，将调用驱动程序的open () 函数：
int open(struct inode * inode ,struct file * file);
其中参数inode为设备特殊文件的inode (索引结点) 结构的指针，参数file是指向这一设备的文件结构的指针。open()的主要任务是确定硬件处在就绪状态、验证次设备号的合法性(次设备号可以用MINOR(inode-> i - rdev) 取得)、控制使用设备的进程数、根据执行情况返回状态码(0表示成功，负数表示存在错误) 等；
release()函数 当最后一个打开设备的用户进程执行close ()系统调用时，内核将调用驱动程序的release () 函数：
void release (struct inode * inode ,struct file * file) ;
release 函数的主要任务是清理未结束的输入/输出操作、释放资源、用户自定义排他标志的复位等。
read()函数 当对设备特殊文件进行read() 系统调用时，将调用驱动程序read() 函数：
void read(struct inode * inode ,struct file * file ,char * buf ,int count) ;
参数buf是指向用户空间缓冲区的指针，由用户进程给出，count 为用户进程要求读取的字节数，也由用户给出。
read() 函数的功能就是从硬设备或内核内存中读取或复制count个字节到buf 指定的缓冲区中。在复制数据时要注意，驱动程序运行在内核中，而buf指定的缓冲区在用户内存区中，是不能直接在内核中访问使用的，因此，必须使用特殊的复制函数来完成复制工作，这些函数在
void put_user_byte (char data_byte ,char * u_addr) ;
void put_user_word (short data_word ,short * u_addr) ;
void put_user_long(long data_long ,long * u_addr) ;
void memcpy_tofs (void * u_addr ,void * k_addr ,unsigned long cnt) ;
参数u_addr为用户空间地址，k_addr 为内核空间地址，cnt为字节数。
write( ) 函数 当设备特殊文件进行write () 系统调用时，将调用驱动程序的write () 函数：
void write (struct inode * inode ,struct file * file ,char * buf ,int count) ;
write ()的功能是将参数buf 指定的缓冲区中的count 个字节内容复制到硬件或内核内存中，和read() 一样，复制工作也需要由特殊函数来完成：
unsigned char_get_user_byte (char * u_addr) ;
unsigned char_get_user_word (short * u_addr) ;
unsigned char_get_user_long(long * u_addr) ;
unsigned memcpy_fromfs(void * k_addr ,void * u_addr ,unsigned long cnt) ;
ioctl() 函数 该函数是特殊的控制函数，可以通过它向设备传递控制信息或从设备取得状态信息，函数原型为：
int ioctl (struct inode * inode ,struct file * file ,unsigned int cmd ,unsigned long arg);
参数cmd为设备驱动程序要执行的命令的代码，由用户自定义，参数arg 为相应的命令提供参数，类型可以是整型、指针等。
同样，在驱动程序中，这些函数的定义也必须符合命名规则，按照本文约定，设备“exampledev”的驱动程序的这些函数应分别命名为
exampledev_open、exampledev_ release、exampledev_read、exampledev_write、exampledev_ioctl，因此设备“exampledev”的基本入口点
结构变量exampledev_fops 赋值如下：
struct file_operations exampledev_fops {
NULL ,
exampledev_read ,
exampledev_write ,
NULL ,
NULL ,
exampledev_ioctl ,
NULL ,
exampledev_open ,
exampledev_release ,
NULL ,
NULL ,
NULL ,
NULL
} ;
3.内存分配
由于Linux驱动程序在内核中运行，因此在设备驱动程序需要申请/释放内存时，不能使用用户级的malloc/free函数，而需由内核级的函数kmalloc/kfree () 来实现，kmalloc()函数的原型为：
void kmalloc (size_t size ,int priority);
参数size为申请分配内存的字节数；参数priority说明若kmalloc()不能马上分配内存时用户进程要采用的动作：GFP_KERNEL 表示等待，即等kmalloc()函数将一些内存安排到交换区来满足你的内存需要，GFP_ATOMIC 表示不等待，如不能立即分配到内存则返回0 值；函数的返回值指向已分配内存的起始地址，出错时，返回0。
kmalloc ()分配的内存需用kfree()函数来释放，kfree ()被定义为：
# define kfree (n) kfree_s( (n) ,0)
其中kfree_s () 函数原型为：
void kfree_s (void * ptr ,int size);
参数ptr为kmalloc()返回的已分配内存的指针，size是要释放内存的字节数，若为0 时，由内核自动确定内存的大小。
4.中断
许多设备涉及到中断操作，因此，在这样的设备的驱动程序中需要对硬件产生的中断请求提供中断服务程序。与注册基本入口点一样，驱动程序也要请求内核将特定的中断请求和中断服务程序联系在一起。在Linux中，用request_irq()函数来实现请求：
int request_irq (unsigned int irq ,void( * handler) int ,unsigned long type ,char * name);
参数irq为要中断请求号，参数handler为指向中断服务程序的指针，参数type 用来确定是正常中断还是快速中断（正常中断指中断服务子程序返回后，内核可以执行调度程序来确定将运行哪一个进程；而快速中断是指中断服务子程序返回后，立即执行被中断程序，正常中断type 取值为0 ，快速中断type 取值为SA_INTERRUPT），参数name是设备驱动程序的名称。
梦想与现实的落差，就是我们离成功的距离~
Linux下的C编程实战――“线程”控制与“线程”通信编程（zz）
1.Linux“线程”
笔者曾经在《基于嵌入式操作系统VxWorks的多任务并发程序设计》（《软件报》2006年第5~12期）中详细叙述了进程和线程的区别，并曾经说明Linux是一种“多进程单线程”的操作系统。Linux本身只有进程的概念，而其所谓的“线程”本质上在内核里仍然是进程。大家知道，进程是资源分配的单位，同一进程中的多个线程共享该进程的资源（如作为共享内存的全局变量）。Linux中所谓的“线程”只是在被创建的时候“克隆”(clone)了父进程的资源，因此，clone出来的进程表现为“线程”，这一点一定要弄清楚。因此，Linux“线程”这个概念只有在打冒号的情况下才是最准确的，可惜的是几乎没有书籍留心去强调这一点。
Linux内核只提供了轻量进程的支持，未实现线程模型，但Linux尽最大努力优化了进程的调度开销，这在一定程度上弥补无线程的缺陷。Linux用一个核心进程（轻量进程）对应一个线程，将线程调度等同于进程调度，交给核心完成。目前Linux中最流行的线程机制为LinuxThreads，所采用的就是线程－进程“一对一”模型，调度交给核心，而在用户级实现一个包括信号处理在内的线程管理机制。LinuxThreads由Xavier Leroy (Xavier.Leroy@inria.fr)负责开发完成，并已绑定在GLIBC中发行，它实现了一种BiCapitalized面向Linux的Posix 1003.1c “pthread”标准接口。Linuxthread可以支持Intel、Alpha、MIPS等平台上的多处理器系统。按照POSIX 1003.1c 标准编写的程序与Linuxthread 库相链接即可支持Linux平台上的多线程，在程序中需包含头文件pthread. h，在编译链接时使用命令：
gcc -D -REENTRANT -lpthread xxx. c
其中-REENTRANT宏使得相关库函数(如stdio.h、errno.h中函数) 是可重入的、线程安全的(thread-safe)，-lpthread则意味着链接库目录下的libpthread.a或libpthread.so文件。使用Linuxthread库需要2.0以上版本的Linux内核及相应版本的C库(libc 5.2.18、libc 5.4.12、libc 6)。
2.“线程”控制
线程创建
进程被创建时，系统会为其创建一个主线程，而要在进程中创建新的线程，则可以调用pthread_create：
pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(start_routine)(void*), void *arg);
start_routine为新线程的入口函数，arg为传递给start_routine的参数。
每个线程都有自己的线程ID，以便在进程内区分。线程ID在pthread_create调用时回返给创建线程的调用者；一个线程也可以在创建后使用pthread_self()调用获取自己的线程ID：
pthread_self (void) ;
线程退出
线程的退出方式有三：
（1）执行完成后隐式退出；
（2）由线程本身显示调用pthread_exit 函数退出；pthread_exit (void * retval) ;
（3）被其他线程用pthread_cance函数终止：pthread_cance (pthread_t thread) ;
在某线程中调用此函数，可以终止由参数thread 指定的线程。
如果一个线程要等待另一个线程的终止，可以使用pthread_join函数，该函数的作用是调用pthread_join的线程将被挂起直到线程ID为参数
thread的线程终止：
pthread_join (pthread_t thread, void** threadreturn);
3.线程通信
线程互斥
互斥意味着“排它”，即两个线程不能同时进入被互斥保护的代码。Linux下可以通过pthread_mutex_t 定义互斥体机制完成多线程的互斥操作，该机制的作用是对某个需要互斥的部分，在进入时先得到互斥体，如果没有得到互斥体，表明互斥部分被其它线程拥有，此时欲获取互斥体的线程阻塞，直到拥有该互斥体的线程完成互斥部分的操作为止。
下面的代码实现了对共享全局变量x 用互斥体mutex 进行保护的目的：
int x; // 进程中的全局变量
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL); //按缺省的属性初始化互斥体变量mutex
pthread_mutex_lock(&mutex); // 给互斥体变量加锁
… //对变量x 的操作
phtread_mutex_unlock(&mutex); // 给互斥体变量解除锁
线程同步
同步就是线程等待某个事件的发生。只有当等待的事件发生线程才继续执行，否则线程挂起并放弃处理器。当多个线程协作时，相互作用的任务必须在一定的条件下同步。
Linux下的C语言编程有多种线程同步机制，最典型的是条件变量(condition variable)。pthread_cond_init用来创建一个条件变量，其函数原型为：
pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr);
pthread_cond_wait和pthread_cond_timedwait用来等待条件变量被设置，值得注意的是这两个等待调用需要一个已经上锁的互斥体mutex，这是为了防止在真正进入等待状态之前别的线程有可能设置该条件变量而产生竞争。pthread_cond_wait的函数原型为：
pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);
pthread_cond_broadcast用于设置条件变量，即使得事件发生，这样等待该事件的线程将不再阻塞：
pthread_cond_broadcast (pthread_cond_t *cond) ;
pthread_cond_signal则用于解除某一个等待线程的阻塞状态：
pthread_cond_signal (pthread_cond_t *cond) ;
pthread_cond_destroy 则用于释放一个条件变量的资源。
在头文件semaphore.h 中定义的信号量则完成了互斥体和条件变量的封装，按照多线程程序设计中访问控制机制，控制对资源的同步访问，提供程序设计人员更方便的调用接口。
sem_init(sem_t *sem, int pshared, unsigned int val);
这个函数初始化一个信号量sem 的值为val，参数pshared 是共享属性控制，表明是否在进程间共享。
sem_wait(sem_t *sem);
调用该函数时，若sem为无状态，调用线程阻塞，等待信号量sem值增加(post )成为有信号状态；若sem为有状态，调用线程顺序执行，但信号量的值减一。
sem_post(sem_t *sem);
调用该函数，信号量sem的值增加，可以从无信号状态变为有信号状态。
4.实例
下面我们还是以著名的生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。
5.WIN32、VxWorks、Linux线程类比
目前为止，笔者已经创作了《基于嵌入式操作系统VxWorks的多任务并发程序设计》（《软件报》2006年5~12期连载）、《深入浅出Win32多线程程序设计》（天极网技术专题）系列，我们来找出这两个系列文章与本文的共通点。
看待技术问题要瞄准其本质，不管是Linux、VxWorks还是WIN32，其涉及到多线程的部分都是那些内容，无非就是线程控制和线程通信，它们的许多函数只是名称不同，其实质含义是等价的，下面我们来列个三大操作系统共同点详细表单：
事项
WIN32
VxWorks
Linux
线程创建
CreateThread
taskSpawn
pthread_create
线程终止
执行完成后退出；线程自身调用ExitThread 函数即终止自己；被其他线程调用函数TerminateThread函数
执行完成后退出；由线程本身调用exit退出；被其他线程调用函数taskDelete终止
执行完成后退出；由线程本身调用pthread_exit 退出；被其他线程调用函数pthread_cance终止
获取线程ID
GetCurrentThreadId
taskIdSelf
pthread_self
创建互斥
CreateMutex
semMCreate
pthread_mutex_init
获取互斥
WaitForSingleObject、
WaitForMultipleObjects
semTake
pthread_mutex_lock
释放互斥
ReleaseMutex
semGive
phtread_mutex_unlock
创建信号量
CreateSemaphore
semBCreate、semCCreate
sem_init
等待信号量
WaitForSingleObject
semTake
sem_wait
释放信号量
ReleaseSemaphore
semGive
sem_post
6.小结
本章讲述了Linux下多线程的控制及线程间通信编程方法，给出了一个生产者/消费者的实例，并将Linux的多线程与WIN32、VxWorks多线程进行了类比，总结了一般规律。鉴于多线程编程已成为开发并发应用程序的主流方法，学好本章的意义也便不言自明。
笔者曾经在《基于嵌入式操作系统VxWorks的多任务并发程序设计》（《软件报》2006年第5~12期）中详细叙述了进程和线程的区别，并曾经说明Linux是一种“多进程单线程”的操作系统。Linux本身只有进程的概念，而其所谓的“线程”本质上在内核里仍然是进程。大家知道，进程是资源分配的单位，同一进程中的多个线程共享该进程的资源（如作为共享内存的全局变量）。Linux中所谓的“线程”只是在被创建的时候“克隆”(clone)了父进程的资源，因此，clone出来的进程表现为“线程”，这一点一定要弄清楚。因此，Linux“线程”这个概念只有在打冒号的情况下才是最准确的，可惜的是几乎没有书籍留心去强调这一点。
Linux内核只提供了轻量进程的支持，未实现线程模型，但Linux尽最大努力优化了进程的调度开销，这在一定程度上弥补无线程的缺陷。Linux用一个核心进程（轻量进程）对应一个线程，将线程调度等同于进程调度，交给核心完成。目前Linux中最流行的线程机制为LinuxThreads，所采用的就是线程－进程“一对一”模型，调度交给核心，而在用户级实现一个包括信号处理在内的线程管理机制。LinuxThreads由Xavier Leroy (Xavier.Leroy@inria.fr)负责开发完成，并已绑定在GLIBC中发行，它实现了一种BiCapitalized面向Linux的Posix 1003.1c “pthread”标准接口。Linuxthread可以支持Intel、Alpha、MIPS等平台上的多处理器系统。按照POSIX 1003.1c 标准编写的程序与Linuxthread 库相链接即可支持Linux平台上的多线程，在程序中需包含头文件pthread. h，在编译链接时使用命令：
gcc -D -REENTRANT -lpthread xxx. c
其中-REENTRANT宏使得相关库函数(如stdio.h、errno.h中函数) 是可重入的、线程安全的(thread-safe)，-lpthread则意味着链接库目录下的libpthread.a或libpthread.so文件。使用Linuxthread库需要2.0以上版本的Linux内核及相应版本的C库(libc 5.2.18、libc 5.4.12、libc 6)。
2.“线程”控制
线程创建
进程被创建时，系统会为其创建一个主线程，而要在进程中创建新的线程，则可以调用pthread_create：
pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(start_routine)(void*), void *arg);
start_routine为新线程的入口函数，arg为传递给start_routine的参数。
每个线程都有自己的线程ID，以便在进程内区分。线程ID在pthread_create调用时回返给创建线程的调用者；一个线程也可以在创建后使用pthread_self()调用获取自己的线程ID：
pthread_self (void) ;
线程退出
线程的退出方式有三：
（1）执行完成后隐式退出；
（2）由线程本身显示调用pthread_exit 函数退出；pthread_exit (void * retval) ;
（3）被其他线程用pthread_cance函数终止：pthread_cance (pthread_t thread) ;
在某线程中调用此函数，可以终止由参数thread 指定的线程。
如果一个线程要等待另一个线程的终止，可以使用pthread_join函数，该函数的作用是调用pthread_join的线程将被挂起直到线程ID为参数
thread的线程终止：
pthread_join (pthread_t thread, void** threadreturn);
3.线程通信
线程互斥
互斥意味着“排它”，即两个线程不能同时进入被互斥保护的代码。Linux下可以通过pthread_mutex_t 定义互斥体机制完成多线程的互斥操作，该机制的作用是对某个需要互斥的部分，在进入时先得到互斥体，如果没有得到互斥体，表明互斥部分被其它线程拥有，此时欲获取互斥体的线程阻塞，直到拥有该互斥体的线程完成互斥部分的操作为止。
下面的代码实现了对共享全局变量x 用互斥体mutex 进行保护的目的：
int x; // 进程中的全局变量
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL); //按缺省的属性初始化互斥体变量mutex
pthread_mutex_lock(&mutex); // 给互斥体变量加锁
… //对变量x 的操作
phtread_mutex_unlock(&mutex); // 给互斥体变量解除锁
线程同步
同步就是线程等待某个事件的发生。只有当等待的事件发生线程才继续执行，否则线程挂起并放弃处理器。当多个线程协作时，相互作用的任务必须在一定的条件下同步。
Linux下的C语言编程有多种线程同步机制，最典型的是条件变量(condition variable)。pthread_cond_init用来创建一个条件变量，其函数原型为：
pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr);
pthread_cond_wait和pthread_cond_timedwait用来等待条件变量被设置，值得注意的是这两个等待调用需要一个已经上锁的互斥体mutex，这是为了防止在真正进入等待状态之前别的线程有可能设置该条件变量而产生竞争。pthread_cond_wait的函数原型为：
pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);
pthread_cond_broadcast用于设置条件变量，即使得事件发生，这样等待该事件的线程将不再阻塞：
pthread_cond_broadcast (pthread_cond_t *cond) ;
pthread_cond_signal则用于解除某一个等待线程的阻塞状态：
pthread_cond_signal (pthread_cond_t *cond) ;
pthread_cond_destroy 则用于释放一个条件变量的资源。
在头文件semaphore.h 中定义的信号量则完成了互斥体和条件变量的封装，按照多线程程序设计中访问控制机制，控制对资源的同步访问，提供程序设计人员更方便的调用接口。
sem_init(sem_t *sem, int pshared, unsigned int val);
这个函数初始化一个信号量sem 的值为val，参数pshared 是共享属性控制，表明是否在进程间共享。
sem_wait(sem_t *sem);
调用该函数时，若sem为无状态，调用线程阻塞，等待信号量sem值增加(post )成为有信号状态；若sem为有状态，调用线程顺序执行，但信号量的值减一。
sem_post(sem_t *sem);
调用该函数，信号量sem的值增加，可以从无信号状态变为有信号状态。
4.实例
下面我们还是以著名的生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。
#include
#include
#define BUFFER_SIZE 16 // 缓冲区数量
struct prodcons
{
// 缓冲区相关数据结构
int buffer[BUFFER_SIZE]; /* 实际数据存放的数组*/
pthread_mutex_t lock; /* 互斥体lock 用于对缓冲区的互斥操作 */
int readpos, writepos; /* 读写指针*/
pthread_cond_t notempty; /* 缓冲区非空的条件变量 */
pthread_cond_t notfull; /* 缓冲区未满的条件变量 */
};
/* 初始化缓冲区结构 */
void init(struct prodcons *b)
{
pthread_mutex_init(&b->lock, NULL);
pthread_cond_init(&b->notempty, NULL);
pthread_cond_init(&b->notfull, NULL);
b->readpos = 0;
b->writepos = 0;
}
/* 将产品放入缓冲区,这里是存入一个整数*/
void put(struct prodcons *b, int data)
{
pthread_mutex_lock(&b->lock);
/* 等待缓冲区未满*/
if ((b->writepos + 1) % BUFFER_SIZE == b->readpos)
{
pthread_cond_wait(&b->notfull, &b->lock);
}
/* 写数据,并移动指针 */
b->buffer[b->writepos] = data;
b->writepos++;
if (b->writepos > = BUFFER_SIZE)
b->writepos = 0;
/* 设置缓冲区非空的条件变量*/
pthread_cond_signal(&b->notempty);
pthread_mutex_unlock(&b->lock);
}
/* 从缓冲区中取出整数*/
int get(struct prodcons *b)
{
int data;
pthread_mutex_lock(&b->lock);
/* 等待缓冲区非空*/
if (b->writepos == b->readpos)
{
pthread_cond_wait(&b->notempty, &b->lock);
}
/* 读数据,移动读指针*/
data = b->buffer[b->readpos];
b->readpos++;
if (b->readpos > = BUFFER_SIZE)
b->readpos = 0;
/* 设置缓冲区未满的条件变量*/
pthread_cond_signal(&b->notfull);
pthread_mutex_unlock(&b->lock);
return data;
}
/* 测试:生产者线程将1 到10000 的整数送入缓冲区,消费者线程从缓冲区中获取整数,两者都打印信息*/
#define OVER ( - 1)
struct prodcons buffer;
void *producer(void *data)
{
int n;
for (n = 0; n < 10000; n++)
{
printf("%d --->\n", n);
put(&buffer, n);
} put(&buffer, OVER);
return NULL;
}
void *consumer(void *data)
{
int d;
while (1)
{
d = get(&buffer);
if (d == OVER)
break;
printf("--->%d \n", d);
}
return NULL;
}
int main(void)
{
pthread_t th_a, th_b;
void *retval;
init(&buffer);
/* 创建生产者和消费者线程*/
pthread_create(&th_a, NULL, producer, 0);
pthread_create(&th_b, NULL, consumer, 0);
/* 等待两个线程结束*/
pthread_join(th_a, &retval);
pthread_join(th_b, &retval);
return 0;
}
5.WIN32、VxWorks、Linux线程类比
目前为止，笔者已经创作了《基于嵌入式操作系统VxWorks的多任务并发程序设计》（《软件报》2006年5~12期连载）、《深入浅出Win32多线程程序设计》（天极网技术专题）系列，我们来找出这两个系列文章与本文的共通点。
看待技术问题要瞄准其本质，不管是Linux、VxWorks还是WIN32，其涉及到多线程的部分都是那些内容，无非就是线程控制和线程通信，它们的许多函数只是名称不同，其实质含义是等价的，下面我们来列个三大操作系统共同点详细表单：
事项
WIN32
VxWorks
Linux
线程创建
CreateThread
taskSpawn
pthread_create
线程终止
执行完成后退出；线程自身调用ExitThread 函数即终止自己；被其他线程调用函数TerminateThread函数
执行完成后退出；由线程本身调用exit退出；被其他线程调用函数taskDelete终止
执行完成后退出；由线程本身调用pthread_exit 退出；被其他线程调用函数pthread_cance终止
获取线程ID
GetCurrentThreadId
taskIdSelf
pthread_self
创建互斥
CreateMutex
semMCreate
pthread_mutex_init
获取互斥
WaitForSingleObject、
WaitForMultipleObjects
semTake
pthread_mutex_lock
释放互斥
ReleaseMutex
semGive
phtread_mutex_unlock
创建信号量
CreateSemaphore
semBCreate、semCCreate
sem_init
等待信号量
WaitForSingleObject
semTake
sem_wait
释放信号量
ReleaseSemaphore
semGive
sem_post
6.小结
本章讲述了Linux下多线程的控制及线程间通信编程方法，给出了一个生产者/消费者的实例，并将Linux的多线程与WIN32、VxWorks多线程进行了类比，总结了一般规律。鉴于多线程编程已成为开发并发应用程序的主流方法，学好本章的意义也便不言自明。
Linux的进程间通信（zz）
Linux的进程间通信（IPC，InterProcess Communication）通信方法有管道、消息队列、共享内存、信号量、套接口等。管道分为有名管道和无名管道，无名管道只能用于亲属进程之间的通信，而有名管道则可用于无亲属关系的进程之间。
上述程序中，无名管道以
int pipe(int filedis[2]);
方式定义，参数filedis返回两个文件描述符filedes[0]为读而打开，filedes[1]为写而打开，filedes[1]的输出是filedes[0]的输入；
在Linux系统下，有名管道可由两种方式创建（假设创建一个名为“fifoexample”的有名管道）：
（1）mkfifo("fifoexample","rw");
（2）mknod fifoexample p
mkfifo是一个函数，mknod是一个系统调用，即我们可以在shell下输出上述命令。
有名管道创建后，我们可以像读写文件一样读写之：
消息队列用于运行于同一台机器上的进程间通信，与管道相似；
共享内存通常由一个进程创建，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式
不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的是实际的物理内存；常用的方式是通过shmXXX函数族来实现共享内存：
int shmget(key_t key, int size, int flag); /* 获得一个共享存储标识符 */
该函数使得系统分配size大小的内存用作共享内存；
void *shmat(int shmid, void *addr, int flag); /* 将共享内存连接到自身地址空间中*/
shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址。此后，进程可以对此地址进行读写操作访问共享内存。
本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作：
（1）测试控制该资源的信号量；
（2）若此信号量的值为正，则允许进行使用该资源，进程将进号量减1；
（3）若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大于0，进程被唤醒，转入步骤（1）；
（4）当进程不再使用一个信号量控制的资源时，信号量值加1，如果此时有进程正在睡眠等待此信号量，则唤醒此进程。
下面是一个使用信号量的例子，该程序创建一个特定的IPC结构的关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量的值，最后清除信号量：
套接字通信并不为Linux所专有，在所有提供了TCP/IP协议栈的操作系统中几乎都提供了socket，而所有这样操作系统，对套接字的编程方法几乎是完全一样的。
4.小结
本文讲述了Linux进程的概念，并以多个实例讲解了进程控制及进程间通信方法，理解这篇的内容可以说是理解Linux这个操作系统的关键。
#define INPUT 0
#define OUTPUT 1
void main()
{
int file_descriptors[2];
/*定义子进程号 */
pid_t pid;
char buf[BUFFER_LEN];
int returned_count;
/*创建无名管道*/
pipe(file_descriptors);
/*创建子进程*/
if ((pid = fork()) == - 1)
{
printf("Error in fork\n");
exit(1);
}
/*执行子进程*/
if (pid == 0)
{
printf("in the spawned (child) process...\n");
/*子进程向父进程写数据，关闭管道的读端*/
close(file_descriptors[INPUT]);
write(file_descriptors[OUTPUT], "test data", strlen("test data"));
exit(0);
}
else
{
/*执行父进程*/
printf("in the spawning (parent) process...\n");
/*父进程从管道读取子进程写的数据，关闭管道的写端*/
close(file_descriptors[OUTPUT]);
returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
printf("%d bytes of data received from spawned process: %s\n",
returned_count, buf);
}
}
上述程序中，无名管道以
int pipe(int filedis[2]);
方式定义，参数filedis返回两个文件描述符filedes[0]为读而打开，filedes[1]为写而打开，filedes[1]的输出是filedes[0]的输入；
在Linux系统下，有名管道可由两种方式创建（假设创建一个名为“fifoexample”的有名管道）：
（1）mkfifo("fifoexample","rw");
（2）mknod fifoexample p
mkfifo是一个函数，mknod是一个系统调用，即我们可以在shell下输出上述命令。
有名管道创建后，我们可以像读写文件一样读写之：
/* 进程一：读有名管道*/
void main()
{
FILE *in_file;
int count = 1;
char buf[BUFFER_LEN];
in_file = fopen("pipeexample", "r");
if (in_file == NULL)
{
printf("Error in fdopen.\n");
exit(1);
}
while ((count = fread(buf, 1, BUFFER_LEN, in_file)) > 0)
printf("received from pipe: %s\n", buf);
fclose(in_file);
}
/* 进程二：写有名管道*/
void main()
{
FILE *out_file;
int count = 1;
char buf[BUFFER_LEN];
out_file = fopen("pipeexample", "w");
if (out_file == NULL)
{
printf("Error opening pipe.");
exit(1);
}
sprintf(buf, "this is test data for the named pipe example\n");
fwrite(buf, 1, BUFFER_LEN, out_file);
fclose(out_file);
}
消息队列用于运行于同一台机器上的进程间通信，与管道相似；
共享内存通常由一个进程创建，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式
不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的是实际的物理内存；常用的方式是通过shmXXX函数族来实现共享内存：
int shmget(key_t key, int size, int flag); /* 获得一个共享存储标识符 */
该函数使得系统分配size大小的内存用作共享内存；
void *shmat(int shmid, void *addr, int flag); /* 将共享内存连接到自身地址空间中*/
shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址。此后，进程可以对此地址进行读写操作访问共享内存。
本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作：
（1）测试控制该资源的信号量；
（2）若此信号量的值为正，则允许进行使用该资源，进程将进号量减1；
（3）若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大于0，进程被唤醒，转入步骤（1）；
（4）当进程不再使用一个信号量控制的资源时，信号量值加1，如果此时有进程正在睡眠等待此信号量，则唤醒此进程。
下面是一个使用信号量的例子，该程序创建一个特定的IPC结构的关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量的值，最后清除信号量：
#include <stdio.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/ipc.h>
void main()
{
key_t unique_key; /* 定义一个IPC关键字*/
int id;
struct sembuf lock_it;
union semun options;
int i;
unique_key = ftok(".", 'a'); /* 生成关键字，字符'a'是一个随机种子*/
/* 创建一个新的信号量集合*/
id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);
printf("semaphore id=%d\n", id);
options.val = 1; /*设置变量值*/
semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/
/*打印出信号量的值*/
i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d\n", i);
/*下面重新设置信号量*/
lock_it.sem_num = 0; /*设置哪个信号量*/
lock_it.sem_op = - 1; /*定义操作*/
lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/
if (semop(id, &lock_it, 1) == - 1)
{
printf("can not lock semaphore.\n");
exit(1);
}
i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d\n", i);
/*清除信号量*/
semctl(id, 0, IPC_RMID, 0);
}
套接字通信并不为Linux所专有，在所有提供了TCP/IP协议栈的操作系统中几乎都提供了socket，而所有这样操作系统，对套接字的编程方法几乎是完全一样的。
4.小结
本文讲述了Linux进程的概念，并以多个实例讲解了进程控制及进程间通信方法，理解这篇的内容可以说是理解Linux这个操作系统的关键。
2008年10月24日星期五
C++多线程入门（zz）
发信人: eastcrusader (昨我已逝), 信区: CPlusPlus
标 题: C++多线程入门（一）
发信站: 水木社区 (Wed Oct 8 01:10:23 2008), 站内
第1节 背景
为了更好的理解多线程的概念，先对进程，线程的概念背景做一下简单介绍。
早期的计算机系统都只允许一个程序独占系统资源，一次只能执行一个程序。在大型机年代，计算能力是一种宝贵资源。对于资源拥有方来说，最好的生财之道自然是将同一资源同时租售给尽可能多的用户。最理想的情况是垄断全球计算市场。所以不难理解为何当年IBM预测“全球只要有4台计算机就够了”。
这种背景下，一个计算机能够支持多个程序并发执行的需求变得十分迫切。由此产生了进程的概念。进程在多数早期多任务操作系统中是执行工作的基本单元。进程是包含程序指令和相关资源的集合。每个进程和其他进程一起参与调度，竞争CPU，内存等系统资源。每次进程切换，都存在进程资源的保存和恢复动作，这称为上下文切换。
进程的引入可以解决支持多用户的问题，但是多进程系统也在如下方面产生了新的问题：
? 进程频繁切换引起的额外开销可能会严重影响系统性能。
? 进程间通信要求复杂的系统级实现。
在程序功能日趋复杂的情况下，上述缺陷也就凸现出来。比如，一个简单的GUI程序，为了有更好的交互性，通常用一个任务支持界面交互，另一个任务支持后台运算。如果每个任务均由一个进程来实现，那会相当低效。对每个进程来说，系统资源看上去都是其独占的。比如内存空间，每个进程认为自己的内存空间是独有的。一次切换，这些独立资源都需要切换。
由此就演化出了利用分配给同一个进程的资源，尽量实现多个任务的方法。这也就引入了线程的概念。同一个进程内部的多个线程，共享的是同一个进程的所有资源。
比如，与每个进程独有自己的内存空间不同，同属一个进程的多个线程共享该进程的内存空间。例如在进程地址空间中有一个全局变量globalVar，若A线程将其赋值为1，则另一线程B可以看到该变量值为1。两个线程看到的全局变量globalVar是同一个变量。
通过线程可以支持同一个应用程序内部的并发，免去了进程频繁切换的开销，另外并发任务间通信也更简单。
目前多线程应用主要用于两大领域：网络应用和嵌入式应用。为什么在这两个领域应用较多呢？因为多线程应用能够解决两大问题：
? 并发。网络程序具有天生的并发性。比如网络数据库可能需要同时处理数以千计的请求。而由于网络连接的时延不确定性和不可靠性，一旦等待一次网络交互，可以让当前线程进入睡眠，退出调度，处理其他线程。这样就能够有效利用系统资源，充分发挥系统处理能力。
? 实时。线程的切换是轻量级的，所以可以保证足够快。每当有事件发生，状态改变，都能有线程及时响应，而且每次线程内部处理的计算强度和复杂度都不大。在这种情况下，多线程实现的模型也是高效的。
在有些语言中，对多线程或者并发的支持是直接内建在语言中的，比如Ada和VHDL。在C++里面，对多线程的支持由具体操作系统提供的函数接口支持。不同的系统中具体实现方法不同。后面所有例子只给出windows和Unix/Linux的实现。
在后面的实现中，考虑的是尽量封装隔离底层的多线程函数接口，屏蔽操作系统底层的线程实现具体细节，介绍的重点是多线程编程中较通用的概念。同时也尽量体现C++面向对象的一面。
最后，由于空闲时间有限，我只求示例代码能够明确表达自己的意思即可。至于代码的尽善尽美就只能有劳各位尽力以为之了。
?
第2节 线程的创建
本节介绍如下内容
? 线程状态
? 线程运行环境
? 线程类定义
? 示例程序
? 线程类的Windows和Unix实现
线程状态
在一个线程的生存期内，可以在多种状态之间转换。不同操作系统可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态。但大体说来，如下几种状态是通用的：
? 就绪：参与调度，等待被执行。一旦被调度选中，立即开始执行。
? 运行：占用CPU，正在运行中。
? 休眠：暂不参与调度，等待特定事件发生。
? 中止：已经运行完毕，等待回收线程资源（要注意，这个很容易误解，后面解释）。
线程环境
线程存在于进程之中。进程内所有全局资源对于内部每个线程均是可见的。
进程内典型全局资源有如下几种：
? 代码区。这意味着当前进程空间内所有可见的函数代码，对于每个线程来说也是可见的。
? 静态存储区。全局变量。静态变量。
? 动态存储区。也就是堆空间。
线程内典型的局部资源有：
? 本地栈空间。存放本线程的函数调用栈，函数内部的局部变量等。
? 部分寄存器变量。例如本线程下一步要执行代码的指针偏移量。
一个进程发起之后，会首先生成一个缺省的线程，通常称这个线程为主线程。C/C++程序中主线程就是通过main函数进入的线程。由主线程衍生的线程称为从线程，从线程也可以有自己的入口函数，作用相当于主线程的main函数。
这个函数由用户指定。Pthread和winapi中都是通过传入函数指针实现。在指定线程入口函数时，也可以指定入口函数的参数。就像main函数有固定的格式要求一样，线程的入口函数一般也有固定的格式要求，参数通常都是void *类型，返回类型在pthread中是void *, winapi中是unsigned int，而且都需要是全局函数。
最常见的线程模型中，除主线程较为特殊之外，其他线程一旦被创建，相互之间就是对等关系 (peer to peer)， 不存在隐含的层次关系。每个进程可以创建的最大线程数由具体实现决定。
为了更好的理解上述概念，下面通过具体代码来详细说明。
线程类接口定义
一个线程类无论具体执行什么任务，其基本的共性无非就是
? 创建并启动线程
? 停止线程
? 另外还有就是能睡，能等，能分离执行（有点拗口，后面再解释）。
? 还有其他的可以继续加…
将线程的概念加以抽象，可以为其定义如下的类：
文件 thread.h
#ifndef __THREAD__H_
#define __THREAD__H_
class Thread
{
public:
Thread();
virtual ~Thread();
int start (void * = NULL);
void stop();
void sleep (int);
void detach();
void * wait();
protected:
virtual void * run(void *) = 0;
private:
//这部分win和unix略有不同，先不定义，后面再分别实现。
//顺便提一下，我很不习惯写中文注释，这里为了更明白一
//点还是选用中文。
…
};
#endif
Thread::start()函数是线程启动函数，其输入参数是无类型指针。
Thread::stop()函数中止当前线程。
Thread::sleep()函数让当前线程休眠给定时间，单位为秒。
Thread::run()函数是用于实现线程类的线程函数调用。
Thread::detach()和thread::wait()函数涉及的概念略复杂一些。在稍后再做解释。
Thread类是一个虚基类，派生类可以重载自己的线程函数。下面是一个例子。
示例程序
代码写的都不够精致，暴力类型转换比较多，欢迎有闲阶级美化，谢过了先。
文件create.h
#ifndef __CREATOR__H_
#define __CREATOR__H_
#include <stdio.h>
#include "thread.h"
class Create: public Thread
{
protected:
void * run(void * param)
{
char * msg = (char*) param;
printf ("%s\n", msg);
//sleep(100); 可以试着取消这行注释，看看结果有什么不同。
printf("One day past.\n");
return NULL;
}
};
#endif
然后，实现一个main函数，来看看具体效果：
文件Genesis.cpp
#include <stdio.h>
#include "create.h"
int main(int argc, char** argv)
{
Create monday;
Create tuesday;
printf("At the first God made the heaven and the earth.\n");
monday.start("Naming the light, Day, and the dark, Night, the first day.");
tuesday.start("Gave the arch the name of Heaven, the second day.");
printf("These are the generations of the heaven and the earth.\n");
return 0;
}
编译运行，程序输出如下：
At the first God made the heaven and the earth.
These are the generations of the heaven and the earth.
令人惊奇的是，由周一和周二对象创建的子线程似乎并没有执行！这是为什么呢？别急，在最后的printf语句之前加上如下语句：
monday.wait();
tuesday.wait();
重新编译运行，新的输出如下：
At the first God made the heaven and the earth.
Naming the light, Day, and the dark, Night, the first day.
One day past.
Gave the arch the name of Heaven, the second day.
One day past.
These are the generations of the heaven and the earth.
为了说明这个问题，需要了解前面没有解释的Thread::detach()和Thread::wait()两个函数的含义。
无论在windows中，还是Posix中，主线程和子线程的默认关系是：
无论子线程执行完毕与否，一旦主线程执行完毕退出，所有子线程执行都会终止。这时整个进程结束或僵死（部分线程保持一种终止执行但还未销毁的状态，而进程必须在其所有线程销毁后销毁，这时进程处于僵死状态），在第一个例子的输出中，可以看到子线程还来不及执行完毕，主线程的main()函数就已经执行完毕，从而所有子线程终止。
需要强调的是，线程函数执行完毕退出，或以其他非常方式终止，线程进入终止态（请回顾上面说的线程状态），但千万要记住的是，进入终止态后，为线程分配的系统资源并不一定已经释放，而且可能在系统重启之前，一直都不能释放。终止态的线程，仍旧作为一个线程实体存在与操作系统中。（这点在win和unix中是一致的。）而什么时候销毁线程，取决于线程属性。
通常，这种终止方式并非我们所期望的结果，而且一个潜在的问题是未执行完就终止的子线程，除了作为线程实体占用系统资源之外，其线程函数所拥有的资源（申请的动态内存，打开的文件，打开的网络端口等）也不一定能释放。所以，针对这个问题，主线程和子线程之间通常定义两种关系：
? 可会合(joinable)。这种关系下，主线程需要明确执行等待操作。在子线程结束后，主线程的等待操作执行完毕，子线程和主线程会合。这时主线程继续执行等待操作之后的下一步操作。主线程必须会合可会合的子线程，Thread类中，这个操作通过在主线程的线程函数内部调用子线程对象的wait()函数实现。这也就是上面加上三个wait()调用后显示正确的原因。必须强调的是，即使子线程能够在主线程之前执行完毕，进入终止态，也必需显示执行会合操作，否则，系统永远不会主动销毁线程，分配给该线程的系统资源（线程id或句柄，线程管理相关的系统资源）也永远不会释放。
? 相分离(detached)。顾名思义，这表示子线程无需和主线程会合，也就是相分离的。这种情况下，子线程一旦进入终止态，系统立即销毁线程，回收资源。无需在主线程内调用wait()实现会合。Thread类中，调用detach()使线程进入detached状态。这种方式常用在线程数较多的情况，有时让主线程逐个等待子线程结束，或者让主线程安排每个子线程结束的等待顺序，是很困难或者不可能的。所以在并发子线程较多的情况下，这种方式也会经常使用。
缺省情况下，创建的线程都是可会合的。可会合的线程可以通过调用detach()方法变成相分离的线程。但反向则不行。
UNIX实现
文件 thread.h
#ifndef __THREAD__H_
#define __THREAD__H_
class Thread
{
public:
Thread();
virtual ~Thread();
int start (void * = NULL);
void stop();
void sleep (int);
void detach();
void * wait();
protected:
virtual void * run(void *) = 0;
private:
pthread_t handle;
bool started;
bool detached;
void * threadFuncParam;
friend void * threadFunc(void *);
};
//pthread中线程函数必须是一个全局函数，为了解决这个问题
//将其声明为静态，以防止此文件之外的代码直接调用这个函数。
//此处实现采用了称为Virtual friend function idiom 的方法。
Static void * threadFunc(void *);
#endif
文件thread.cpp
#include <pthread.h>
#include <sys/time.h>
#include “thread.h”
static void * threadFunc (void * threadObject)
{
Thread * thread = (Thread *) threadObject;
return thread->run(thread->threadFuncParam);
}
Thread::Thread()
{
started = detached = false;
}
Thread::~Thread()
{
stop();
}
bool Thread::start(void * param)
{
pthread_attr_t attributes;
pthread_attr_init(&attributes);
if (detached)
{
pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
}
threadFuncParam = param;
if (pthread_create(&handle, &attributes, threadFunc, this) == 0)
{
started = true;
}
pthread_attr_destroy(&attribute);
}
void Thread::detach()
{
if (started && !detached)
{
pthread_detach(handle);
}
detached = true;
}
void * Thread::wait()
{
void * status = NULL;
if (started && !detached)
{
pthread_join(handle, &status);
}
return status;
}
void Thread::stop()
{
if (started && !detached)
{
pthread_cancel(handle);
pthread_detach(handle);
detached = true;
}
}
void Thread::sleep(unsigned int milliSeconds)
{
timeval timeout = { milliSeconds/1000, millisecond%1000};
select(0, NULL, NULL, NULL, &timeout);
}
Windows实现
文件thread.h
#ifndef _THREAD_SPECIFICAL_H__
#define _THREAD_SPECIFICAL_H__
#include <windows.h>
static unsigned int __stdcall threadFunction(void *);
class Thread {
friend unsigned int __stdcall threadFunction(void *);
public:
Thread();
virtual ~Thread();
int start(void * = NULL);
void * wait();
void stop();
void detach();
static void sleep(unsigned int);
protected:
virtual void * run(void *) = 0;
private:
HANDLE threadHandle;
bool started;
bool detached;
void * param;
unsigned int threadID;
};
#endif
文件thread.cpp
#include "stdafx.h"
#include <process.h>
#include "thread.h"
unsigned int __stdcall threadFunction(void * object)
{
Thread * thread = (Thread *) object;
return (unsigned int ) thread->run(thread->param);
}
Thread::Thread()
{
started = false;
detached = false;
}
Thread::~Thread()
{
stop();
}
int Thread::start(void* pra)
{
if (!started)
{
param = pra;
if (threadHandle = (HANDLE)_beginthreadex(NULL, 0, threadFunction, this, 0, &threadID))
{
if (detached)
{
CloseHandle(threadHandle);
}
started = true;
}
}
return started;
}
//wait for current thread to end.
void * Thread::wait()
{
DWORD status = (DWORD) NULL;
if (started && !detached)
{
WaitForSingleObject(threadHandle, INFINITE);
GetExitCodeThread(threadHandle, &status);
CloseHandle(threadHandle);
detached = true;
}
return (void *)status;
}
void Thread::detach()
{
if (started && !detached)
{
CloseHandle(threadHandle);
}
detached = true;
}
void Thread::stop()
{
if (started && !detached)
{
TerminateThread(threadHandle, 0);
//Closing a thread handle does not terminate
//the associated thread.
//To remove a thread object, you must terminate the thread,
//then close all handles to the thread.
//The thread object remains in the system until
//the thread has terminated and all handles to it have been
//closed through a call to CloseHandle
CloseHandle(threadHandle);
detached = true;
}
}
void Thread::sleep(unsigned int delay)
{
::Sleep(delay);
}
小结
本节的主要目的是帮助入门者建立基本的线程概念，以此为基础，抽象出一个最小接口的通用线程类。在示例程序部分，初学者可以体会到并行和串行程序执行的差异。有兴趣的话，大家可以在现有线程类的基础上，做进一步的扩展和尝试。如果觉得对线程的概念需要进一步细化，大家可以进一步扩展和完善现有Thread类。
想更进一步了解的话，一个建议是，可以去看看其他语言，其他平台的线程库中，线程类抽象了哪些概念。比如Java, perl等跨平台语言中是如何定义的，微软从winapi到dotnet中是如何支持多线程的，其线程类是如何定义的。这样有助于更好的理解线程的模型和基础概念。
另外，也鼓励大家多动手写写代码，在此基础上尝试写一些代码，也会有助于更好的理解多线程程序的特点。比如，先开始的线程不一定先结束。线程的执行可能会交替进行。把printf替换为cout可能会有新的发现，等等。
每个子线程一旦被创建，就被赋予了自己的生命。管理不好的话，一只特例独行的猪是非常让人头痛的。
对于初学者而言，编写多线程程序可能会遇到很多令人手足无措的bug。往往还没到考虑效率，避免死锁等阶段就问题百出，而且很难理解和调试。这是非常正常的，请不要气馁，后续文章会尽量解释各种常见问题的原因，引导大家避免常见错误。目前能想到入门阶段常遇到的问题是：
? 内存泄漏，系统资源泄漏。
? 程序执行结果混乱，但是在某些点插入sleep语句后结果又正确了。
? 程序crash, 但移除或添加部分无关语句后，整个程序正常运行（假相）。
? 多线程程序执行结果完全不合逻辑，出于预期。
本文至此，如果自己动手改改，试一些例子，对多线程程序应该多少有一些感性认识了。刚开始只要把基本概念弄懂了，后面可以一步一步搭建出很复杂的类。不过刚开始不要贪多，否则会欲速则不达，越弄越糊涂。
最后，大家见仁见智吧，我在此起到抛砖引玉的作用就很开心了，呵呵。另外文本编辑器的原因，代码如果编译不过，可能需要把标点符号从中文换成英文。
第三节 线程互斥
本节介绍如下内容
? 主动对象
? 调度与原子操作
? 竞争条件和数据一致性
? 为何需要互斥
? 互斥类接口定义
? 示例程序
? 互斥类的Unix和Windows实现
主动对象(Active Object)
第二节介绍Thread类的时候曾经提到，每个子线程一旦被创建，就被赋予了自己的生命。当一个线程类创建并启动之后，它将会以自己的步调主动执行其独立线程，它和其他线程（包括主线程）的执行是并行关系。
为了详细说明这个问题，先介绍一下什么是控制流(control flow)。计算机科学中，控制流指指令式(imperative)或函数式(functional)编程语言中语句、指令、函数调用的执行（或求值）序列。
单线程程序中，控制流始终是一线串珠，一旦控制流达到某个对象，由程序主动调用对象函数，在函数执行完毕后，控制流返回主程序继续执行。对于被访问对象来说，访问、修改、成员函数调用都是一个被动的过程，此过程受控于该程序的控制流。所以，称单线程程序的对象为被动对象(Passive Object)。
与被动对象相对应的是主动对象。主动对象和被动对象的区别在于，主动对象可以发起自己的线程，创建新的执行序列，产生独立于主线程的控制流分支。简而言之，主动对象可以独立于主线程，自主制定自己的控制流。如果愿意，你可以实现一个和主线程没有任何协调关系，天马行空式的独立线程。当然，这样的线程往往也意味着毫无用处（娱乐作用除外）。
调度和原子操作
从理论模型上说，多线程环境中，线程之间是独立、对等关系。一个线程完全可以无视其他线程的存在。但实际多线程执行环境中，线程数往往远大于CPU数量。为了共享和分配资源，线程必需遵守一定规则，进行必要的协调。操作系统中具体的规则执行者是调度程序。因此，要想掌握多线程编程，就必需了解线程调度的基本概念和特点。在此基础上，才能了解为什么需要在线程之间进行协调，进而才能透彻理解如何协调多线程的并发执行。
现代操作系统中，存在许多不同的线程调度模型，这些调度模型的基本共同点就是线程执行顺序具有随机性和不确定性。调度模型既无法事先知道某一时刻会存在多少线程，也无法知道哪个线程会正在运行，甚至也不知道某个线程确切会到什么时刻执行结束，更不用说预先安排在特定时刻执行特定线程的特定语句。
前面提到，控制流就是语句，指令或函数调用的顺序序列。反映到时间轴上，就是一系列离散分布的执行序列。线程调度作用于多个控制流的客观效果，就是多个控制流按同一条时间轴排列时，是一个近似随机的执行序列；按每个控制流各自的时间轴排列时，则是一个具有先后顺序的执行序列。
在具体的程序执行上，这个特点就表现为线程A的一个语句执行完毕后，紧接着执行的可能是另一个线程B的一个语句。甚至可能是线程A的一个语句还没有执行完毕，就接着执行线程B的语句。
对于后一点不用感到奇怪。因为操作系统中，调度程序作为系统底层实现的一部分，参与调度的操作指令可能比高级编程语言的基本语句要底层的多。同一个调度程序，其调度的众多线程可能由多种高级语言编写，所以调度程序基本上不可能以某种高级编程语言的单条语句为单位安排执行序列。
通常，一条高级语言语句可能对应多条汇编指令，而一条汇编指令可能对应多条CPU微码指令。而一条微码指令，则可能对应逻辑电路的一个具体电路逻辑。顺便提一下，这也是Verilog, VHDL等高级语言能够综合出具体的逻辑电路的基本原理。所不同的是，高级语言编译器编译的最终单位是汇编，而硬件描述语言综合的最终单位是和微码对应的电路器件单元（集成电路前端设计的内容。记得以前暑期实习，我窝在学校做的就是这么一个元件库，做的很不像样子居然还得到了一定的肯定，多年后想起来还是汗颜）。
至于系统调度程序具体会定义怎样的原子操作集合，会以什么粒度的指令为调度基本单位，这就是系统设计者各显神通的地方了。个人认为，作为高级语言的编程者，记住什么操作是原子操作意义并不明显。大多数场合，只要认为，多线程的控制流在同一条时间轴上看来是完全随机的就可以了。要记住，墨菲定律生效的时候，看似不可能的事情都能成为现实。
多线程程序设计中，一种朴素的设计思想是将线程具体化为主动对象，主动对象之间通过共享环境（全局资源）来维护当前应用的运行状态；主动对象间通过一套约定的互斥和同步规则来实现通信；线程的具体执行时序则由调度程序安排。主动对象之间，应尽量避免一个主动对象直接调用另一个主动对象的内部方法（例如suspend, stop, exit）直接控制另一个线程的执行步调。主动对象的行为应该完全由其本身控制，和其他主动对象的交互尽量只通过环境以及同步语句来实现。
实际实现中，如果多个主动对象都可以直接调用某个主动对象的stop方法终止其运行，这个程序是非常脆弱的，因为在调度程序之外，不借助同步机制，主观假定线程执行时序，人为更改线程执行状态是非常不明智的。即使这样的程序可用，对于维护者来说其难度也不亚于维护goto语句。
这也就是前一篇文章所定义线程类中detach, start, stop没有加锁的原因，因为并不希望在多个线程中调用同一个线程对象的这些方法。
竞争条件和数据一致性
共享环境是进程全局资源的同义词。在多线程并发执行中，最常遇到的问题就是共享环境被污染。具体体现就是全局数据被破坏，全局文件内容被破坏 … 。
例如：
有一个64位全局变量long globalVar = 0;主动对象A想把它置为0x000A000B000C000D；假设这个操作分两步执行，先将高32位置为000A000B，再把低32位置为000C000D。但不巧的是，对象A刚刚将高位置位，调度程序安排另一主动对象B执行。这时，全局变量globalVar内部的值是一个非法值，它是无意义的。在B拿着这个值做进一步处理时，得出的也是错误结果。这时，称为数据的一致性被破坏。
线程调度的不确定性也可能导致程序执行结果的不确定性。有时候这种不确定性会导致程序得到错误的运行结果。
例如：
为了对Thread类所生成的对象总数计数，定义一个全局变量Unsigned int counter = 0; 在Thread类的构造函数中，执行++counter。现在假设有2个Thread对象objA和objB并发运行，考虑如下两个场景：
Scenario1.操作序列如下：
1. counter = 0;
2. objA将counter值0从内存读入寄存器A；
3. objA将寄存器A值加1；
4. objA将寄存器A值写回内存，counter值为1；
5. objB将counter值1从内存读入寄存器B；
6. objB将寄存器B值加1；
7. objA将寄存器B值写回内存，counter值为2；
8. 最终counter值为2。
Scenario2.操作序列如下：
1. counter = 0;
2. objA将counter值0从内存读入寄存器A；
3. objB将counter值0从内存读入寄存器B
4. objA将寄存器A值加1；
5. objB将寄存器B值加1；
6. objA将寄存器A值写回内存，counter值为1；
7. objA将寄存器B值写回内存，counter值为1；
8. 最终counter值为1。
场景1的结果是设计的本意，场景2的结果对我们而言是错误的。
一个线程的执行结果正确性取决于于其他线程执行时序的条件，称为竞争条件。中文这样翻译不伦不类，但从英文字面理解非常容易。Race一般是计时赛，某位选手跑得快一点，竞赛结果就有变化，最终结果由race condition决定，还是非常形象的。
为何需要互斥
线程间协作问题，通常可以归为互斥和同步两类。其中互斥又主要解决两类问题：维护数据一致性、避免竞争条件的出现。
解决一致性问题，通俗说就是，修改数据的线程通告其他线程“我正在修改你要访问的对象X，操作过程中不能保证这个数据的有效性，请不要使用此对象”。
避免竞争条件，通俗说就是，某线程通告其他线程“我将要进行涉及某对象的一系列操作A，在我未完成这一系列操作之前，如果有人和我同时执行涉及此对象的操作序列B（B也可能就是A），将会影响我执行结果的正确性，请不要进行涉及此对象的操作”。
这种操作序列A有时候也被称为“原子性操作”，因为它不允许操作序列B在时间轴上和它交叉分布，必需保证在时间轴上看来，操作序列A是一个不可分割的整体。（物理学早期，原子也被认为是不可分割的）。
以上冗长的解释，精简成一句话，就是“线程间需要互斥执行”。需要互斥的操作对应的代码也有一个很学术的名称－“关键域（或关键区）”。
那么如何实现互斥呢？一个简单的思路就是，设立一个权威仲裁者，给那些需要互斥执行的线程颁发一个共用的通行证。某个线程想要进入一个关键域执行，需要先申请可以进入该关键域的通行证，如果别的线程已经拿走了该通行证，则本线程等待，进入休眠状态，退出调度。如果本线程的通行证使用完毕，则应该将它归还给仲裁者，重新唤醒等待线程，参与调度，竞争此通行证。
比如，下列伪码中，threadFuncA和threadFuncB就需要申请同一张通行证：
例一：
int globalCounter = 0;
void threadFuncA (通行证类型 * 通行证)
{
获取通行证；
globalCounter++;
归还通行证；
}
Void threadFuncB (通行证类型 * 通行证)
{
获取通行证；
globalCounter *= 2;
归还通行证；
}
又比如，下列伪码中，需要为ResourceClass类的对象引用计数器制定一张通行证
。
例二：
class ResourceClass
{
public:
resource & reference()
{
获取通行证；
++refcounter;
printf(“当前对象被引用了%u次”, refCounter);
释放通行证；
}
private:
通行证类型 通行证；
unsigned int refCounter;
};
ResourceClass rescObj
Void threadFuncA()
{
rescObj-> reference();
}
Void threadFuncB()
{
rescObj-> reference();
}
最后一个例子，是为ResourceClass类的对象计数器制定一张通行证。
例三：
class ResourceClass
{
public:
ResourceClass ()
{
获取通行证；
++objcounter;
printf(“当前类创建了%u个对象”, objCounter);
释放通行证；
}
private:
static通行证类型 通行证；
unsigned int objCounter;
};
Void threadFuncA()
{
ResourceClass * rescObj = new ResourceClass ();
}
Void threadFuncB()
{
ResourceClass * rescObj = new ResourceClass ();
}
这三个例子中，例一是不同函数之间互斥，所以通行证的作用域要对两个函数都可见。
例二是同一个对象的内部函数多次调用之间的互斥，所以只要保证该函数多次调用时共用的都是当前对象内部同一份通行证即可。例三是同一个类的所有对象在创建时都要互斥，所以必需保证这个类的所有对象构造时共用的时同一份通行证，从而通行证被声明为静态成员。
这里所说的“通行证”在多线程编程中对应一个专门的术语mutex，由“mutual exclusion”拼接而来。为什么不直接用“锁”的概念呢？因为“锁”并不能很好的表达互斥的含义。锁是指一定条件下不允许当前代码段执行的概念。如上述例二或例三，不允许多个线程同时执行同一函数，这时说这个函数被锁定是很形象。但在例一中，A函数被锁定，为什么B函数不能执行呢？这就较难理解了。
而且经常有人感到疑惑，为什么“加锁后，被锁定的关键域只能串行执行”。这个其实是指在各自的时间轴上，并行的控制流在经过互斥执行的代码段时，必需以先后顺序串行执行。在今后的介绍中，mutex的申请，用acquire()操作表示，mutex的归还，用release()表示。舍弃lock(), unlock()的表示。
为了深入理解，先来看一段使用忙等待实现互斥的代码，用的是系统内核中使用较多的“spin lock”互斥方法。
例4．忙等待实现互斥
//声明为volatile，防止被编译器优化。
volatile bool dataProcessNotDone = true;
int criticalData = 0;
unsigned threadFuncA( void* para )
{
//如果编译器不支持volatile关键字，
//打开优化选项时，此句可能直接变成死循环。
while (dataProcessNotDone); // spin lock,锁定的是后续数据
//被锁定的代码区
printf("critical data is %d\n", CriticalData);
return 0;
}
unsigned threadFuncB( void* para )
{
sleep(1000);
criticalData++;
dataProcessNotDone = false; //修改互斥变量
return 0;
}
在高级语言中，利用spin lock实现复杂互斥条件非常困难，单单处理竞争条件就令人望而生畏。Spin lock在每次等待解锁的时间都很短时，具有无需线程切换，无需再调度等独特优势。但是在绝大多数应用中，由于互斥等待时间不确定（可能很长），多个线程等待spin lock解锁的过程中，spinning的行为可能导致系统处于半瘫痪状态，会严重影响程序性能。
除了忙等待之外，很多操作系统或线程库都提供了互斥原语来实现互斥。如果有可能，应当尽量使用系统提供的接口实现互斥。否则，要考虑编译器优化中的常量代入，语句执行顺序重排，cpu指令序列优化等依赖于具体软硬件环境的复杂问题（关键是这样的付出没有太大意义）。
下面根据上述概念，抽象出互斥类的概念，定义如下Mutex类接口
互斥类接口定义
文件mutex.h
#ifndef __MUTEX_H__
#define __MUTEX_H__
// C++标准中以_或__开头的名字不符合标准，
// 这一特点可以让这样定义的宏不会错误覆盖其他名字。
class Mutex
{
public:
Mutex();
~Mutex();
bool acquire (bool block = true);
void release();
private:
//依赖于具体实现，后面再说。
};
#endif
其中，Mutex::acquire()，获取互斥量，有阻塞和非阻塞两种调用方式，阻塞方式，获取互斥量失败时线程休眠。非阻塞方式下，获取失败时直接返回。Mutex::release()，释放互斥量。
示例程序
下面的例子说明了如何实现多线程环境下的Singleton模式。
文件Singleton.h：
#ifndef __SINGLETON_H__
#define __SINGLETON_H__
#include <stdio.h>
#include "thread.h"
#include "mutex.h"
// Dummy class.
class Helper {};
// A wrapper class for Mutex class
// It is exception safe.
class Guard
{
public:
Guard(Mutex & lock):mutex(lock)
{
mutex.acquire();
}
~Guard()
{
mutex.release();
}
private:
Mutex & mutex;
};
// Correct but possibly expensive multithreaded version
class Singleton1
{
public:
Helper * getInstance() {
Guard guard(mutex);
if (helper == NULL)
{
helper = new Helper();
}
return helper;
}
private:
static Mutex mutex;
static Helper * helper;
};
// Broken multithreaded version
// "Double-Checked Locking" idiom
class Singleton2
{
public:
Helper * getInstance() {
if (helper == NULL)
{
Guard guard(mutex);
if (helper == NULL)
{
helper = new Helper();
}
}
return helper;
}
private:
static Mutex mutex;
static Helper * helper;
};
//Thread class for test.
template
class TestThread: public Thread
{
public:
TestThread(T & resource, Helper *& res, Helper *&
res2Cmp)
:singleton(resource), instance(res), instance2Cmp(res2Cmp) {}
protected:
void * run (void *)
{
for (int i=0; i<100000; i++)
{
instance = singleton.getInstance();
if (instance != instance2Cmp
&& instance != NULL
&&instance2Cmp != NULL
)
{
printf("Fail! %p << %p.\n", instance, instance2Cmp);
}
}
return NULL;
}
private:
T & singleton;
Helper * & instance;
Helper * & instance2Cmp;
};
#endif
文件main.cpp
#include <stdio.h>
#include "singleton.h"
#define SINGLETON Singleton1
Mutex SINGLETON::mutex;
Helper * SINGLETON::helper = NULL;
int main(int argc, char** argv)
{
Helper * instance1= NULL;
Helper * instance2 = NULL;
SINGLETON singleton;
TestThread<singleton> thread1(singleton, instance1, instance2);
TestThread<singleton> thread2(singleton, instance2, instance1);
thread1.start();
thread2.start();
thread1.wait();
thread2.wait();
printf("Finished!\n");
return 0;
}
对此示例程序，说明如下几点。
1．定义了一个新的Guard类，这样做的好处是做到异常安全。比如：
try
{
Mutex mutex;
mutex.acquire();
// Some operations
if (errorHappened)
throw Exception();
mutex.release();
}
catch (Exception & e)
{
// Print error message;
}
这段代码中，抛出异常时，互斥量不能释放，容易造成死锁。使用Guard类重写，可以实现异常安全：
try
{
Mutex mutex;
Guard guard(mutex);
// Some operations
if (errorHappened)
throw Exception();
}
catch (Exception & e)
{
// Print error message;
}
2.Singleton1的实现可以确保多线程安全。但它是一个低效实现。假如有100次访问，只有1次会修改instance指针，其余99次都是只读操作。但是每次访问都需要进行互斥量的获取和释放操作。
取决于系统实现方式，互斥操作可能比整型变量的++操作慢一个数量级。有的实现提供的mutex其实是进程级别的互斥，一次互斥操作，会进入内核态，然后再返回用户态。而有的线程库提供的是Process local mutex，要稍快一些。但无论那种实现，代价都较大。
因此，为了改进Singleton1的实现效率，"Double-Checked Locking" idiom被提了出来。其思路是如果instance指针为空再进入互斥操作。由于获取互斥量过程中，可能别的线程已经将instance指针赋值，所以需要在获得互斥量所有权之后，再次检查instance指针值。这就是所谓”double check”中double的来历。
Double check的设计很聪明，但可惜无论在C++中还是在Java中，这么做其实都不能保证线程安全。考虑如下序列：
Step1. 线程A检查instance指针，发现其为空。获取互斥量成功，运行至语句helper = new Helper();
在打开优化选项时，这个语句在优化后可能变成2步子操作, 而且编译器自动调整了原语句的执行顺序（reordering）：
1) 分配内存，将地址赋值给helper变量。此时helper值非空。
2) 开始初始化此内存。
在运行完子语句1后，线程发生切换，此时内存尚未初始化。
Step2. 线程B检查instance指针，发现其非空。对instance所指对象进行进一步操作，由于此时对象是初始化还未完成无效数据，程序崩溃。
那么如何实现安全的double check呢？vc2005以后的版本，以及java 1.6以后的版本中，可以通过为helper加上volatile限定符，防止编译优化时调整指令执行顺序。最新的g++对volatile如何处理，没有查到相关资料。不过在C++中，只要本地汇编支持memoryBarrier指令，也可以通过在C++代码中内嵌汇编指令实现线程安全。在此不再详细讨论。
除此之外，instance类型是否是基本类型，是否多核环境，都对不安全的double check版本运行结果有微妙影响。
3．无论编译器如何实现，无论硬件环境如何，即使它最慢，也应该尽量使用系统提供的互斥原语。只有它是能够确保安全的。通过系统接口实现互斥，可以避免考虑编译优化等复杂情况。一种观点说volatile可以确保上述double check有效，但是intel有技术人员专门从硬件的角度批驳了这个说法，他告诉大家，即使编译器不做这个reordering, 处理器也可能在指令级别做。唯一能确保安全的，还是由系统实现的互斥接口。（照此说法，MS 和 Intel结成wintel联盟还是必要的，呵呵）双方说法似乎都一样权威时，作为程序开发者，很难取舍，因此在此类问题上还
是应该适当保守。
4．Mutex, volatile变量，普通变量在使用中的具体效率对比，是一个非常复杂的问题。涉及到内存，缓存，寄存器之间各种情况的同步问题。不过大家可以针对一些简单的例子，测试一下执行时间上的差异。
Unix实现
下面是借助pthread的Mutex类实现。
文件Mutex.h
#ifndef __MUTEX_H__
#define __MUTEX_H__
#include <pthread.h>
class Mutex
{
public:
Mutex();
virtual ~Mutex();
virtual bool acquire (bool block = true);
virtual void release();
private:
pthread_mutex_t handle;
};
#endif
文件 Mutex.cpp
#include "mutex.h"
Mutex::Mutex()
{
pthread_mutex_init(&handle, NULL);
}
Mutex::~Mutex()
{
pthread_mutex_destroy(&handle);
}
bool Mutex::acquire(bool block)
{
if (block)
{
return pthread_mutex_lock(&handle) == 0;
}
else
{
return pthread_mutex_trylock(&handle) == 0;
}
}
void Mutex::release()
{
ReleaseMutex(handle);
}
Windows实现
文件mutex.h
#ifndef __MUTEX_H__
#define __MUTEX_H__
#include <windows.h>
class Mutex
{
public:
Mutex();
virtual ~Mutex();
virtual bool acquire (bool block = true);
virtual void release();
private:
HANDLE handle;
};
#endif
文件mutex.cpp
#include "mutex.h"
Mutex::Mutex()
{
handle = CreateMutex(NULL, false, NULL);
}
Mutex::~Mutex()
{
CloseHandle(handle);
}
bool Mutex::acquire(bool block)
{
//Use caution when calling the wait functions
//and code that directly or indirectly creates windows.
return WaitForSingleObject(handle, block ? INFINITE : 0) ==
WAIT_OBJECT_0;
}
void Mutex::release()
{
ReleaseMutex(handle);
}
小结
本节从控制流的角度进一步介绍了什么是多线程执行中的并发，在此基础上介绍了主动对象的概念。在多线程编程中，需要考虑线程协作的地方，如果执行顺序理不清，为每一个线程画一条时间轴，标出各自时序，对分析问题往往能有帮助。
本节也介绍了多线程设计的一个基本思想，就是主动对象要具有一定的独立性，和其他线程的交互尽量只通过进程环境、系统或线程库提供的同步原语实现。
为什么要互斥，这个基本问题不能透彻理解的话，锁的概念很容易把自己弄糊涂。互斥的粒度大小也就根本无法谈起。
互斥的效率问题，在实际设计中是一个值得考虑的问题。但是程序的正确性问题是一个更重要的问题。不能保证正确性，就不要用。保证正确性到实现高效性的过程，类似于学会走路到能够飞奔的过程。对于初学者来说，欲速则不达。
为了对互斥量的使用，“通行证”所有权的转换，以及不同系统中Mutex的实现效率等有一个充分的感性认识，大家请多动手实现才能真正有所收益，最终超越我本人的一己知见。
最后，欢迎提出各种意见，以便这个系列能够错误少一些，解释准确一些，帮助也更大一些。
标 题: C++多线程入门（一）
发信站: 水木社区 (Wed Oct 8 01:10:23 2008), 站内
第1节 背景
为了更好的理解多线程的概念，先对进程，线程的概念背景做一下简单介绍。
早期的计算机系统都只允许一个程序独占系统资源，一次只能执行一个程序。在大型机年代，计算能力是一种宝贵资源。对于资源拥有方来说，最好的生财之道自然是将同一资源同时租售给尽可能多的用户。最理想的情况是垄断全球计算市场。所以不难理解为何当年IBM预测“全球只要有4台计算机就够了”。
这种背景下，一个计算机能够支持多个程序并发执行的需求变得十分迫切。由此产生了进程的概念。进程在多数早期多任务操作系统中是执行工作的基本单元。进程是包含程序指令和相关资源的集合。每个进程和其他进程一起参与调度，竞争CPU，内存等系统资源。每次进程切换，都存在进程资源的保存和恢复动作，这称为上下文切换。
进程的引入可以解决支持多用户的问题，但是多进程系统也在如下方面产生了新的问题：
? 进程频繁切换引起的额外开销可能会严重影响系统性能。
? 进程间通信要求复杂的系统级实现。
在程序功能日趋复杂的情况下，上述缺陷也就凸现出来。比如，一个简单的GUI程序，为了有更好的交互性，通常用一个任务支持界面交互，另一个任务支持后台运算。如果每个任务均由一个进程来实现，那会相当低效。对每个进程来说，系统资源看上去都是其独占的。比如内存空间，每个进程认为自己的内存空间是独有的。一次切换，这些独立资源都需要切换。
由此就演化出了利用分配给同一个进程的资源，尽量实现多个任务的方法。这也就引入了线程的概念。同一个进程内部的多个线程，共享的是同一个进程的所有资源。
比如，与每个进程独有自己的内存空间不同，同属一个进程的多个线程共享该进程的内存空间。例如在进程地址空间中有一个全局变量globalVar，若A线程将其赋值为1，则另一线程B可以看到该变量值为1。两个线程看到的全局变量globalVar是同一个变量。
通过线程可以支持同一个应用程序内部的并发，免去了进程频繁切换的开销，另外并发任务间通信也更简单。
目前多线程应用主要用于两大领域：网络应用和嵌入式应用。为什么在这两个领域应用较多呢？因为多线程应用能够解决两大问题：
? 并发。网络程序具有天生的并发性。比如网络数据库可能需要同时处理数以千计的请求。而由于网络连接的时延不确定性和不可靠性，一旦等待一次网络交互，可以让当前线程进入睡眠，退出调度，处理其他线程。这样就能够有效利用系统资源，充分发挥系统处理能力。
? 实时。线程的切换是轻量级的，所以可以保证足够快。每当有事件发生，状态改变，都能有线程及时响应，而且每次线程内部处理的计算强度和复杂度都不大。在这种情况下，多线程实现的模型也是高效的。
在有些语言中，对多线程或者并发的支持是直接内建在语言中的，比如Ada和VHDL。在C++里面，对多线程的支持由具体操作系统提供的函数接口支持。不同的系统中具体实现方法不同。后面所有例子只给出windows和Unix/Linux的实现。
在后面的实现中，考虑的是尽量封装隔离底层的多线程函数接口，屏蔽操作系统底层的线程实现具体细节，介绍的重点是多线程编程中较通用的概念。同时也尽量体现C++面向对象的一面。
最后，由于空闲时间有限，我只求示例代码能够明确表达自己的意思即可。至于代码的尽善尽美就只能有劳各位尽力以为之了。
?
第2节 线程的创建
本节介绍如下内容
? 线程状态
? 线程运行环境
? 线程类定义
? 示例程序
? 线程类的Windows和Unix实现
线程状态
在一个线程的生存期内，可以在多种状态之间转换。不同操作系统可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态。但大体说来，如下几种状态是通用的：
? 就绪：参与调度，等待被执行。一旦被调度选中，立即开始执行。
? 运行：占用CPU，正在运行中。
? 休眠：暂不参与调度，等待特定事件发生。
? 中止：已经运行完毕，等待回收线程资源（要注意，这个很容易误解，后面解释）。
线程环境
线程存在于进程之中。进程内所有全局资源对于内部每个线程均是可见的。
进程内典型全局资源有如下几种：
? 代码区。这意味着当前进程空间内所有可见的函数代码，对于每个线程来说也是可见的。
? 静态存储区。全局变量。静态变量。
? 动态存储区。也就是堆空间。
线程内典型的局部资源有：
? 本地栈空间。存放本线程的函数调用栈，函数内部的局部变量等。
? 部分寄存器变量。例如本线程下一步要执行代码的指针偏移量。
一个进程发起之后，会首先生成一个缺省的线程，通常称这个线程为主线程。C/C++程序中主线程就是通过main函数进入的线程。由主线程衍生的线程称为从线程，从线程也可以有自己的入口函数，作用相当于主线程的main函数。
这个函数由用户指定。Pthread和winapi中都是通过传入函数指针实现。在指定线程入口函数时，也可以指定入口函数的参数。就像main函数有固定的格式要求一样，线程的入口函数一般也有固定的格式要求，参数通常都是void *类型，返回类型在pthread中是void *, winapi中是unsigned int，而且都需要是全局函数。
最常见的线程模型中，除主线程较为特殊之外，其他线程一旦被创建，相互之间就是对等关系 (peer to peer)， 不存在隐含的层次关系。每个进程可以创建的最大线程数由具体实现决定。
为了更好的理解上述概念，下面通过具体代码来详细说明。
线程类接口定义
一个线程类无论具体执行什么任务，其基本的共性无非就是
? 创建并启动线程
? 停止线程
? 另外还有就是能睡，能等，能分离执行（有点拗口，后面再解释）。
? 还有其他的可以继续加…
将线程的概念加以抽象，可以为其定义如下的类：
文件 thread.h
#ifndef __THREAD__H_
#define __THREAD__H_
class Thread
{
public:
Thread();
virtual ~Thread();
int start (void * = NULL);
void stop();
void sleep (int);
void detach();
void * wait();
protected:
virtual void * run(void *) = 0;
private:
//这部分win和unix略有不同，先不定义，后面再分别实现。
//顺便提一下，我很不习惯写中文注释，这里为了更明白一
//点还是选用中文。
…
};
#endif
Thread::start()函数是线程启动函数，其输入参数是无类型指针。
Thread::stop()函数中止当前线程。
Thread::sleep()函数让当前线程休眠给定时间，单位为秒。
Thread::run()函数是用于实现线程类的线程函数调用。
Thread::detach()和thread::wait()函数涉及的概念略复杂一些。在稍后再做解释。
Thread类是一个虚基类，派生类可以重载自己的线程函数。下面是一个例子。
示例程序
代码写的都不够精致，暴力类型转换比较多，欢迎有闲阶级美化，谢过了先。
文件create.h
#ifndef __CREATOR__H_
#define __CREATOR__H_
#include <stdio.h>
#include "thread.h"
class Create: public Thread
{
protected:
void * run(void * param)
{
char * msg = (char*) param;
printf ("%s\n", msg);
//sleep(100); 可以试着取消这行注释，看看结果有什么不同。
printf("One day past.\n");
return NULL;
}
};
#endif
然后，实现一个main函数，来看看具体效果：
文件Genesis.cpp
#include <stdio.h>
#include "create.h"
int main(int argc, char** argv)
{
Create monday;
Create tuesday;
printf("At the first God made the heaven and the earth.\n");
monday.start("Naming the light, Day, and the dark, Night, the first day.");
tuesday.start("Gave the arch the name of Heaven, the second day.");
printf("These are the generations of the heaven and the earth.\n");
return 0;
}
编译运行，程序输出如下：
At the first God made the heaven and the earth.
These are the generations of the heaven and the earth.
令人惊奇的是，由周一和周二对象创建的子线程似乎并没有执行！这是为什么呢？别急，在最后的printf语句之前加上如下语句：
monday.wait();
tuesday.wait();
重新编译运行，新的输出如下：
At the first God made the heaven and the earth.
Naming the light, Day, and the dark, Night, the first day.
One day past.
Gave the arch the name of Heaven, the second day.
One day past.
These are the generations of the heaven and the earth.
为了说明这个问题，需要了解前面没有解释的Thread::detach()和Thread::wait()两个函数的含义。
无论在windows中，还是Posix中，主线程和子线程的默认关系是：
无论子线程执行完毕与否，一旦主线程执行完毕退出，所有子线程执行都会终止。这时整个进程结束或僵死（部分线程保持一种终止执行但还未销毁的状态，而进程必须在其所有线程销毁后销毁，这时进程处于僵死状态），在第一个例子的输出中，可以看到子线程还来不及执行完毕，主线程的main()函数就已经执行完毕，从而所有子线程终止。
需要强调的是，线程函数执行完毕退出，或以其他非常方式终止，线程进入终止态（请回顾上面说的线程状态），但千万要记住的是，进入终止态后，为线程分配的系统资源并不一定已经释放，而且可能在系统重启之前，一直都不能释放。终止态的线程，仍旧作为一个线程实体存在与操作系统中。（这点在win和unix中是一致的。）而什么时候销毁线程，取决于线程属性。
通常，这种终止方式并非我们所期望的结果，而且一个潜在的问题是未执行完就终止的子线程，除了作为线程实体占用系统资源之外，其线程函数所拥有的资源（申请的动态内存，打开的文件，打开的网络端口等）也不一定能释放。所以，针对这个问题，主线程和子线程之间通常定义两种关系：
? 可会合(joinable)。这种关系下，主线程需要明确执行等待操作。在子线程结束后，主线程的等待操作执行完毕，子线程和主线程会合。这时主线程继续执行等待操作之后的下一步操作。主线程必须会合可会合的子线程，Thread类中，这个操作通过在主线程的线程函数内部调用子线程对象的wait()函数实现。这也就是上面加上三个wait()调用后显示正确的原因。必须强调的是，即使子线程能够在主线程之前执行完毕，进入终止态，也必需显示执行会合操作，否则，系统永远不会主动销毁线程，分配给该线程的系统资源（线程id或句柄，线程管理相关的系统资源）也永远不会释放。
? 相分离(detached)。顾名思义，这表示子线程无需和主线程会合，也就是相分离的。这种情况下，子线程一旦进入终止态，系统立即销毁线程，回收资源。无需在主线程内调用wait()实现会合。Thread类中，调用detach()使线程进入detached状态。这种方式常用在线程数较多的情况，有时让主线程逐个等待子线程结束，或者让主线程安排每个子线程结束的等待顺序，是很困难或者不可能的。所以在并发子线程较多的情况下，这种方式也会经常使用。
缺省情况下，创建的线程都是可会合的。可会合的线程可以通过调用detach()方法变成相分离的线程。但反向则不行。
UNIX实现
文件 thread.h
#ifndef __THREAD__H_
#define __THREAD__H_
class Thread
{
public:
Thread();
virtual ~Thread();
int start (void * = NULL);
void stop();
void sleep (int);
void detach();
void * wait();
protected:
virtual void * run(void *) = 0;
private:
pthread_t handle;
bool started;
bool detached;
void * threadFuncParam;
friend void * threadFunc(void *);
};
//pthread中线程函数必须是一个全局函数，为了解决这个问题
//将其声明为静态，以防止此文件之外的代码直接调用这个函数。
//此处实现采用了称为Virtual friend function idiom 的方法。
Static void * threadFunc(void *);
#endif
文件thread.cpp
#include <pthread.h>
#include <sys/time.h>
#include “thread.h”
static void * threadFunc (void * threadObject)
{
Thread * thread = (Thread *) threadObject;
return thread->run(thread->threadFuncParam);
}
Thread::Thread()
{
started = detached = false;
}
Thread::~Thread()
{
stop();
}
bool Thread::start(void * param)
{
pthread_attr_t attributes;
pthread_attr_init(&attributes);
if (detached)
{
pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
}
threadFuncParam = param;
if (pthread_create(&handle, &attributes, threadFunc, this) == 0)
{
started = true;
}
pthread_attr_destroy(&attribute);
}
void Thread::detach()
{
if (started && !detached)
{
pthread_detach(handle);
}
detached = true;
}
void * Thread::wait()
{
void * status = NULL;
if (started && !detached)
{
pthread_join(handle, &status);
}
return status;
}
void Thread::stop()
{
if (started && !detached)
{
pthread_cancel(handle);
pthread_detach(handle);
detached = true;
}
}
void Thread::sleep(unsigned int milliSeconds)
{
timeval timeout = { milliSeconds/1000, millisecond%1000};
select(0, NULL, NULL, NULL, &timeout);
}
Windows实现
文件thread.h
#ifndef _THREAD_SPECIFICAL_H__
#define _THREAD_SPECIFICAL_H__
#include <windows.h>
static unsigned int __stdcall threadFunction(void *);
class Thread {
friend unsigned int __stdcall threadFunction(void *);
public:
Thread();
virtual ~Thread();
int start(void * = NULL);
void * wait();
void stop();
void detach();
static void sleep(unsigned int);
protected:
virtual void * run(void *) = 0;
private:
HANDLE threadHandle;
bool started;
bool detached;
void * param;
unsigned int threadID;
};
#endif
文件thread.cpp
#include "stdafx.h"
#include <process.h>
#include "thread.h"
unsigned int __stdcall threadFunction(void * object)
{
Thread * thread = (Thread *) object;
return (unsigned int ) thread->run(thread->param);
}
Thread::Thread()
{
started = false;
detached = false;
}
Thread::~Thread()
{
stop();
}
int Thread::start(void* pra)
{
if (!started)
{
param = pra;
if (threadHandle = (HANDLE)_beginthreadex(NULL, 0, threadFunction, this, 0, &threadID))
{
if (detached)
{
CloseHandle(threadHandle);
}
started = true;
}
}
return started;
}
//wait for current thread to end.
void * Thread::wait()
{
DWORD status = (DWORD) NULL;
if (started && !detached)
{
WaitForSingleObject(threadHandle, INFINITE);
GetExitCodeThread(threadHandle, &status);
CloseHandle(threadHandle);
detached = true;
}
return (void *)status;
}
void Thread::detach()
{
if (started && !detached)
{
CloseHandle(threadHandle);
}
detached = true;
}
void Thread::stop()
{
if (started && !detached)
{
TerminateThread(threadHandle, 0);
//Closing a thread handle does not terminate
//the associated thread.
//To remove a thread object, you must terminate the thread,
//then close all handles to the thread.
//The thread object remains in the system until
//the thread has terminated and all handles to it have been
//closed through a call to CloseHandle
CloseHandle(threadHandle);
detached = true;
}
}
void Thread::sleep(unsigned int delay)
{
::Sleep(delay);
}
小结
本节的主要目的是帮助入门者建立基本的线程概念，以此为基础，抽象出一个最小接口的通用线程类。在示例程序部分，初学者可以体会到并行和串行程序执行的差异。有兴趣的话，大家可以在现有线程类的基础上，做进一步的扩展和尝试。如果觉得对线程的概念需要进一步细化，大家可以进一步扩展和完善现有Thread类。
想更进一步了解的话，一个建议是，可以去看看其他语言，其他平台的线程库中，线程类抽象了哪些概念。比如Java, perl等跨平台语言中是如何定义的，微软从winapi到dotnet中是如何支持多线程的，其线程类是如何定义的。这样有助于更好的理解线程的模型和基础概念。
另外，也鼓励大家多动手写写代码，在此基础上尝试写一些代码，也会有助于更好的理解多线程程序的特点。比如，先开始的线程不一定先结束。线程的执行可能会交替进行。把printf替换为cout可能会有新的发现，等等。
每个子线程一旦被创建，就被赋予了自己的生命。管理不好的话，一只特例独行的猪是非常让人头痛的。
对于初学者而言，编写多线程程序可能会遇到很多令人手足无措的bug。往往还没到考虑效率，避免死锁等阶段就问题百出，而且很难理解和调试。这是非常正常的，请不要气馁，后续文章会尽量解释各种常见问题的原因，引导大家避免常见错误。目前能想到入门阶段常遇到的问题是：
? 内存泄漏，系统资源泄漏。
? 程序执行结果混乱，但是在某些点插入sleep语句后结果又正确了。
? 程序crash, 但移除或添加部分无关语句后，整个程序正常运行（假相）。
? 多线程程序执行结果完全不合逻辑，出于预期。
本文至此，如果自己动手改改，试一些例子，对多线程程序应该多少有一些感性认识了。刚开始只要把基本概念弄懂了，后面可以一步一步搭建出很复杂的类。不过刚开始不要贪多，否则会欲速则不达，越弄越糊涂。
最后，大家见仁见智吧，我在此起到抛砖引玉的作用就很开心了，呵呵。另外文本编辑器的原因，代码如果编译不过，可能需要把标点符号从中文换成英文。
第三节 线程互斥
本节介绍如下内容
? 主动对象
? 调度与原子操作
? 竞争条件和数据一致性
? 为何需要互斥
? 互斥类接口定义
? 示例程序
? 互斥类的Unix和Windows实现
主动对象(Active Object)
第二节介绍Thread类的时候曾经提到，每个子线程一旦被创建，就被赋予了自己的生命。当一个线程类创建并启动之后，它将会以自己的步调主动执行其独立线程，它和其他线程（包括主线程）的执行是并行关系。
为了详细说明这个问题，先介绍一下什么是控制流(control flow)。计算机科学中，控制流指指令式(imperative)或函数式(functional)编程语言中语句、指令、函数调用的执行（或求值）序列。
单线程程序中，控制流始终是一线串珠，一旦控制流达到某个对象，由程序主动调用对象函数，在函数执行完毕后，控制流返回主程序继续执行。对于被访问对象来说，访问、修改、成员函数调用都是一个被动的过程，此过程受控于该程序的控制流。所以，称单线程程序的对象为被动对象(Passive Object)。
与被动对象相对应的是主动对象。主动对象和被动对象的区别在于，主动对象可以发起自己的线程，创建新的执行序列，产生独立于主线程的控制流分支。简而言之，主动对象可以独立于主线程，自主制定自己的控制流。如果愿意，你可以实现一个和主线程没有任何协调关系，天马行空式的独立线程。当然，这样的线程往往也意味着毫无用处（娱乐作用除外）。
调度和原子操作
从理论模型上说，多线程环境中，线程之间是独立、对等关系。一个线程完全可以无视其他线程的存在。但实际多线程执行环境中，线程数往往远大于CPU数量。为了共享和分配资源，线程必需遵守一定规则，进行必要的协调。操作系统中具体的规则执行者是调度程序。因此，要想掌握多线程编程，就必需了解线程调度的基本概念和特点。在此基础上，才能了解为什么需要在线程之间进行协调，进而才能透彻理解如何协调多线程的并发执行。
现代操作系统中，存在许多不同的线程调度模型，这些调度模型的基本共同点就是线程执行顺序具有随机性和不确定性。调度模型既无法事先知道某一时刻会存在多少线程，也无法知道哪个线程会正在运行，甚至也不知道某个线程确切会到什么时刻执行结束，更不用说预先安排在特定时刻执行特定线程的特定语句。
前面提到，控制流就是语句，指令或函数调用的顺序序列。反映到时间轴上，就是一系列离散分布的执行序列。线程调度作用于多个控制流的客观效果，就是多个控制流按同一条时间轴排列时，是一个近似随机的执行序列；按每个控制流各自的时间轴排列时，则是一个具有先后顺序的执行序列。
在具体的程序执行上，这个特点就表现为线程A的一个语句执行完毕后，紧接着执行的可能是另一个线程B的一个语句。甚至可能是线程A的一个语句还没有执行完毕，就接着执行线程B的语句。
对于后一点不用感到奇怪。因为操作系统中，调度程序作为系统底层实现的一部分，参与调度的操作指令可能比高级编程语言的基本语句要底层的多。同一个调度程序，其调度的众多线程可能由多种高级语言编写，所以调度程序基本上不可能以某种高级编程语言的单条语句为单位安排执行序列。
通常，一条高级语言语句可能对应多条汇编指令，而一条汇编指令可能对应多条CPU微码指令。而一条微码指令，则可能对应逻辑电路的一个具体电路逻辑。顺便提一下，这也是Verilog, VHDL等高级语言能够综合出具体的逻辑电路的基本原理。所不同的是，高级语言编译器编译的最终单位是汇编，而硬件描述语言综合的最终单位是和微码对应的电路器件单元（集成电路前端设计的内容。记得以前暑期实习，我窝在学校做的就是这么一个元件库，做的很不像样子居然还得到了一定的肯定，多年后想起来还是汗颜）。
至于系统调度程序具体会定义怎样的原子操作集合，会以什么粒度的指令为调度基本单位，这就是系统设计者各显神通的地方了。个人认为，作为高级语言的编程者，记住什么操作是原子操作意义并不明显。大多数场合，只要认为，多线程的控制流在同一条时间轴上看来是完全随机的就可以了。要记住，墨菲定律生效的时候，看似不可能的事情都能成为现实。
多线程程序设计中，一种朴素的设计思想是将线程具体化为主动对象，主动对象之间通过共享环境（全局资源）来维护当前应用的运行状态；主动对象间通过一套约定的互斥和同步规则来实现通信；线程的具体执行时序则由调度程序安排。主动对象之间，应尽量避免一个主动对象直接调用另一个主动对象的内部方法（例如suspend, stop, exit）直接控制另一个线程的执行步调。主动对象的行为应该完全由其本身控制，和其他主动对象的交互尽量只通过环境以及同步语句来实现。
实际实现中，如果多个主动对象都可以直接调用某个主动对象的stop方法终止其运行，这个程序是非常脆弱的，因为在调度程序之外，不借助同步机制，主观假定线程执行时序，人为更改线程执行状态是非常不明智的。即使这样的程序可用，对于维护者来说其难度也不亚于维护goto语句。
这也就是前一篇文章所定义线程类中detach, start, stop没有加锁的原因，因为并不希望在多个线程中调用同一个线程对象的这些方法。
竞争条件和数据一致性
共享环境是进程全局资源的同义词。在多线程并发执行中，最常遇到的问题就是共享环境被污染。具体体现就是全局数据被破坏，全局文件内容被破坏 … 。
例如：
有一个64位全局变量long globalVar = 0;主动对象A想把它置为0x000A000B000C000D；假设这个操作分两步执行，先将高32位置为000A000B，再把低32位置为000C000D。但不巧的是，对象A刚刚将高位置位，调度程序安排另一主动对象B执行。这时，全局变量globalVar内部的值是一个非法值，它是无意义的。在B拿着这个值做进一步处理时，得出的也是错误结果。这时，称为数据的一致性被破坏。
线程调度的不确定性也可能导致程序执行结果的不确定性。有时候这种不确定性会导致程序得到错误的运行结果。
例如：
为了对Thread类所生成的对象总数计数，定义一个全局变量Unsigned int counter = 0; 在Thread类的构造函数中，执行++counter。现在假设有2个Thread对象objA和objB并发运行，考虑如下两个场景：
Scenario1.操作序列如下：
1. counter = 0;
2. objA将counter值0从内存读入寄存器A；
3. objA将寄存器A值加1；
4. objA将寄存器A值写回内存，counter值为1；
5. objB将counter值1从内存读入寄存器B；
6. objB将寄存器B值加1；
7. objA将寄存器B值写回内存，counter值为2；
8. 最终counter值为2。
Scenario2.操作序列如下：
1. counter = 0;
2. objA将counter值0从内存读入寄存器A；
3. objB将counter值0从内存读入寄存器B
4. objA将寄存器A值加1；
5. objB将寄存器B值加1；
6. objA将寄存器A值写回内存，counter值为1；
7. objA将寄存器B值写回内存，counter值为1；
8. 最终counter值为1。
场景1的结果是设计的本意，场景2的结果对我们而言是错误的。
一个线程的执行结果正确性取决于于其他线程执行时序的条件，称为竞争条件。中文这样翻译不伦不类，但从英文字面理解非常容易。Race一般是计时赛，某位选手跑得快一点，竞赛结果就有变化，最终结果由race condition决定，还是非常形象的。
为何需要互斥
线程间协作问题，通常可以归为互斥和同步两类。其中互斥又主要解决两类问题：维护数据一致性、避免竞争条件的出现。
解决一致性问题，通俗说就是，修改数据的线程通告其他线程“我正在修改你要访问的对象X，操作过程中不能保证这个数据的有效性，请不要使用此对象”。
避免竞争条件，通俗说就是，某线程通告其他线程“我将要进行涉及某对象的一系列操作A，在我未完成这一系列操作之前，如果有人和我同时执行涉及此对象的操作序列B（B也可能就是A），将会影响我执行结果的正确性，请不要进行涉及此对象的操作”。
这种操作序列A有时候也被称为“原子性操作”，因为它不允许操作序列B在时间轴上和它交叉分布，必需保证在时间轴上看来，操作序列A是一个不可分割的整体。（物理学早期，原子也被认为是不可分割的）。
以上冗长的解释，精简成一句话，就是“线程间需要互斥执行”。需要互斥的操作对应的代码也有一个很学术的名称－“关键域（或关键区）”。
那么如何实现互斥呢？一个简单的思路就是，设立一个权威仲裁者，给那些需要互斥执行的线程颁发一个共用的通行证。某个线程想要进入一个关键域执行，需要先申请可以进入该关键域的通行证，如果别的线程已经拿走了该通行证，则本线程等待，进入休眠状态，退出调度。如果本线程的通行证使用完毕，则应该将它归还给仲裁者，重新唤醒等待线程，参与调度，竞争此通行证。
比如，下列伪码中，threadFuncA和threadFuncB就需要申请同一张通行证：
例一：
int globalCounter = 0;
void threadFuncA (通行证类型 * 通行证)
{
获取通行证；
globalCounter++;
归还通行证；
}
Void threadFuncB (通行证类型 * 通行证)
{
获取通行证；
globalCounter *= 2;
归还通行证；
}
又比如，下列伪码中，需要为ResourceClass类的对象引用计数器制定一张通行证
。
例二：
class ResourceClass
{
public:
resource & reference()
{
获取通行证；
++refcounter;
printf(“当前对象被引用了%u次”, refCounter);
释放通行证；
}
private:
通行证类型 通行证；
unsigned int refCounter;
};
ResourceClass rescObj
Void threadFuncA()
{
rescObj-> reference();
}
Void threadFuncB()
{
rescObj-> reference();
}
最后一个例子，是为ResourceClass类的对象计数器制定一张通行证。
例三：
class ResourceClass
{
public:
ResourceClass ()
{
获取通行证；
++objcounter;
printf(“当前类创建了%u个对象”, objCounter);
释放通行证；
}
private:
static通行证类型 通行证；
unsigned int objCounter;
};
Void threadFuncA()
{
ResourceClass * rescObj = new ResourceClass ();
}
Void threadFuncB()
{
ResourceClass * rescObj = new ResourceClass ();
}
这三个例子中，例一是不同函数之间互斥，所以通行证的作用域要对两个函数都可见。
例二是同一个对象的内部函数多次调用之间的互斥，所以只要保证该函数多次调用时共用的都是当前对象内部同一份通行证即可。例三是同一个类的所有对象在创建时都要互斥，所以必需保证这个类的所有对象构造时共用的时同一份通行证，从而通行证被声明为静态成员。
这里所说的“通行证”在多线程编程中对应一个专门的术语mutex，由“mutual exclusion”拼接而来。为什么不直接用“锁”的概念呢？因为“锁”并不能很好的表达互斥的含义。锁是指一定条件下不允许当前代码段执行的概念。如上述例二或例三，不允许多个线程同时执行同一函数，这时说这个函数被锁定是很形象。但在例一中，A函数被锁定，为什么B函数不能执行呢？这就较难理解了。
而且经常有人感到疑惑，为什么“加锁后，被锁定的关键域只能串行执行”。这个其实是指在各自的时间轴上，并行的控制流在经过互斥执行的代码段时，必需以先后顺序串行执行。在今后的介绍中，mutex的申请，用acquire()操作表示，mutex的归还，用release()表示。舍弃lock(), unlock()的表示。
为了深入理解，先来看一段使用忙等待实现互斥的代码，用的是系统内核中使用较多的“spin lock”互斥方法。
例4．忙等待实现互斥
//声明为volatile，防止被编译器优化。
volatile bool dataProcessNotDone = true;
int criticalData = 0;
unsigned threadFuncA( void* para )
{
//如果编译器不支持volatile关键字，
//打开优化选项时，此句可能直接变成死循环。
while (dataProcessNotDone); // spin lock,锁定的是后续数据
//被锁定的代码区
printf("critical data is %d\n", CriticalData);
return 0;
}
unsigned threadFuncB( void* para )
{
sleep(1000);
criticalData++;
dataProcessNotDone = false; //修改互斥变量
return 0;
}
在高级语言中，利用spin lock实现复杂互斥条件非常困难，单单处理竞争条件就令人望而生畏。Spin lock在每次等待解锁的时间都很短时，具有无需线程切换，无需再调度等独特优势。但是在绝大多数应用中，由于互斥等待时间不确定（可能很长），多个线程等待spin lock解锁的过程中，spinning的行为可能导致系统处于半瘫痪状态，会严重影响程序性能。
除了忙等待之外，很多操作系统或线程库都提供了互斥原语来实现互斥。如果有可能，应当尽量使用系统提供的接口实现互斥。否则，要考虑编译器优化中的常量代入，语句执行顺序重排，cpu指令序列优化等依赖于具体软硬件环境的复杂问题（关键是这样的付出没有太大意义）。
下面根据上述概念，抽象出互斥类的概念，定义如下Mutex类接口
互斥类接口定义
文件mutex.h
#ifndef __MUTEX_H__
#define __MUTEX_H__
// C++标准中以_或__开头的名字不符合标准，
// 这一特点可以让这样定义的宏不会错误覆盖其他名字。
class Mutex
{
public:
Mutex();
~Mutex();
bool acquire (bool block = true);
void release();
private:
//依赖于具体实现，后面再说。
};
#endif
其中，Mutex::acquire()，获取互斥量，有阻塞和非阻塞两种调用方式，阻塞方式，获取互斥量失败时线程休眠。非阻塞方式下，获取失败时直接返回。Mutex::release()，释放互斥量。
示例程序
下面的例子说明了如何实现多线程环境下的Singleton模式。
文件Singleton.h：
#ifndef __SINGLETON_H__
#define __SINGLETON_H__
#include <stdio.h>
#include "thread.h"
#include "mutex.h"
// Dummy class.
class Helper {};
// A wrapper class for Mutex class
// It is exception safe.
class Guard
{
public:
Guard(Mutex & lock):mutex(lock)
{
mutex.acquire();
}
~Guard()
{
mutex.release();
}
private:
Mutex & mutex;
};
// Correct but possibly expensive multithreaded version
class Singleton1
{
public:
Helper * getInstance() {
Guard guard(mutex);
if (helper == NULL)
{
helper = new Helper();
}
return helper;
}
private:
static Mutex mutex;
static Helper * helper;
};
// Broken multithreaded version
// "Double-Checked Locking" idiom
class Singleton2
{
public:
Helper * getInstance() {
if (helper == NULL)
{
Guard guard(mutex);
if (helper == NULL)
{
helper = new Helper();
}
}
return helper;
}
private:
static Mutex mutex;
static Helper * helper;
};
//Thread class for test.
template
class TestThread: public Thread
{
public:
TestThread
res2Cmp)
:singleton(resource), instance(res), instance2Cmp(res2Cmp) {}
protected:
void * run (void *)
{
for (int i=0; i<100000; i++)
{
instance = singleton.getInstance();
if (instance != instance2Cmp
&& instance != NULL
&&instance2Cmp != NULL
)
{
printf("Fail! %p << %p.\n", instance, instance2Cmp);
}
}
return NULL;
}
private:
T & singleton;
Helper * & instance;
Helper * & instance2Cmp;
};
#endif
文件main.cpp
#include <stdio.h>
#include "singleton.h"
#define SINGLETON Singleton1
Mutex SINGLETON::mutex;
Helper * SINGLETON::helper = NULL;
int main(int argc, char** argv)
{
Helper * instance1= NULL;
Helper * instance2 = NULL;
SINGLETON singleton;
TestThread<singleton> thread1(singleton, instance1, instance2);
TestThread<singleton> thread2(singleton, instance2, instance1);
thread1.start();
thread2.start();
thread1.wait();
thread2.wait();
printf("Finished!\n");
return 0;
}
对此示例程序，说明如下几点。
1．定义了一个新的Guard类，这样做的好处是做到异常安全。比如：
try
{
Mutex mutex;
mutex.acquire();
// Some operations
if (errorHappened)
throw Exception();
mutex.release();
}
catch (Exception & e)
{
// Print error message;
}
这段代码中，抛出异常时，互斥量不能释放，容易造成死锁。使用Guard类重写，可以实现异常安全：
try
{
Mutex mutex;
Guard guard(mutex);
// Some operations
if (errorHappened)
throw Exception();
}
catch (Exception & e)
{
// Print error message;
}
2.Singleton1的实现可以确保多线程安全。但它是一个低效实现。假如有100次访问，只有1次会修改instance指针，其余99次都是只读操作。但是每次访问都需要进行互斥量的获取和释放操作。
取决于系统实现方式，互斥操作可能比整型变量的++操作慢一个数量级。有的实现提供的mutex其实是进程级别的互斥，一次互斥操作，会进入内核态，然后再返回用户态。而有的线程库提供的是Process local mutex，要稍快一些。但无论那种实现，代价都较大。
因此，为了改进Singleton1的实现效率，"Double-Checked Locking" idiom被提了出来。其思路是如果instance指针为空再进入互斥操作。由于获取互斥量过程中，可能别的线程已经将instance指针赋值，所以需要在获得互斥量所有权之后，再次检查instance指针值。这就是所谓”double check”中double的来历。
Double check的设计很聪明，但可惜无论在C++中还是在Java中，这么做其实都不能保证线程安全。考虑如下序列：
Step1. 线程A检查instance指针，发现其为空。获取互斥量成功，运行至语句helper = new Helper();
在打开优化选项时，这个语句在优化后可能变成2步子操作, 而且编译器自动调整了原语句的执行顺序（reordering）：
1) 分配内存，将地址赋值给helper变量。此时helper值非空。
2) 开始初始化此内存。
在运行完子语句1后，线程发生切换，此时内存尚未初始化。
Step2. 线程B检查instance指针，发现其非空。对instance所指对象进行进一步操作，由于此时对象是初始化还未完成无效数据，程序崩溃。
那么如何实现安全的double check呢？vc2005以后的版本，以及java 1.6以后的版本中，可以通过为helper加上volatile限定符，防止编译优化时调整指令执行顺序。最新的g++对volatile如何处理，没有查到相关资料。不过在C++中，只要本地汇编支持memoryBarrier指令，也可以通过在C++代码中内嵌汇编指令实现线程安全。在此不再详细讨论。
除此之外，instance类型是否是基本类型，是否多核环境，都对不安全的double check版本运行结果有微妙影响。
3．无论编译器如何实现，无论硬件环境如何，即使它最慢，也应该尽量使用系统提供的互斥原语。只有它是能够确保安全的。通过系统接口实现互斥，可以避免考虑编译优化等复杂情况。一种观点说volatile可以确保上述double check有效，但是intel有技术人员专门从硬件的角度批驳了这个说法，他告诉大家，即使编译器不做这个reordering, 处理器也可能在指令级别做。唯一能确保安全的，还是由系统实现的互斥接口。（照此说法，MS 和 Intel结成wintel联盟还是必要的，呵呵）双方说法似乎都一样权威时，作为程序开发者，很难取舍，因此在此类问题上还
是应该适当保守。
4．Mutex, volatile变量，普通变量在使用中的具体效率对比，是一个非常复杂的问题。涉及到内存，缓存，寄存器之间各种情况的同步问题。不过大家可以针对一些简单的例子，测试一下执行时间上的差异。
Unix实现
下面是借助pthread的Mutex类实现。
文件Mutex.h
#ifndef __MUTEX_H__
#define __MUTEX_H__
#include <pthread.h>
class Mutex
{
public:
Mutex();
virtual ~Mutex();
virtual bool acquire (bool block = true);
virtual void release();
private:
pthread_mutex_t handle;
};
#endif
文件 Mutex.cpp
#include "mutex.h"
Mutex::Mutex()
{
pthread_mutex_init(&handle, NULL);
}
Mutex::~Mutex()
{
pthread_mutex_destroy(&handle);
}
bool Mutex::acquire(bool block)
{
if (block)
{
return pthread_mutex_lock(&handle) == 0;
}
else
{
return pthread_mutex_trylock(&handle) == 0;
}
}
void Mutex::release()
{
ReleaseMutex(handle);
}
Windows实现
文件mutex.h
#ifndef __MUTEX_H__
#define __MUTEX_H__
#include <windows.h>
class Mutex
{
public:
Mutex();
virtual ~Mutex();
virtual bool acquire (bool block = true);
virtual void release();
private:
HANDLE handle;
};
#endif
文件mutex.cpp
#include "mutex.h"
Mutex::Mutex()
{
handle = CreateMutex(NULL, false, NULL);
}
Mutex::~Mutex()
{
CloseHandle(handle);
}
bool Mutex::acquire(bool block)
{
//Use caution when calling the wait functions
//and code that directly or indirectly creates windows.
return WaitForSingleObject(handle, block ? INFINITE : 0) ==
WAIT_OBJECT_0;
}
void Mutex::release()
{
ReleaseMutex(handle);
}
小结
本节从控制流的角度进一步介绍了什么是多线程执行中的并发，在此基础上介绍了主动对象的概念。在多线程编程中，需要考虑线程协作的地方，如果执行顺序理不清，为每一个线程画一条时间轴，标出各自时序，对分析问题往往能有帮助。
本节也介绍了多线程设计的一个基本思想，就是主动对象要具有一定的独立性，和其他线程的交互尽量只通过进程环境、系统或线程库提供的同步原语实现。
为什么要互斥，这个基本问题不能透彻理解的话，锁的概念很容易把自己弄糊涂。互斥的粒度大小也就根本无法谈起。
互斥的效率问题，在实际设计中是一个值得考虑的问题。但是程序的正确性问题是一个更重要的问题。不能保证正确性，就不要用。保证正确性到实现高效性的过程，类似于学会走路到能够飞奔的过程。对于初学者来说，欲速则不达。
为了对互斥量的使用，“通行证”所有权的转换，以及不同系统中Mutex的实现效率等有一个充分的感性认识，大家请多动手实现才能真正有所收益，最终超越我本人的一己知见。
最后，欢迎提出各种意见，以便这个系列能够错误少一些，解释准确一些，帮助也更大一些。
2008年10月19日星期日
C++中不常用的关键字
mutable关键字
关键字mutable是C＋＋中一个不常用的关键字,他只能用于类的非静态和非常量数据成员我们知道一个对象的状态由该对象的非静态数据成员决定,所以随着数据成员的改变,对像的状态也会随之发生变化!
如果一个类的成员函数被声明为const类型,表示该函数不会改变对象的状态,也就是该函数不会修改类的非静态数据成员.但是有些时候需要在该类函数中对类的数据成员进行赋值.这个时候就需要用到mutable关键字了
例如:
编译上面的代码会出现 error C2166: l-value specifies const object的错误说明在const类型的函数中改变了类的非静态数据成员.这个时候需要使用mutable来修饰一下要在const成员函数中改变的非静态数据成员
m_nAccess,代码如下:
class Demo
{
public:
Demo(){}
~Demo(){}
public:
bool getFlag() const
{
m_nAccess＋＋;
return m_bFlag;
}
private:
mutable int m_nAccess;
bool m_bFlag;
};
int main()
{
return 0;
}
这样再重新编译的时候就不会出现错误了!
volatile关键字
volatile是c/c＋＋中一个鲜为人知的关键字,该关键字告诉编译器不要持有变量的临时拷贝,它可以适用于基础类型
如：int,char,long......也适用于C的结构和C＋＋的类。当对结构或者类对象使用volatile修饰的时候，结构或者类的所有成员都会被视为volatile.使用volatile并不会否定对CRITICAL_SECTION,Mutex,Event等同步对象的需要
例如：
int i;
i = i ＋ 3;
无论如何，总是会有一小段时间，i会被放在一个寄存器中，因为算术运算只能在寄存器中进行。一般来说，volatitle关键字适用于行与行之间，而不是放在行内。
我们先来实现一个简单的函数，来观察一下由编译器产生出来的汇编代码中的不足之处，并观察volatile关键字如何修正这个不足之处。在这个函数体内存在一个busy loop(所谓busy loop也叫做busy waits,是一种高度浪费CPU时间的循环方法)
void getKey(char* pch)
{
while (*pch == 0)
;
}
当你在VC开发环境中将最优化选项都关闭之后，编译这个程序，将获得以下结果(汇编代码)
; while (*pch == 0)
$L27
; Load the address stored in pch
mov eax, DWORD PTR _pch$[ebp]
; Load the character into the EAX register
movsx eax, BYTE PTR [eax]
; Compare the value to zero
test eax, eax
; If not zero, exit loop
jne $L28
;
jmp $L27
$L28
;}
这段没有优化的代码不断的载入适当的地址，载入地址中的内容，测试结果。效率相当的低，但是结果非常准确现在我们再来看看将编译器的所有最优化选项开关都打开以后，重新编译程序，生成的汇编代码，和上面的代码
比较一下有什么不同
;{
; Load the address stored in pch
mov eax, DWORD PTR _pch$[esp-4]
; Load the character into the AL register
movsx al, BYTE PTR [eax]
; while (*pch == 0)
; Compare the value in the AL register to zero
test al, al
; If still zero, try again
je SHORT $L84
;
;}
从代码的长度就可以看出来，比没有优化的情况要短的多。需要注意的是编译器把MOV指令放到了循环之外。这在单线程中是一个非常好的优化，但是，在多线程应用程序中，如果另一个线程改变了变量的值，则循环永远不会结束。被测试的值永远被放在寄存器中，所以该段代码在多线程的情况下，存在一个巨大的BUG。解决方法是重新
写一次getKey函数，并把参数pch声明为volatile,代码如下：
void getKey(volatile char* pch)
{
while (*pch == 0)
;
}
这次的修改对于非最优化的版本没有任何影响，下面请看最优化后的结果：
;{
; Load the address stored in pch
mov eax, DWORD PTR _pch$[esp-4]
; while (*pch == 0)
$L84:
; Directly compare the value to zero
cmp BYTE PTR [eax], 0
; If still zero, try again
je SHORT $L84
;
;}
这次的修改结果比较完美，地址不会改变，所以地址声明被移动到循环之外。地址内容是volatile,所以每次循环之中它不断的被重新检查。把一个const volatile变量作为参数传递给函数是合法的。如此的声明意味着函数不能改变变量的值，但是变量的值却可以被另一个线程在任何时间改变掉。
explicit关键字
我们在编写应用程序的时候explicit关键字基本上是很少使用,它的作用是"禁止单参数构造函数"被用于自动型别转换,其中比较典型的例子就是容器类型,在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数.
例如:
你可以声明这样一个构造函数
class Array
{
public:
explicit Array(int size);
......
};
在这里explicit关键字起着至关重要的作用,如果没有这个关键字的话,这个构造函数有能力将int转换成Array.一旦这种情况发生,你可以给Array支派一个整数值而不会引起任何的问题,比如:
Array arr;
...
arr = 40;
此时,C＋＋的自动型别转换会把40转换成拥有40个元素的Array,并且指派给arr变量,这个结果根本就不是我们想要的结果.如果我们将构造函数声明为explicit,上面的赋值操作就会导致编译器报错,使我们可以及时发现错误.需要注意的是:explicit同样也能阻止"以赋值语法进行带有转型操作的初始化";
例如:
Array arr(40);//正确
Array arr = 40;//错误
看一下以下两种操作:
X x;
Y y(x);//显式类型转换
另一种
X x;
Y y = x;//隐式类型转换
这两种操作存在一个小小的差别,第一种方式式通过显式类型转换,根据型别x产生了型别Y的新对象;第二种方式通过隐式转换产生了一个型别Y的新对象.explicit关键字的应用主要就是上面所说的构造函数定义种,参考该关键字的应用可以看看STL源代码,其中大量使用了该关键字
__based关键字
该关键字主要用来解决一些和共享内存有关的问题,它允许指针被定义为从某一点开始算的32位偏移值,而不是内存种的绝对位置
举个例子:
typedef struct tagDEMOSTRUCT {
int a;
char sz[10];
} DEMOSTRUCT, * PDEMOSTRUCT;
HANDLE hFileMapping = CreateFileMapping(...);
LPVOID lpShare = (LPDWORD)MapViewOfFile(...);
DEMOSTRUCT __based(lpShare)* lpDemo;
上面的例子声明了一个指针lpDemo,内部储存的是从lpShare开始的偏移值,也就是lpHead是以lpShare为基准的偏移值.
上面的例子种的DEMOSTRUCT只是随便定义的一个结构,用来代表任意的结构.
虽然__based指针使用起来非常容易,但是,你必须在效率上付出一定的代价.每当你用__based指针处理数据,CPU都必须为它加上基地址,才能指向真正的位置.
关键字mutable是C＋＋中一个不常用的关键字,他只能用于类的非静态和非常量数据成员我们知道一个对象的状态由该对象的非静态数据成员决定,所以随着数据成员的改变,对像的状态也会随之发生变化!
如果一个类的成员函数被声明为const类型,表示该函数不会改变对象的状态,也就是该函数不会修改类的非静态数据成员.但是有些时候需要在该类函数中对类的数据成员进行赋值.这个时候就需要用到mutable关键字了
例如:
class Demo
{
public:
Demo(){}
~Demo(){}
public:
bool getFlag() const
{
m_nAccess＋＋;
return m_bFlag;
}
private:
int m_nAccess;
bool m_bFlag;
};
int main()
{
return 0;
}
编译上面的代码会出现 error C2166: l-value specifies const object的错误说明在const类型的函数中改变了类的非静态数据成员.这个时候需要使用mutable来修饰一下要在const成员函数中改变的非静态数据成员
m_nAccess,代码如下:
class Demo
{
public:
Demo(){}
~Demo(){}
public:
bool getFlag() const
{
m_nAccess＋＋;
return m_bFlag;
}
private:
mutable int m_nAccess;
bool m_bFlag;
};
int main()
{
return 0;
}
这样再重新编译的时候就不会出现错误了!
volatile关键字
volatile是c/c＋＋中一个鲜为人知的关键字,该关键字告诉编译器不要持有变量的临时拷贝,它可以适用于基础类型
如：int,char,long......也适用于C的结构和C＋＋的类。当对结构或者类对象使用volatile修饰的时候，结构或者类的所有成员都会被视为volatile.使用volatile并不会否定对CRITICAL_SECTION,Mutex,Event等同步对象的需要
例如：
int i;
i = i ＋ 3;
无论如何，总是会有一小段时间，i会被放在一个寄存器中，因为算术运算只能在寄存器中进行。一般来说，volatitle关键字适用于行与行之间，而不是放在行内。
我们先来实现一个简单的函数，来观察一下由编译器产生出来的汇编代码中的不足之处，并观察volatile关键字如何修正这个不足之处。在这个函数体内存在一个busy loop(所谓busy loop也叫做busy waits,是一种高度浪费CPU时间的循环方法)
void getKey(char* pch)
{
while (*pch == 0)
;
}
当你在VC开发环境中将最优化选项都关闭之后，编译这个程序，将获得以下结果(汇编代码)
; while (*pch == 0)
$L27
; Load the address stored in pch
mov eax, DWORD PTR _pch$[ebp]
; Load the character into the EAX register
movsx eax, BYTE PTR [eax]
; Compare the value to zero
test eax, eax
; If not zero, exit loop
jne $L28
;
jmp $L27
$L28
;}
这段没有优化的代码不断的载入适当的地址，载入地址中的内容，测试结果。效率相当的低，但是结果非常准确现在我们再来看看将编译器的所有最优化选项开关都打开以后，重新编译程序，生成的汇编代码，和上面的代码
比较一下有什么不同
;{
; Load the address stored in pch
mov eax, DWORD PTR _pch$[esp-4]
; Load the character into the AL register
movsx al, BYTE PTR [eax]
; while (*pch == 0)
; Compare the value in the AL register to zero
test al, al
; If still zero, try again
je SHORT $L84
;
;}
从代码的长度就可以看出来，比没有优化的情况要短的多。需要注意的是编译器把MOV指令放到了循环之外。这在单线程中是一个非常好的优化，但是，在多线程应用程序中，如果另一个线程改变了变量的值，则循环永远不会结束。被测试的值永远被放在寄存器中，所以该段代码在多线程的情况下，存在一个巨大的BUG。解决方法是重新
写一次getKey函数，并把参数pch声明为volatile,代码如下：
void getKey(volatile char* pch)
{
while (*pch == 0)
;
}
这次的修改对于非最优化的版本没有任何影响，下面请看最优化后的结果：
;{
; Load the address stored in pch
mov eax, DWORD PTR _pch$[esp-4]
; while (*pch == 0)
$L84:
; Directly compare the value to zero
cmp BYTE PTR [eax], 0
; If still zero, try again
je SHORT $L84
;
;}
这次的修改结果比较完美，地址不会改变，所以地址声明被移动到循环之外。地址内容是volatile,所以每次循环之中它不断的被重新检查。把一个const volatile变量作为参数传递给函数是合法的。如此的声明意味着函数不能改变变量的值，但是变量的值却可以被另一个线程在任何时间改变掉。
explicit关键字
我们在编写应用程序的时候explicit关键字基本上是很少使用,它的作用是"禁止单参数构造函数"被用于自动型别转换,其中比较典型的例子就是容器类型,在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数.
例如:
你可以声明这样一个构造函数
class Array
{
public:
explicit Array(int size);
......
};
在这里explicit关键字起着至关重要的作用,如果没有这个关键字的话,这个构造函数有能力将int转换成Array.一旦这种情况发生,你可以给Array支派一个整数值而不会引起任何的问题,比如:
Array arr;
...
arr = 40;
此时,C＋＋的自动型别转换会把40转换成拥有40个元素的Array,并且指派给arr变量,这个结果根本就不是我们想要的结果.如果我们将构造函数声明为explicit,上面的赋值操作就会导致编译器报错,使我们可以及时发现错误.需要注意的是:explicit同样也能阻止"以赋值语法进行带有转型操作的初始化";
例如:
Array arr(40);//正确
Array arr = 40;//错误
看一下以下两种操作:
X x;
Y y(x);//显式类型转换
另一种
X x;
Y y = x;//隐式类型转换
这两种操作存在一个小小的差别,第一种方式式通过显式类型转换,根据型别x产生了型别Y的新对象;第二种方式通过隐式转换产生了一个型别Y的新对象.explicit关键字的应用主要就是上面所说的构造函数定义种,参考该关键字的应用可以看看STL源代码,其中大量使用了该关键字
__based关键字
该关键字主要用来解决一些和共享内存有关的问题,它允许指针被定义为从某一点开始算的32位偏移值,而不是内存种的绝对位置
举个例子:
typedef struct tagDEMOSTRUCT {
int a;
char sz[10];
} DEMOSTRUCT, * PDEMOSTRUCT;
HANDLE hFileMapping = CreateFileMapping(...);
LPVOID lpShare = (LPDWORD)MapViewOfFile(...);
DEMOSTRUCT __based(lpShare)* lpDemo;
上面的例子声明了一个指针lpDemo,内部储存的是从lpShare开始的偏移值,也就是lpHead是以lpShare为基准的偏移值.
上面的例子种的DEMOSTRUCT只是随便定义的一个结构,用来代表任意的结构.
虽然__based指针使用起来非常容易,但是,你必须在效率上付出一定的代价.每当你用__based指针处理数据,CPU都必须为它加上基地址,才能指向真正的位置.
2008年9月22日星期一
Linux的shell编程（Linux Shell Tutorial）
http://tech.sina.com.cn 2001/01/15 17:01 软件世界 敬茂华
Shell本身是一个用C语言编写的程序，它是用户使用Linux的桥梁。Shell既是一种命令语言，又是一种程序设计语言。作为命令语言，它交互式地解释和执行用户输入的命令；作为程序设计语言，它定义了各种变量和参数，并提供了许多在高级语言中才具有的控制结构，包括循环和分支。它虽然不是Linux系统核心的一部分，但它调用了系统核心的大部分功能来执行程序、建立文件并以并行的方式协调各个程序的运行。因此，对于用户来说，shell是最重要的实用程序，深入了解和熟练掌握shell的特性极其使用方法，是用好Linux系统的关键。可以说，shell使用的熟练程度反映了用户对Linux使用的熟练程度。
一、什么是shell
当一个用户登录Linux系统之后，系统初始化程序init就为每一个用户运行一个称为shell(外壳)的程序。那么，shell是什么呢？确切一点说，shell就是一个命令行解释器，它为用户提供了一个向Linux内核发送请求以便运行程序的界面系统级程序，用户可以用shell来启动、挂起、停止甚至是编写一些程序。
当用户使用Linux时是通过命令来完成所需工作的。一个命令就是用户和shell之间对话的一个基本单位，它是由多个字符组成并以换行结束的字符串。shell解释用户输入的命令，就象DOS里的command.com所做的一样，所不同的是，在DOS中，command.com只有一个，而在Linux下比较流行的shell有好几个，每个shell都各有千秋。一般的Linux系统都将bash作为默认的shell。
二、几种流行的shell
目前流行的shell有ash、bash、ksh、csh、zsh等，你可以用下面的命令来查看你自己的shell类型：
#echo $SHELL
$SHELL是一个环境变量，它记录用户所使用的shell类型。你可以用命令：
#shell-name
来转换到别的shell，这里shell-name是你想要尝试使用的shell的名称，如ash等。这个命令为用户又启动了一个shell，这个shell在最初登录的那个shell之后，称为下级的shell或子shell。使用命令：
$exit
可以退出这个子shell。
使用不同的shell的原因在于它们各自都有自己的特点，下面作一个简单的介绍：
1.ash
ash shell是由Kenneth Almquist编写的，Linux中占用系统资源最少的一个小shell，它只包含24个内部命令，因而使用起来很不方便。
2.bash
bash是Linux系统默认使用的shell，它由Brian Fox和Chet Ramey共同完成，是Bourne Again Shell的缩写，内部命令一共有40个。Linux使用它作为默认的shell是因为它有诸如以下的特色：
(1)可以使用类似DOS下面的doskey的功能，用方向键查阅和快速输入并修改命令。
(2)自动通过查找匹配的方式给出以某字符串开头的命令。
(3)包含了自身的帮助功能，你只要在提示符下面键入help就可以得到相关的帮助。
3.ksh
ksh是Korn shell的缩写，由Eric Gisin编写，共有42条内部命令。该shell最大的优点是几乎和商业发行版的ksh完全兼容，这样就可以在不用花钱购买商业版本的情况下尝试商业版本的性能了。
4.csh
csh是Linux比较大的内核，它由以William Joy为代表的共计47位作者编成，共有52个内部命令。该shell其实是指向/bin/tcsh这样的一个shell，也就是说，csh其实就是tcsh。
5.zch
zch是Linux最大的shell之一，由Paul Falstad完成，共有84个内部命令。如果只是一般的用途，是没有必要安装这样的shell的。
3. shell程序设计(基础部分)
其实作为命令语言交互式地解释和执行用户输入的命令只是shell功能的一个方面，shell还可以用来进行程序设计，它提供了定义变量和参数的手段以及丰富的程序控制结构。使用shell编程类似于DOS中的批处理文件，称为shell script，又叫shell程序或shell命令文件。
1.shell基本语法
shell的基本语法主要就是如何输入命令运行程序以及如何在程序之间通过shell的一些参数提供便利手段来进行通讯。
(1)输入输出重定向
在Linux中，每一个进程都有三个特殊的文件描述指针：标准输入(standard input，文件描述指针为0)、标准输出(standard output，文件描述指针为1)、标准错误输出(standard error，文件描述指针为2)。这三个特殊的文件描述指针使进程在一般情况下接收标准输入终端的输入，同时由标准终端来显示输出，Linux同时也向使用者提供可以使用普通的文件或管道来取代这些标准输入输出设备。在shell中，使用者可以利用“>”和“<”来进行输入输出重定向。如：
command>file：将命令的输出结果重定向到一个文件。
command>&file：将命令的标准错误输出一起重定向到一个文件。
command>>file：将标准输出的结果追加到文件中。
command>>&file：将标准输出和标准错误输出的结构都追加到文件中。
command
(2)管道pipe
pipe同样可以在标准输入输出和标准错误输出间做代替工作，这样一来，可以将某一个程序的输出送到另一个程序的输入，其语法如下：
command1| command2[| command3...]
也可以连同标准错误输出一起送入管道：
command1| &command2[|& command3...]
(3)前台和后台
在shell下面，一个新产生的进程可以通过用命令后面的符号“；”和“&”来分别以前台和后台的方式来执行，语法如下：
command
产生一个前台的进程，下一个命令须等该命令运行结束后才能输入。
command &
产生一个后台的进程，此进程在后台运行的同时，可以输入其他的命令。
2。shell程序的变量和参数
像高级程序设计语言一样，shell也提供说明和使用变量的功能。对shell来讲，所有变量的取值都是一个字符串，shell程序采用$var的形式来引用名为var的变量的值。
Shell有以下几种基本类型的变量：
(1)shell定义的环境变量
shell在开始执行时就已经定义了一些和系统的工作环境有关的变量，这些变量用户还可以重新定义，常用的shell环境变量有：
HOME：用于保存注册目录的完全路径名。
PATH：用于保存用冒号分隔的目录路径名，shell将按PATH变量中给出的顺序搜索这些目录，找到的第一个与命令名称一致的可执行文件将被执行。
TERM：终端的类型。
UID：当前用户的标识符，取值是由数字构成的字符串。
PWD：当前工作目录的绝对路径名，该变量的取值随cd命令的使用而变化。
PS1：主提示符，在特权用户下，缺省的主提示符是“#”，在普通用户下，缺省的主提示符是“$”。
PS2：在shell接收用户输入命令的过程中，如果用户在输入行的末尾输入“\”然后回车，或者当用户按回车键时shell判断出用户输入的命令没有结束时，显示这个辅助提示符，提示用户继续输入命令的其余部分，缺省的辅助提示符是“>”。
(2)用户定义的变量
用户可以按照下面的语法规则定义自己的变量：
变量名=变量值
要注意的一点是，在定义变量时，变量名前不应加符号“$”，在引用变量的内容时则应在变量名前加“$”；在给变量赋值时，等号两边一定不能留空格，若变量中本身就包含了空格，则整个字符串都要用双引号括起来。
在编写shell程序时，为了使变量名和命令名相区别，建议所有的变量名都用大写字母来表示。
有时我们想要在说明一个变量并对它设定为一个特定值后就不在改变它的值，这可以用下面的命令来保证一个变量的只读性：
readly 变量名
在任何时候，建立的变量都只是当前shell的局部变量，所以不能被shell运行的其他命令或shell程序所利用，export命令可以将一局部变量提供给shell执行的其他命令使用，其格式为：
export 变量名
也可以在给变量赋值的同时使用export命令：
export 变量名=变量值
使用export说明的变量，在shell以后运行的所有命令或程序中都可以访问到。
(3)位置参数
位置参数是一种在调用shell程序的命令行中按照各自的位置决定的变量，是在程序名之后输入的参数。位置参数之间用空格分隔，shell取第一个位置参数替换程序文件中的$1，第二个替换$2，依次类推。$0是一个特殊的变量，它的内容是当前这个shell程序的文件名，所以，$0不是一个位置参数，在显示当前所有的位置参数时是不包括$0的。
(4)预定义变量
预定义变量和环境变量相类似，也是在shell一开始时就定义了的变量，所不同的是，用户只能根据shell的定义来使用这些变量，而不能重定义它。所有预定义变量都是由$符和另一个符号组成的，常用的shell预定义变量有：
$#：位置参数的数量
$*：所有位置参数的内容
$?：命令执行后返回的状态
$$：当前进程的进程号
$!：后台运行的最后一个进程号
$0：当前执行的进程名
其中，“$?”用于检查上一个命令执行是否正确(在Linux中，命令退出状态为0表示该命令正确执行，任何非0值表示命令出错)。
“$$”变量最常见的用途是用作临时文件的名字以保证临时文件不会重复。
(5)参数置换的变量
shell提供了参数置换能力以便用户可以根据不同的条件来给变量赋不同的值。参数置换的变量有四种，这些变量通常与某一个位置参数相联系，根据指定的位置参数是否已经设置类决定变量的取值，它们的语法和功能分别如下。
a. 变量=${参数-word}：如果设置了参数，则用参数的值置换变量的值，否则用word置换。即这种变量的值等于某一个参数的值，如果该参数没有设置，则变量就等于word的值。
b. 变量=${参数=word}：如果设置了参数，则用参数的值置换变量的值，否则把变量设置成word然后再用word替换参数的值。注意，位置参数不能用于这种方式，因为在shell程序中不能为位置参数赋值。
c. 变量=${参数？word}：如果设置了参数，则用参数的值置换变量的值，否则就显示word并从shell中退出，如果省略了word，则显示标准信息。这种变量要求一定等于某一个参数的值，如果该参数没有设置，就显示一个信息，然后退出，因此这种方式常用于出错指示。
d. 变量=${参数+word}：如果设置了参数，则用word置换变量，否则不进行置换。
所有这四种形式中的“参数”既可以是位置参数，也可以是另一个变量，只是用位置参数的情况比较多。
接下来以bash为例向大家介绍shell程序设计的高级部分：shell编程的流程控制、调试方法及shell程序的运行方法，顺便也向大家介绍一下bash的内部命令。
四、shell程序设计的流程控制
和其他高级程序设计语言一样，shell提供了用来控制程序执行流程的命令，包括条件分支和循环结构，用户可以用这些命令建立非常复杂的程序。
与传统的语言不同的是，shell用于指定条件值的不是布尔表达式而是命令和字符串。
1.test测试命令
test命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试，其测试符和相应的功能分别如下：
(1)数值测试：
-eq：等于则为真
-ne：不等于则为真
-gt：大于则为真
-ge：大于等于则为真
-lt：小于则为真
-le：小于等于则为真
(2)字符串测试：
=：等于则为真
!=：不相等则为真
-z字符串：字符串长度伪则为真
-n字符串：字符串长度不伪则为真
(3)文件测试：
-e文件名：如果文件存在则为真
-r文件名：如果文件存在且可读则为真
-w文件名：如果文件存在且可写则为真
-x文件名：如果文件存在且可执行则为真
-s文件名：如果文件存在且至少有一个字符则为真
-d文件名：如果文件存在且为目录则为真
-f文件名：如果文件存在且为普通文件则为真
-c文件名：如果文件存在且为字符型特殊文件则为真
-b文件名：如果文件存在且为块特殊文件则为真
另外，Linux还提供了与(“！”)、或(“-o)、非(“-a”)三个逻辑操作符用于将测试条件连接起来，其优先级为：“！”最高，“-a”次之，“-o”最低。
同时，bash也能完成简单的算术运算，格式如下：
$[expression]
例如：var1=2
var2=$[var1*10+1]
则：var2的值为21。
2.if条件语句
shell程序中的条件分支是通过if条件语句来实现的，其一般格式为：
if条件命令串
then
条件为真时的命令串
else
条件为假时的命令串
fi
3.for循环
for循环对一个变量的可能的值都执行一个命令序列。赋给变量的几个数值既可以在程序内以数值列表的形式提供，也可以在程序以外以位置参数的形式提供。for循环的一般格式为：
for变量名
[in数值列表]
do
若干个命令行
done
变量名可以是用户选择的任何字符串，如果变量名是var，则在in之后给出的数值将顺序替换循环命令列表中的$var。如果省略了in，则变量var的取值将是位置参数。对变量的每一个可能的赋值都将执行do和done之间的命令列表。
4.while和until循环
while和until命令都是用命令的返回状态值来控制循环的。While循环的一般格式为：
while
若干个命令行1
do
若干个命令行2
done
只要while的“若干个命令行1”中最后一个命令的返回状态为真，while循环就继续执行do...done之间的“若干个命令行2”。
until命令是另一种循环结构，它和while命令相似，其格式如下：
until
若干个命令行1
do
若干个命令行2
done
until循环和while循环的区别在于：while循环在条件为真时继续执行循环，而until则是在条件为假时继续执行循环。
Shell还提供了true和false两条命令用于建立无限循环结构的需要，它们的返回状态分别是总为0或总为非0
5.case条件选择
if条件语句用于在两个选项中选定一项，而case条件选择为用户提供了根据字符串或变量的值从多个选项中选择一项的方法，其格式如下：
case string in
exp-1)
若干个命令行1
；；
exp-2)
若干个命令行2
；；
……
*)
其他命令行
esac
shell通过计算字符串string的值，将其结果依次和表达式exp-1、exp-2等进行比较，直到找到一个匹配的表达式为止，如果找到了匹配项则执行它下面的命令直到遇到一对分号(；；)为止。
在case表达式中也可以使用shell的通配符(“*”、“？”、“[ ]”)。通常用“*”作为case命令的最后表达式以便使在前面找不到任何相应的匹配项时执行“其他命令行”的命令。
6.无条件控制语句break和continue
break用于立即终止当前循环的执行，而contiune用于不执行循环中后面的语句而立即开始下一个循环的执行。这两个语句只有放在do和done之间才有效。
7.函数定义
在shell中还可以定义函数。函数实际上也是由若干条shell命令组成的，因此它与shell程序形式上是相似的，不同的是它不是一个单独的进程，而是shell程序的一部分。函数定义的基本格式为：
functionname
{
若干命令行
}
调用函数的格式为：
functionname param1 param2……
shell函数可以完成某些例行的工作，而且还可以有自己的退出状态，因此函数也可以作为if、while等控制结构的条件。
在函数定义时不用带参数说明，但在调用函数时可以带有参数，此时shell将把这些参数分别赋予相应的位置参数$1、$2、...及$*。
8.命令分组
在shell中有两种命令分组的方法：“()”和“{}”，前者当shell执行()中的命令时将再创建一个新的子进程，然后这个子进程去执行圆括弧中的命令。当用户在执行某个命令时不想让命令运行时对状态集合(如位置参数、环境变量、当前工作目录等)的改变影响到下面语句的执行时，就应该把这些命令放在圆括弧中，这样就能保证所有的改变只对子进程产生影响，而父进程不受任何干扰；{}用于将顺序执行的命令的输出结果用于另一个命令的输入(管道方式)。当我们要真正使用圆括弧和花括弧时(如计算表达式的优先级)，则需要在其前面加上转义符(\)以便让shell知道它们不是用于命令执行的控制所用。
9.信号
trap命令用于在shell程序中捕捉到信号，之后可以有三种反应方式：
(1)执行一段程序来处理这一信号
(2)接受信号的默认操作
(3)忽视这一信号
trap对上面三种方式提供了三种基本形式：
第一种形式的trap命令在shell接收到signal list清单中数值相同的信号时，将执行双引号中的命令串。
trap 'commands' signal-list
trap "commands" signal-list
为了恢复信号的默认操作，使用第二种形式的trap命令：
trap signal-list
第三种形式的trap命令允许忽视信号：
trap " " signal-list
注意：
(1)对信号11(段违例)不能捕捉，因为shell本身需要捕捉该信号去进行内存的转储。
(2)在trap中可以定义对信号0的处理(实际上没有这个信号)，shell程序在其终止(如执行exit语句)时发出该信号。
(3)在捕捉到signal-list中指定的信号并执行完相应的命令之后，如果这些命令没有将shell程序终止的话，shell程序将继续执行收到信号时所执行的命令后面的命令，这样将很容易导致shell程序无法终止。
另外，在trap语句中，单引号和双引号是不同的，当shell程序第一次碰到trap语句时，将把commands中的命令扫描一遍。此时若commands是用单引号括起来的话，那么shell不会对commands中的变量和命令进行替换，否则commands中的变量和命令将用当时具体的值来替换。
五、运行shell程序的方法
用户可以用任何编辑程序来编写shell程序。因为shell程序是解释执行的，所以不需要编译装配成目标程序，按照shell编程的惯例，以bash为例，程序的第一行一般为“#！/bin/bash”，其中#表示该行是注释，叹号“！”告诉shell运行叹号之后的命令并用文件的其余部分作为输入，也就是运行/bin/bash并让/bin/bash去执行shell程序的内容。
执行shell程序的方法有三种：
(1)sh shell程序文件名
这种方法的命令格式为：
bash shell程序文件名
这实际上是调用一个新的bash命令解释程序，而把shell程序文件名作为参数传递给它。新启动的shell将去读指定的文件，执行文件中列出的命令，当所有的命令都执行完结束。该方法的优点是可以利用shell调试功能。
(2)sh
格式为：
bash
这种方式就是利用输入重定向，使shell命令解释程序的输入取自指定的程序文件。
(3)用chmod命令使shell程序成为可执行的
一个文件能否运行取决于该文件的内容本身可执行且该文件具有执行权。对于shell程序，当用编辑器生成一个文件时，系统赋予的许可权限都是644(rw-r-r--)，因此，当用户需要运行这个文件时，只需要直接键入文件名即可。
在这三种运行shell程序的方法中，最好按下面的方式选择：当刚建立一个shell程序，对它的正确性还没有把握时，应当使用第一种方式进行调试。当一个shell程序已经调试好时，应使用第三种方式把它固定下来，以后只要键入相应的文件名即可，并可被另一个程序所调用。
六、bash程序的调试
在编程过程中难免会出错，有的时候，调试程序比编写程序花费的时间还要多，shell程序同样如此。
shell程序的调试主要是利用bash命令解释程序的选择项。调用bash的形式是：
bash -选择项shell程序文件名
几个常用的选择项是：
-e：如果一个命令失败就立即退出
-n：读入命令但是不执行它们
-u：置换时把未设置的变量看作出错
-v：当读入shell输入行时把它们显示出来
-x：执行命令时把命令和它们的参数显示出来
上面的所有选项也可以在shell程序内部用“set -选择项”的形式引用，而“set +选择项”则将禁止该选择项起作用。如果只想对程序的某一部分使用某些选择项时，则可以将该部分用上面两个语句包围起来。
1.未置变量退出和立即退出
未置变量退出特性允许用户对所有变量进行检查，如果引用了一个未赋值的变量就终止shell程序的执行。shell通常允许未置变量的使用，在这种情况下，变量的值为空。如果设置了未置变量退出选择项，则一旦使用了未置变量就显示错误信息，并终止程序的运行。未置变量退出选择项为“-u”。
当shell运行时，若遇到不存在或不可执行的命令、重定向失败或命令非正常结束等情况时，如果未经重新定向，该出错信息会打印在终端屏幕上，而shell程序仍将继续执行。要想在错误发生时迫使shell程序立即结束，可以使用“-e”选项将shell程序的执行立即终止。
2.shell程序的跟踪
调试shell程序的主要方法是利用shell命令解释程序的“-v”或“-x”选项来跟踪程序的执行。“-v”选择项使shell在执行程序的过程中，把它读入的每一个命令行都显示出来，而“-x”选择项使shell在执行程序的过程中把它执行的每一个命令在行首用一个“+”加上命令名显示出来。并把每一个变量和该变量所取的值也显示出来，因此，它们的主要区别在于：在执行命令行之前无“-v”则打印出命令行的原始内容，而有“-v”则打印出经过替换后的命令行的内容。
除了使用shell的“-v”和“-x”选择项以外，还可以在shell程序内部采取一些辅助调试的措施。例如，可以在shell程序的一些关键地方使用echo命令把必要的信息显示出来，它的作用相当于C语言中的printf语句，这样就可以知道程序运行到什么地方及程序目前的状态。
七、bash的内部命令
bash命令解释程序包含了一些内部命令。内部命令在目录列表时是看不见的，它们由shell本身提供。常用的内部命令有：echo、eval、exec、export、readonly、read、shift、wait和点(.)。下面简单介绍其命令格式和功能。
1.echo
命令格式：echo arg
功能：在屏幕上打印出由arg指定的字符串。
2.eval
命令格式：eval args
功能：当shell程序执行到eval语句时，shell读入参数args，并将它们组合成一个新的命令，然后执行。
3.exec
命令格式：exec命令命令参数
功能：当shell执行到exec语句时，不会去创建新的子进程，而是转去执行指定的命令，当指定的命令执行完时，该进程，也就是最初的shell就终止了，所以shell程序中exec后面的语句将不再被执行。
4.export
命令格式：export变量名或：export变量名=变量值
功能：shell可以用export把它的变量向下带入子shell从而让子进程继承父进程中的环境变量。但子shell不能用export把它的变量向上带入父shell。
注意：不带任何变量名的export语句将显示出当前所有的export变量。
5.readonly
命令格式：readonly变量名
功能：将一个用户定义的shell变量标识为不可变的。不带任何参数的readonly命令将显示出所有只读的shell变量。
6.read
命令格式：read变量名表
功能：从标准输入设备读入一行，分解成若干字，赋值给shell程序内部定义的变量。
7.shift语句
功能：shift语句按如下方式重新命名所有的位置参数变量：$2成为$1，$3成为$2……在程序中每使用一次shift语句，都使所有的位置参数依次向左移动一个位置，并使位置参数“$#”减一，直到减到0。
8.wait
功能：是shell等待在后台启动的所有子进程结束。Wait的返回值总是真。
9.exit
功能：退出shell程序。在exit之后可有选择地指定一个数字作为返回状态。
10.“.”(点)
命令格式：. Shell程序文件名
功能：使shell读入指定的shell程序文件并依次执行文件中的所有语句。
Shell本身是一个用C语言编写的程序，它是用户使用Linux的桥梁。Shell既是一种命令语言，又是一种程序设计语言。作为命令语言，它交互式地解释和执行用户输入的命令；作为程序设计语言，它定义了各种变量和参数，并提供了许多在高级语言中才具有的控制结构，包括循环和分支。它虽然不是Linux系统核心的一部分，但它调用了系统核心的大部分功能来执行程序、建立文件并以并行的方式协调各个程序的运行。因此，对于用户来说，shell是最重要的实用程序，深入了解和熟练掌握shell的特性极其使用方法，是用好Linux系统的关键。可以说，shell使用的熟练程度反映了用户对Linux使用的熟练程度。
一、什么是shell
当一个用户登录Linux系统之后，系统初始化程序init就为每一个用户运行一个称为shell(外壳)的程序。那么，shell是什么呢？确切一点说，shell就是一个命令行解释器，它为用户提供了一个向Linux内核发送请求以便运行程序的界面系统级程序，用户可以用shell来启动、挂起、停止甚至是编写一些程序。
当用户使用Linux时是通过命令来完成所需工作的。一个命令就是用户和shell之间对话的一个基本单位，它是由多个字符组成并以换行结束的字符串。shell解释用户输入的命令，就象DOS里的command.com所做的一样，所不同的是，在DOS中，command.com只有一个，而在Linux下比较流行的shell有好几个，每个shell都各有千秋。一般的Linux系统都将bash作为默认的shell。
二、几种流行的shell
目前流行的shell有ash、bash、ksh、csh、zsh等，你可以用下面的命令来查看你自己的shell类型：
#echo $SHELL
$SHELL是一个环境变量，它记录用户所使用的shell类型。你可以用命令：
#shell-name
来转换到别的shell，这里shell-name是你想要尝试使用的shell的名称，如ash等。这个命令为用户又启动了一个shell，这个shell在最初登录的那个shell之后，称为下级的shell或子shell。使用命令：
$exit
可以退出这个子shell。
使用不同的shell的原因在于它们各自都有自己的特点，下面作一个简单的介绍：
1.ash
ash shell是由Kenneth Almquist编写的，Linux中占用系统资源最少的一个小shell，它只包含24个内部命令，因而使用起来很不方便。
2.bash
bash是Linux系统默认使用的shell，它由Brian Fox和Chet Ramey共同完成，是Bourne Again Shell的缩写，内部命令一共有40个。Linux使用它作为默认的shell是因为它有诸如以下的特色：
(1)可以使用类似DOS下面的doskey的功能，用方向键查阅和快速输入并修改命令。
(2)自动通过查找匹配的方式给出以某字符串开头的命令。
(3)包含了自身的帮助功能，你只要在提示符下面键入help就可以得到相关的帮助。
3.ksh
ksh是Korn shell的缩写，由Eric Gisin编写，共有42条内部命令。该shell最大的优点是几乎和商业发行版的ksh完全兼容，这样就可以在不用花钱购买商业版本的情况下尝试商业版本的性能了。
4.csh
csh是Linux比较大的内核，它由以William Joy为代表的共计47位作者编成，共有52个内部命令。该shell其实是指向/bin/tcsh这样的一个shell，也就是说，csh其实就是tcsh。
5.zch
zch是Linux最大的shell之一，由Paul Falstad完成，共有84个内部命令。如果只是一般的用途，是没有必要安装这样的shell的。
3. shell程序设计(基础部分)
其实作为命令语言交互式地解释和执行用户输入的命令只是shell功能的一个方面，shell还可以用来进行程序设计，它提供了定义变量和参数的手段以及丰富的程序控制结构。使用shell编程类似于DOS中的批处理文件，称为shell script，又叫shell程序或shell命令文件。
1.shell基本语法
shell的基本语法主要就是如何输入命令运行程序以及如何在程序之间通过shell的一些参数提供便利手段来进行通讯。
(1)输入输出重定向
在Linux中，每一个进程都有三个特殊的文件描述指针：标准输入(standard input，文件描述指针为0)、标准输出(standard output，文件描述指针为1)、标准错误输出(standard error，文件描述指针为2)。这三个特殊的文件描述指针使进程在一般情况下接收标准输入终端的输入，同时由标准终端来显示输出，Linux同时也向使用者提供可以使用普通的文件或管道来取代这些标准输入输出设备。在shell中，使用者可以利用“>”和“<”来进行输入输出重定向。如：
command>file：将命令的输出结果重定向到一个文件。
command>&file：将命令的标准错误输出一起重定向到一个文件。
command>>file：将标准输出的结果追加到文件中。
command>>&file：将标准输出和标准错误输出的结构都追加到文件中。
command
(2)管道pipe
pipe同样可以在标准输入输出和标准错误输出间做代替工作，这样一来，可以将某一个程序的输出送到另一个程序的输入，其语法如下：
command1| command2[| command3...]
也可以连同标准错误输出一起送入管道：
command1| &command2[|& command3...]
(3)前台和后台
在shell下面，一个新产生的进程可以通过用命令后面的符号“；”和“&”来分别以前台和后台的方式来执行，语法如下：
command
产生一个前台的进程，下一个命令须等该命令运行结束后才能输入。
command &
产生一个后台的进程，此进程在后台运行的同时，可以输入其他的命令。
2。shell程序的变量和参数
像高级程序设计语言一样，shell也提供说明和使用变量的功能。对shell来讲，所有变量的取值都是一个字符串，shell程序采用$var的形式来引用名为var的变量的值。
Shell有以下几种基本类型的变量：
(1)shell定义的环境变量
shell在开始执行时就已经定义了一些和系统的工作环境有关的变量，这些变量用户还可以重新定义，常用的shell环境变量有：
HOME：用于保存注册目录的完全路径名。
PATH：用于保存用冒号分隔的目录路径名，shell将按PATH变量中给出的顺序搜索这些目录，找到的第一个与命令名称一致的可执行文件将被执行。
TERM：终端的类型。
UID：当前用户的标识符，取值是由数字构成的字符串。
PWD：当前工作目录的绝对路径名，该变量的取值随cd命令的使用而变化。
PS1：主提示符，在特权用户下，缺省的主提示符是“#”，在普通用户下，缺省的主提示符是“$”。
PS2：在shell接收用户输入命令的过程中，如果用户在输入行的末尾输入“\”然后回车，或者当用户按回车键时shell判断出用户输入的命令没有结束时，显示这个辅助提示符，提示用户继续输入命令的其余部分，缺省的辅助提示符是“>”。
(2)用户定义的变量
用户可以按照下面的语法规则定义自己的变量：
变量名=变量值
要注意的一点是，在定义变量时，变量名前不应加符号“$”，在引用变量的内容时则应在变量名前加“$”；在给变量赋值时，等号两边一定不能留空格，若变量中本身就包含了空格，则整个字符串都要用双引号括起来。
在编写shell程序时，为了使变量名和命令名相区别，建议所有的变量名都用大写字母来表示。
有时我们想要在说明一个变量并对它设定为一个特定值后就不在改变它的值，这可以用下面的命令来保证一个变量的只读性：
readly 变量名
在任何时候，建立的变量都只是当前shell的局部变量，所以不能被shell运行的其他命令或shell程序所利用，export命令可以将一局部变量提供给shell执行的其他命令使用，其格式为：
export 变量名
也可以在给变量赋值的同时使用export命令：
export 变量名=变量值
使用export说明的变量，在shell以后运行的所有命令或程序中都可以访问到。
(3)位置参数
位置参数是一种在调用shell程序的命令行中按照各自的位置决定的变量，是在程序名之后输入的参数。位置参数之间用空格分隔，shell取第一个位置参数替换程序文件中的$1，第二个替换$2，依次类推。$0是一个特殊的变量，它的内容是当前这个shell程序的文件名，所以，$0不是一个位置参数，在显示当前所有的位置参数时是不包括$0的。
(4)预定义变量
预定义变量和环境变量相类似，也是在shell一开始时就定义了的变量，所不同的是，用户只能根据shell的定义来使用这些变量，而不能重定义它。所有预定义变量都是由$符和另一个符号组成的，常用的shell预定义变量有：
$#：位置参数的数量
$*：所有位置参数的内容
$?：命令执行后返回的状态
$$：当前进程的进程号
$!：后台运行的最后一个进程号
$0：当前执行的进程名
其中，“$?”用于检查上一个命令执行是否正确(在Linux中，命令退出状态为0表示该命令正确执行，任何非0值表示命令出错)。
“$$”变量最常见的用途是用作临时文件的名字以保证临时文件不会重复。
(5)参数置换的变量
shell提供了参数置换能力以便用户可以根据不同的条件来给变量赋不同的值。参数置换的变量有四种，这些变量通常与某一个位置参数相联系，根据指定的位置参数是否已经设置类决定变量的取值，它们的语法和功能分别如下。
a. 变量=${参数-word}：如果设置了参数，则用参数的值置换变量的值，否则用word置换。即这种变量的值等于某一个参数的值，如果该参数没有设置，则变量就等于word的值。
b. 变量=${参数=word}：如果设置了参数，则用参数的值置换变量的值，否则把变量设置成word然后再用word替换参数的值。注意，位置参数不能用于这种方式，因为在shell程序中不能为位置参数赋值。
c. 变量=${参数？word}：如果设置了参数，则用参数的值置换变量的值，否则就显示word并从shell中退出，如果省略了word，则显示标准信息。这种变量要求一定等于某一个参数的值，如果该参数没有设置，就显示一个信息，然后退出，因此这种方式常用于出错指示。
d. 变量=${参数+word}：如果设置了参数，则用word置换变量，否则不进行置换。
所有这四种形式中的“参数”既可以是位置参数，也可以是另一个变量，只是用位置参数的情况比较多。
接下来以bash为例向大家介绍shell程序设计的高级部分：shell编程的流程控制、调试方法及shell程序的运行方法，顺便也向大家介绍一下bash的内部命令。
四、shell程序设计的流程控制
和其他高级程序设计语言一样，shell提供了用来控制程序执行流程的命令，包括条件分支和循环结构，用户可以用这些命令建立非常复杂的程序。
与传统的语言不同的是，shell用于指定条件值的不是布尔表达式而是命令和字符串。
1.test测试命令
test命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试，其测试符和相应的功能分别如下：
(1)数值测试：
-eq：等于则为真
-ne：不等于则为真
-gt：大于则为真
-ge：大于等于则为真
-lt：小于则为真
-le：小于等于则为真
(2)字符串测试：
=：等于则为真
!=：不相等则为真
-z字符串：字符串长度伪则为真
-n字符串：字符串长度不伪则为真
(3)文件测试：
-e文件名：如果文件存在则为真
-r文件名：如果文件存在且可读则为真
-w文件名：如果文件存在且可写则为真
-x文件名：如果文件存在且可执行则为真
-s文件名：如果文件存在且至少有一个字符则为真
-d文件名：如果文件存在且为目录则为真
-f文件名：如果文件存在且为普通文件则为真
-c文件名：如果文件存在且为字符型特殊文件则为真
-b文件名：如果文件存在且为块特殊文件则为真
另外，Linux还提供了与(“！”)、或(“-o)、非(“-a”)三个逻辑操作符用于将测试条件连接起来，其优先级为：“！”最高，“-a”次之，“-o”最低。
同时，bash也能完成简单的算术运算，格式如下：
$[expression]
例如：var1=2
var2=$[var1*10+1]
则：var2的值为21。
2.if条件语句
shell程序中的条件分支是通过if条件语句来实现的，其一般格式为：
if条件命令串
then
条件为真时的命令串
else
条件为假时的命令串
fi
3.for循环
for循环对一个变量的可能的值都执行一个命令序列。赋给变量的几个数值既可以在程序内以数值列表的形式提供，也可以在程序以外以位置参数的形式提供。for循环的一般格式为：
for变量名
[in数值列表]
do
若干个命令行
done
变量名可以是用户选择的任何字符串，如果变量名是var，则在in之后给出的数值将顺序替换循环命令列表中的$var。如果省略了in，则变量var的取值将是位置参数。对变量的每一个可能的赋值都将执行do和done之间的命令列表。
4.while和until循环
while和until命令都是用命令的返回状态值来控制循环的。While循环的一般格式为：
while
若干个命令行1
do
若干个命令行2
done
只要while的“若干个命令行1”中最后一个命令的返回状态为真，while循环就继续执行do...done之间的“若干个命令行2”。
until命令是另一种循环结构，它和while命令相似，其格式如下：
until
若干个命令行1
do
若干个命令行2
done
until循环和while循环的区别在于：while循环在条件为真时继续执行循环，而until则是在条件为假时继续执行循环。
Shell还提供了true和false两条命令用于建立无限循环结构的需要，它们的返回状态分别是总为0或总为非0
5.case条件选择
if条件语句用于在两个选项中选定一项，而case条件选择为用户提供了根据字符串或变量的值从多个选项中选择一项的方法，其格式如下：
case string in
exp-1)
若干个命令行1
；；
exp-2)
若干个命令行2
；；
……
*)
其他命令行
esac
shell通过计算字符串string的值，将其结果依次和表达式exp-1、exp-2等进行比较，直到找到一个匹配的表达式为止，如果找到了匹配项则执行它下面的命令直到遇到一对分号(；；)为止。
在case表达式中也可以使用shell的通配符(“*”、“？”、“[ ]”)。通常用“*”作为case命令的最后表达式以便使在前面找不到任何相应的匹配项时执行“其他命令行”的命令。
6.无条件控制语句break和continue
break用于立即终止当前循环的执行，而contiune用于不执行循环中后面的语句而立即开始下一个循环的执行。这两个语句只有放在do和done之间才有效。
7.函数定义
在shell中还可以定义函数。函数实际上也是由若干条shell命令组成的，因此它与shell程序形式上是相似的，不同的是它不是一个单独的进程，而是shell程序的一部分。函数定义的基本格式为：
functionname
{
若干命令行
}
调用函数的格式为：
functionname param1 param2……
shell函数可以完成某些例行的工作，而且还可以有自己的退出状态，因此函数也可以作为if、while等控制结构的条件。
在函数定义时不用带参数说明，但在调用函数时可以带有参数，此时shell将把这些参数分别赋予相应的位置参数$1、$2、...及$*。
8.命令分组
在shell中有两种命令分组的方法：“()”和“{}”，前者当shell执行()中的命令时将再创建一个新的子进程，然后这个子进程去执行圆括弧中的命令。当用户在执行某个命令时不想让命令运行时对状态集合(如位置参数、环境变量、当前工作目录等)的改变影响到下面语句的执行时，就应该把这些命令放在圆括弧中，这样就能保证所有的改变只对子进程产生影响，而父进程不受任何干扰；{}用于将顺序执行的命令的输出结果用于另一个命令的输入(管道方式)。当我们要真正使用圆括弧和花括弧时(如计算表达式的优先级)，则需要在其前面加上转义符(\)以便让shell知道它们不是用于命令执行的控制所用。
9.信号
trap命令用于在shell程序中捕捉到信号，之后可以有三种反应方式：
(1)执行一段程序来处理这一信号
(2)接受信号的默认操作
(3)忽视这一信号
trap对上面三种方式提供了三种基本形式：
第一种形式的trap命令在shell接收到signal list清单中数值相同的信号时，将执行双引号中的命令串。
trap 'commands' signal-list
trap "commands" signal-list
为了恢复信号的默认操作，使用第二种形式的trap命令：
trap signal-list
第三种形式的trap命令允许忽视信号：
trap " " signal-list
注意：
(1)对信号11(段违例)不能捕捉，因为shell本身需要捕捉该信号去进行内存的转储。
(2)在trap中可以定义对信号0的处理(实际上没有这个信号)，shell程序在其终止(如执行exit语句)时发出该信号。
(3)在捕捉到signal-list中指定的信号并执行完相应的命令之后，如果这些命令没有将shell程序终止的话，shell程序将继续执行收到信号时所执行的命令后面的命令，这样将很容易导致shell程序无法终止。
另外，在trap语句中，单引号和双引号是不同的，当shell程序第一次碰到trap语句时，将把commands中的命令扫描一遍。此时若commands是用单引号括起来的话，那么shell不会对commands中的变量和命令进行替换，否则commands中的变量和命令将用当时具体的值来替换。
五、运行shell程序的方法
用户可以用任何编辑程序来编写shell程序。因为shell程序是解释执行的，所以不需要编译装配成目标程序，按照shell编程的惯例，以bash为例，程序的第一行一般为“#！/bin/bash”，其中#表示该行是注释，叹号“！”告诉shell运行叹号之后的命令并用文件的其余部分作为输入，也就是运行/bin/bash并让/bin/bash去执行shell程序的内容。
执行shell程序的方法有三种：
(1)sh shell程序文件名
这种方法的命令格式为：
bash shell程序文件名
这实际上是调用一个新的bash命令解释程序，而把shell程序文件名作为参数传递给它。新启动的shell将去读指定的文件，执行文件中列出的命令，当所有的命令都执行完结束。该方法的优点是可以利用shell调试功能。
(2)sh
格式为：
bash
这种方式就是利用输入重定向，使shell命令解释程序的输入取自指定的程序文件。
(3)用chmod命令使shell程序成为可执行的
一个文件能否运行取决于该文件的内容本身可执行且该文件具有执行权。对于shell程序，当用编辑器生成一个文件时，系统赋予的许可权限都是644(rw-r-r--)，因此，当用户需要运行这个文件时，只需要直接键入文件名即可。
在这三种运行shell程序的方法中，最好按下面的方式选择：当刚建立一个shell程序，对它的正确性还没有把握时，应当使用第一种方式进行调试。当一个shell程序已经调试好时，应使用第三种方式把它固定下来，以后只要键入相应的文件名即可，并可被另一个程序所调用。
六、bash程序的调试
在编程过程中难免会出错，有的时候，调试程序比编写程序花费的时间还要多，shell程序同样如此。
shell程序的调试主要是利用bash命令解释程序的选择项。调用bash的形式是：
bash -选择项shell程序文件名
几个常用的选择项是：
-e：如果一个命令失败就立即退出
-n：读入命令但是不执行它们
-u：置换时把未设置的变量看作出错
-v：当读入shell输入行时把它们显示出来
-x：执行命令时把命令和它们的参数显示出来
上面的所有选项也可以在shell程序内部用“set -选择项”的形式引用，而“set +选择项”则将禁止该选择项起作用。如果只想对程序的某一部分使用某些选择项时，则可以将该部分用上面两个语句包围起来。
1.未置变量退出和立即退出
未置变量退出特性允许用户对所有变量进行检查，如果引用了一个未赋值的变量就终止shell程序的执行。shell通常允许未置变量的使用，在这种情况下，变量的值为空。如果设置了未置变量退出选择项，则一旦使用了未置变量就显示错误信息，并终止程序的运行。未置变量退出选择项为“-u”。
当shell运行时，若遇到不存在或不可执行的命令、重定向失败或命令非正常结束等情况时，如果未经重新定向，该出错信息会打印在终端屏幕上，而shell程序仍将继续执行。要想在错误发生时迫使shell程序立即结束，可以使用“-e”选项将shell程序的执行立即终止。
2.shell程序的跟踪
调试shell程序的主要方法是利用shell命令解释程序的“-v”或“-x”选项来跟踪程序的执行。“-v”选择项使shell在执行程序的过程中，把它读入的每一个命令行都显示出来，而“-x”选择项使shell在执行程序的过程中把它执行的每一个命令在行首用一个“+”加上命令名显示出来。并把每一个变量和该变量所取的值也显示出来，因此，它们的主要区别在于：在执行命令行之前无“-v”则打印出命令行的原始内容，而有“-v”则打印出经过替换后的命令行的内容。
除了使用shell的“-v”和“-x”选择项以外，还可以在shell程序内部采取一些辅助调试的措施。例如，可以在shell程序的一些关键地方使用echo命令把必要的信息显示出来，它的作用相当于C语言中的printf语句，这样就可以知道程序运行到什么地方及程序目前的状态。
七、bash的内部命令
bash命令解释程序包含了一些内部命令。内部命令在目录列表时是看不见的，它们由shell本身提供。常用的内部命令有：echo、eval、exec、export、readonly、read、shift、wait和点(.)。下面简单介绍其命令格式和功能。
1.echo
命令格式：echo arg
功能：在屏幕上打印出由arg指定的字符串。
2.eval
命令格式：eval args
功能：当shell程序执行到eval语句时，shell读入参数args，并将它们组合成一个新的命令，然后执行。
3.exec
命令格式：exec命令命令参数
功能：当shell执行到exec语句时，不会去创建新的子进程，而是转去执行指定的命令，当指定的命令执行完时，该进程，也就是最初的shell就终止了，所以shell程序中exec后面的语句将不再被执行。
4.export
命令格式：export变量名或：export变量名=变量值
功能：shell可以用export把它的变量向下带入子shell从而让子进程继承父进程中的环境变量。但子shell不能用export把它的变量向上带入父shell。
注意：不带任何变量名的export语句将显示出当前所有的export变量。
5.readonly
命令格式：readonly变量名
功能：将一个用户定义的shell变量标识为不可变的。不带任何参数的readonly命令将显示出所有只读的shell变量。
6.read
命令格式：read变量名表
功能：从标准输入设备读入一行，分解成若干字，赋值给shell程序内部定义的变量。
7.shift语句
功能：shift语句按如下方式重新命名所有的位置参数变量：$2成为$1，$3成为$2……在程序中每使用一次shift语句，都使所有的位置参数依次向左移动一个位置，并使位置参数“$#”减一，直到减到0。
8.wait
功能：是shell等待在后台启动的所有子进程结束。Wait的返回值总是真。
9.exit
功能：退出shell程序。在exit之后可有选择地指定一个数字作为返回状态。
10.“.”(点)
命令格式：. Shell程序文件名
功能：使shell读入指定的shell程序文件并依次执行文件中的所有语句。
2008年8月13日星期三
source insight 快捷键
退出程序 : Alt+F4
重画屏幕 : Ctrl+Alt+Space
完成语法 : Ctrl+E
复制一行 : Ctrl+K
恰好复制该位置右边的该行的字符 : Ctrl+Shift+K
复制到剪贴板 : Ctrl+Del
剪切一行 : Ctrl+U
剪切该位置右边的该行的字符 : Ctrl+;
剪切到剪贴板 : Ctrl+Shift+X
剪切一个字 : Ctrl+,
左边缩进 : F9
右边缩进 : F10
插入一行 : Ctrl+I
插入新行 : Ctrl+Enter
加入一行 : Ctrl+J
从剪切板粘贴 : Ctrl+Ins
粘贴一行 : Ctrl+P
重复上一个动作 : Ctrl+Y
重新编号 : Ctrl+R
重复输入 : Ctrl+\
替换 : Ctrl+H
智能重命名 : Ctrl+'
关闭文件 : Ctrl+W
关闭所有文件 : Ctrl+Shift+W
新建 : Ctrl+N
转到下一个文件 : Ctrl+Shift+N
打开 : Ctrl+O
重新装载文件 : Ctrl+Shift+O
另存为 : Ctrl+Shift+S
显示文件状态 : Shift+F10
激活语法窗口 : Alt+L
回到该行的开始 : Home
回到选择的开始 : Ctrl+Alt+[
到块的下面 : Ctrl+Shift+]
到块的上面 : Ctrl+Shift+[
书签 : Ctrl+M
到文件底部 : Ctrl+End, Ctrl+(KeyPad) End
到窗口底部 : (KeyPad) End (小键盘的END)
到一行的尾部 : End
到选择部分的尾部 : Ctrl+Alt+]
到下一个函数 : 小键盘 +
上一个函数 : 小键盘 -
后退 : Alt+,, Thumb 1 Click
后退到索引 : Alt+M
向前 : Alt+., Thumb 2 Click
转到行 : F5, Ctrl+G
转到下一个修改 : Alt+(KeyPad) +
转到下一个链接 : Shift+F9, Ctrl+Shift+L
回到前一个修改 : Alt+(KeyPad) -
跳到连接(就是语法串口列表的地方) : Ctrl+L
跳到匹配 : Alt+]
下一页 : PgDn, (KeyPad) PgDn
上一页 : PgUp, (KeyPad) PgUp
向上滚动半屏 : Ctrl+PgDn, Ctrl+(KeyPad) PgDn, (KeyPad) *
向下滚动半屏 : Ctrl+PgUp, Ctrl+(KeyPad) PgUp, (KeyPad) /
左滚 : Alt+Left
向上滚动一行 : Alt+Down
向下滚动一行 : Alt+Up
右滚 : Alt+Right
选择一块 : Ctrl+-
选择当前位置的左边一个字符 : Shift+Left
选择当前位置右边一个字符 : Shift+Right
选择一行 : Shift+F6
从当前行其开始向下选择 : Shift+Down
从当前行其开始向上选择 : Shift+Up
选择上页 : Shift+PgDn, Shift+(KeyPad) PgDn
选择下页 : Shift+PgUp, Shift+(KeyPad) PgUp
选择句子(直到遇到一个 . 为止) : Shift+F7, Ctrl+.
从当前位置选择到文件结束 : Ctrl+Shift+End
从当前位置选择到行结束 : Shift+End
从当前位置选择到行的开始 : Shift+Home
从当前位置选择到文件顶部 : Ctrl+Shift+Home
选择一个单词 : Shift+F5
选择左边单词 : Ctrl+Shift+Left
选择右边单词 : Ctrl+Shift+Right
到文件顶部 : Ctrl+Home, Ctrl+(KeyPad) Home
到窗口顶部 : (KeyPad) Home
到单词左边(也就是到一个单词的开始) : Ctrl+Left
到单词右边(到该单词的结束) : Ctrl+Right
排列语法窗口(有三种排列方式分别按1,2,3次) : Alt+F7
移除文件 : Alt+Shift+R
同步文件 : Alt+Shift+S
增量搜索(当用Ctrl + F 搜索,然后按F12就会转到下一个匹配) : F12
替换文件 : Ctrl+Shift+H
向后搜索 : F3
在多个文件中搜索 : Ctrl+Shift+F
向前搜索 : F4
搜索选择的(比如选择了一个单词,shift+F4将搜索下一个) : Shift+F4
搜索 : Ctrl+F
浏览本地语法(弹出该文件语法列表窗口,如果你光标放到一个变量/函数等,那么列出本文件该变量/函数等的信息) : F8
浏览工程语法 : F7, Alt+G
跳到基本类型(即跳到原型) : Alt+0
跳到定义出(也就是声明) : Ctrl+=, Ctrl+L Click (select), Ctrl+Double L Click
检查引用 : Ctrl+/
语法信息(弹出该语法的信息) : Alt+/, Ctrl+R Click (select)
高亮当前单词 : Shift+F8
语法窗口(隐藏/显示语法窗口) : Alt+F8
关闭窗口 : Alt+F6, Ctrl+F4
最后一个窗口 : Ctrl+Tab, Ctrl+Shift+Tab
2008年7月18日星期五
VC6经验小结
1. 在VC6中用了STL时，会出现了一堆的警告，google下原因：原来VC在编译模板代码的时候会将代码展开，所以虽然只写了个map<int, int>，但实际上在编译器看来，这个东西确是std::_Tree<int,struct std::pair<int const ,bool>,struct std::map<int,bool,struct std::less<int>,class std::allocator<bool> >::_Kfn,struct std::less<int>,class std::allocator<bool> >这个稀奇古怪的东西。很显然，代码中很普通的符号在编译器内部可能就会变得非常的怪非常的长，长得怪，编译器倒是不在乎的，但是VC6.0的编译器对长的符号就会报警告，说这玩意太长了，超过了255个字节，编译器要自动把这个符号裁减到255个字节。 虽然裁减了，但是绝大部分情况下都是没有问题的．
所以，就给在include <map>的前面，加上一句#pragma warning(disable: 4786)，于是，满世界都清静了。（注：在.NET中已经不会出现这些警告。）
2. 在普通程序中使用MFC的类：习惯了MFC中各种方便的类，又不愿意带着那个笨重的框架，可以在文件头添加#include，直接编译会报错，需要在Project Setting(Alt+F7)中的C/C++页中添加编译选项/MT。然后就可以放心的使用CString、CFile...
所以，就给在include <map>的前面，加上一句#pragma warning(disable: 4786)，于是，满世界都清静了。（注：在.NET中已经不会出现这些警告。）
2. 在普通程序中使用MFC的类：习惯了MFC中各种方便的类，又不愿意带着那个笨重的框架，可以在文件头添加#include
2008年5月12日星期一
重读设计模式（Design Patterns）
摘要：该看懂的时候没看懂。
从扉页上的记录看，已经买了两年了。想起刚买的时候，兴冲冲向达哥显摆的情景。当时又从他那弄到两本书，一本是《编程珠玑》，一本是《敏捷软件开发》，前者看完了，后来又看了一遍。后者只看了开头和结尾，中间挑着看了点。对这本Design Patterns小字，首先腹诽一下机械工业出版社：那么小的字，那么薄的纸！那一阵出的书都是这副德行。感觉性价比高的还是电工和清华。
这本书算来集中精力攻坚了三次。第一次，刚进实验室，有个师兄的论文就是这个。所以看的很有动力，不过也只看完了结构型模式，并且还是一知半解。英文的确限制了理解，书本身写的也晦涩，开始觉得没什么，后来发现读本通俗的书可以省下大量的时间。下了很多资料，其中有个是武大同龄人写的，很佩服，人家现在也在香港写siggraph了。
第二次，是下学期上软件结构，有这方面内容，看《Headfirst Design Patterns》，那本书写的很好，但是时间紧，就抓着看了有三天，很多东西看的很有趣，不用就忘光了。
第三次，这学期，同学那看到了《大话设计模式》，中文的，写的很有趣，就借来一本看看。长期的积累，对于其中的代码，竟然能够一口气读下来也没觉得困难，觉得似乎本来就应该是这样啊。参照着原来的那本原版dp。一下子全啃下来了。
以前老师说书是先越读越厚，然后越读越薄。自己这第一个阶段算是读下来了，第二个阶段什么时候结束？我也不知道。
总结，坚持不放弃，最终读出来了是不错，可是中间绵延了两年，为什么呢？就算是书难懂，当初坚持肯，多花时间也应该是能够读出来的，如果早就读出来了，那么在这两年的就可以少走很多弯路，体会其中的妙处。
现在这个问题依然存在着，数学的，算法的，多长时间没有完完整整的读完一本技术书籍了？能指望未来某一天因为某种契机而对这些知识突然顿悟么？应该抽出精力解决了，人生没有那么多的两年。
附：HDP里面记录的原则OO Basics
Abstraction
Encapsulation
Polymorphism
Inheritance
OO Principles
Encapsulate what varies.
Favor composition over inheritance.
Program to interfaces, not implementations.
Strive for loosely coupled designs between objects that interact.
Classes should be open for extension but closed for modification.
Depend on abstraction. Do not depend on concrete classes.
Only talk to your friends.
Don't call us, we'll call you.
A class should have only one reason to change.
从扉页上的记录看，已经买了两年了。想起刚买的时候，兴冲冲向达哥显摆的情景。当时又从他那弄到两本书，一本是《编程珠玑》，一本是《敏捷软件开发》，前者看完了，后来又看了一遍。后者只看了开头和结尾，中间挑着看了点。对这本Design Patterns小字，首先腹诽一下机械工业出版社：那么小的字，那么薄的纸！那一阵出的书都是这副德行。感觉性价比高的还是电工和清华。
这本书算来集中精力攻坚了三次。第一次，刚进实验室，有个师兄的论文就是这个。所以看的很有动力，不过也只看完了结构型模式，并且还是一知半解。英文的确限制了理解，书本身写的也晦涩，开始觉得没什么，后来发现读本通俗的书可以省下大量的时间。下了很多资料，其中有个是武大同龄人写的，很佩服，人家现在也在香港写siggraph了。
第二次，是下学期上软件结构，有这方面内容，看《Headfirst Design Patterns》，那本书写的很好，但是时间紧，就抓着看了有三天，很多东西看的很有趣，不用就忘光了。
第三次，这学期，同学那看到了《大话设计模式》，中文的，写的很有趣，就借来一本看看。长期的积累，对于其中的代码，竟然能够一口气读下来也没觉得困难，觉得似乎本来就应该是这样啊。参照着原来的那本原版dp。一下子全啃下来了。
以前老师说书是先越读越厚，然后越读越薄。自己这第一个阶段算是读下来了，第二个阶段什么时候结束？我也不知道。
总结，坚持不放弃，最终读出来了是不错，可是中间绵延了两年，为什么呢？就算是书难懂，当初坚持肯，多花时间也应该是能够读出来的，如果早就读出来了，那么在这两年的就可以少走很多弯路，体会其中的妙处。
现在这个问题依然存在着，数学的，算法的，多长时间没有完完整整的读完一本技术书籍了？能指望未来某一天因为某种契机而对这些知识突然顿悟么？应该抽出精力解决了，人生没有那么多的两年。
附：HDP里面记录的原则OO Basics
Abstraction
Encapsulation
Polymorphism
Inheritance
OO Principles
Encapsulate what varies.
Favor composition over inheritance.
Program to interfaces, not implementations.
Strive for loosely coupled designs between objects that interact.
Classes should be open for extension but closed for modification.
Depend on abstraction. Do not depend on concrete classes.
Only talk to your friends.
Don't call us, we'll call you.
A class should have only one reason to change.
2008年5月11日星期日
Google Reader高级技巧快速入门
英文原文：Quick Tips for Google Reader Power Users
中文译文：Google Reader高级技巧快速入门
使用Google Reader是很有效率的，通常情况下，从其他阅读器（如Bloglines）切换到Google Reader后，可以使用三分之一的时间阅读订阅，这样就提高了三倍的效率，这里我就介绍一些更有效使用Google Reader的技巧。
更好的阅读订阅内容，主要的方法是利用键盘的快捷键，当然不用也可以，但对于Google Reader的新用户来说这是很有用的。
1. 增加竖向的阅读区域 - 按F11可以使得浏览器以全屏方式工作，并移除了一些没用的按钮和菜单，浏览器的顶部和底部会增加很多空间，这就增加了垂直方向的阅读区域。
2. 增加横向的阅读区域 - 将Google Reader自己的侧栏删除可以增加更多的阅读空间，按u键就可实现这个功能。现在，就可以做到少使用滚动条就可以一气呵成地将整篇文章阅读完毕。当然，你还可以换一个大显示器，并设置显示分辨率卫高解析度屏幕，较大显示器就更适合阅读长篇文章了。
3. 切换到阅读所有栏目 - 这是一个传统的新闻阅读法，按ga，这样就不用点击每个Feed来查看文章了。否则，我要一个一个点下去看。将默认设置为“Sort by newest”，这样就可以迅速按照时间阅读文章。另外在设置中，将起始页面设置为“All Items”，这样一打开就可以立刻阅读。
4. 切换到Expanded View - 这样可以快速将文章扫描一遍。按1来切换。如果你想更快地阅读，可以按2只看文章标题。
5. 开始快速阅读 - 做好上面的设置，现在，你就可以快速进行阅读，以最快的速度一篇一篇的跳过文章，直到你看到一篇感兴趣的文章。有三种方法可以实现，在“expanded view”里，你可以按j向前，按k后退。另外你也可以按空格进行文章阅读，按Shift+空格后退，在列表模式下，使用n向前，使用p后退。
在设置中选择在expanded view模式自动标记已读，在侧边选择“only list updated”，将隐藏那么不更新的内容，这是一个很有特色的功能，不过每浏览20篇文章会有一些停顿，希望Google能解决这个问题。
6. 标记、分享、分类、阅读 - 当你读到一篇好文章后，你有5件事情可以做。将其标记（Star）以便日后使用，按s键（这和Gmail一样，以后你会看到所有标星的文章列表）。或者将文章分享给其他人（Share），按Shift-s键实现。或者你可以将其打标签分类，按t键，将其增加tags以便日后组织管理。或者你可以打开文章的原始链接地址查看完整信息，按v键，主要用于添加评论。或者将其标记为未读状态，按m键（有时可能有用）。
7. 刷新 - 当你按j了很多次，你会发现已经没有更多未读的文章了，这时按r键刷新列表，Google Reader可能会立刻带来一些新文章呢。
8. 查看标星的栏目 - 按gs键查看你标星的列表。你要将全部精力放在阅读标星的精选文章中，你或许会仔细阅读整篇文章的细节，或者为其写一篇博文。当你读完之后，还可以按s键取消星标。
中文译文：Google Reader高级技巧快速入门
使用Google Reader是很有效率的，通常情况下，从其他阅读器（如Bloglines）切换到Google Reader后，可以使用三分之一的时间阅读订阅，这样就提高了三倍的效率，这里我就介绍一些更有效使用Google Reader的技巧。
更好的阅读订阅内容，主要的方法是利用键盘的快捷键，当然不用也可以，但对于Google Reader的新用户来说这是很有用的。
1. 增加竖向的阅读区域 - 按F11可以使得浏览器以全屏方式工作，并移除了一些没用的按钮和菜单，浏览器的顶部和底部会增加很多空间，这就增加了垂直方向的阅读区域。
2. 增加横向的阅读区域 - 将Google Reader自己的侧栏删除可以增加更多的阅读空间，按u键就可实现这个功能。现在，就可以做到少使用滚动条就可以一气呵成地将整篇文章阅读完毕。当然，你还可以换一个大显示器，并设置显示分辨率卫高解析度屏幕，较大显示器就更适合阅读长篇文章了。
3. 切换到阅读所有栏目 - 这是一个传统的新闻阅读法，按ga，这样就不用点击每个Feed来查看文章了。否则，我要一个一个点下去看。将默认设置为“Sort by newest”，这样就可以迅速按照时间阅读文章。另外在设置中，将起始页面设置为“All Items”，这样一打开就可以立刻阅读。
4. 切换到Expanded View - 这样可以快速将文章扫描一遍。按1来切换。如果你想更快地阅读，可以按2只看文章标题。
5. 开始快速阅读 - 做好上面的设置，现在，你就可以快速进行阅读，以最快的速度一篇一篇的跳过文章，直到你看到一篇感兴趣的文章。有三种方法可以实现，在“expanded view”里，你可以按j向前，按k后退。另外你也可以按空格进行文章阅读，按Shift+空格后退，在列表模式下，使用n向前，使用p后退。
在设置中选择在expanded view模式自动标记已读，在侧边选择“only list updated”，将隐藏那么不更新的内容，这是一个很有特色的功能，不过每浏览20篇文章会有一些停顿，希望Google能解决这个问题。
6. 标记、分享、分类、阅读 - 当你读到一篇好文章后，你有5件事情可以做。将其标记（Star）以便日后使用，按s键（这和Gmail一样，以后你会看到所有标星的文章列表）。或者将文章分享给其他人（Share），按Shift-s键实现。或者你可以将其打标签分类，按t键，将其增加tags以便日后组织管理。或者你可以打开文章的原始链接地址查看完整信息，按v键，主要用于添加评论。或者将其标记为未读状态，按m键（有时可能有用）。
7. 刷新 - 当你按j了很多次，你会发现已经没有更多未读的文章了，这时按r键刷新列表，Google Reader可能会立刻带来一些新文章呢。
8. 查看标星的栏目 - 按gs键查看你标星的列表。你要将全部精力放在阅读标星的精选文章中，你或许会仔细阅读整篇文章的细节，或者为其写一篇博文。当你读完之后，还可以按s键取消星标。
2008年4月28日星期一
在Blogger中添加Piscasa相册（Add Photo Albums in Blogger）
Blogger是个好东西，什么功能都有，但必须得你自己添加。早就想加个相册了，通过一番查找，终于实现了这个功能，效果见右。对很多人来说这可能只是小儿科的东西，但因为在Blogger Help上并没有相关帮助，所以还是把实现过程写一下吧，方便后来人。
Embed Slideshow的确是一个好东东，特别是对于博客用户。但是中文版的picasa尚不支持这个功能，我们只能曲线救国了：首先在http://picasaweb.google.com登陆你的picasa相册，然后点击设置，在语言偏好里选择English (United States)（注意，一定要选择English (United States)，选择English (UK)都不行），点击保存设置。接下来点击水平导航栏上的My Photos，进入想公开的相册，点击左侧的Embed Slideshow，在Select slideshow size下拉框里选择好宽度，接着将Embed slideshow下面文本框里的代码复制。
如果你已经有公开相册了，那么可以直接点击右边相册右下角的图片，选择相册说明下方的"Get your own"，一样可以进入公开相册，然后设置好参数之后复制下面文本框中的代码。
进入布局->页面元素->添加页面元素->HTML/JavaScript，选添加到博客，给相册起好名字之后把复制的代码粘贴到下面的代码栏中，就跟添加翻译工具栏一样。Ok
最终效果如右图，参数是经过调整的，去掉了上下的富余，整体效果不错。
补充：后来发现添加页面元素中新增了一个“幻灯片”，可直接同piscasa相连，功能类似，不过没有上面做完的那样好看。
Embed Slideshow的确是一个好东东，特别是对于博客用户。但是中文版的picasa尚不支持这个功能，我们只能曲线救国了：首先在http://picasaweb.google.com登陆你的picasa相册，然后点击设置，在语言偏好里选择English (United States)（注意，一定要选择English (United States)，选择English (UK)都不行），点击保存设置。接下来点击水平导航栏上的My Photos，进入想公开的相册，点击左侧的Embed Slideshow，在Select slideshow size下拉框里选择好宽度，接着将Embed slideshow下面文本框里的代码复制。
如果你已经有公开相册了，那么可以直接点击右边相册右下角的图片，选择相册说明下方的"Get your own"，一样可以进入公开相册，然后设置好参数之后复制下面文本框中的代码。
进入布局->页面元素->添加页面元素->HTML/JavaScript，选添加到博客，给相册起好名字之后把复制的代码粘贴到下面的代码栏中，就跟添加翻译工具栏一样。Ok
最终效果如右图，参数是经过调整的，去掉了上下的富余，整体效果不错。
补充：后来发现添加页面元素中新增了一个“幻灯片”，可直接同piscasa相连，功能类似，不过没有上面做完的那样好看。
2008年4月21日星期一
获取信息的有关Windows API
1.窗口信息
MS为我们提供了打开特定桌面和枚举桌面窗口的函数。
hDesk=OpenDesktop(lpszDesktop,0,FALSE,DESKTOP_ENUMERATE);
//打开我们默认的Default桌面；
EnumDesktopWindows(hDesk,(WNDENUMPROC)EnumWindowProc,0);
//枚举打开桌面上的所有窗口，由回调函数实现。
BOOL __stdcall EnumWindowProc(HWND, LPARAM);
//在回调函数中，我们可以获得窗口的标题和相关进程，线程信息；
GetWindowText(hWnd,szWindowText,dwMaxCount);
GetWindowThreadProcessId(hWnd,&dwPID);
2.设备驱动器信息(服务和设备驱动器差不多，在此不做重复)
设备驱动信息由服务控制管理器(SCM)来管理，需要打开服务控制管理器，并枚举所有的设备驱动器。
OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
//以所有权限打开服务控制管理器；
EnumServicesStatus(schManager,dwDeviceType,dwDeviceState,
EnumStatus,dwBufSize,&dwBytesNeeded,
&dwDevicesReturned,&dwResumeHandle))
//枚举所有设备的当前状态；
CloseServiceHandle(schManager);
//记住，在结束访问后要关闭服务句柄；
OpenService(schManager,szDeviceName,SERVICE_ALL_ACCESS);
//打开特定的设备驱动器；
QueryServiceConfig(schDevice,lpDeviceConfig,
1024*8,&dwBytesNeeded)；
//查询驱动器的服务配置信息；
QueryServiceStatus(schDevice,&DeviceStatus)；
//查询设备驱动器的当前状态；
QueryServiceConfig2(schDevice,SERVICE_CONFIG_DESCRIPTION,
(LPBYTE)lpDeviceDescription,8*1024,&dwBytesNeeded)
//查询设备的描述信息；
StartService(schDevice,0,NULL)；
//启动设备；
ControlService(schDevice,SERVICE_CONTROL_STOP,&DeviceStatus)；
//停止设备；
DeleteService(schDevice)；
//删除设备；
3.磁盘信息
我们希望获得系统所有磁盘的信息，包括软盘，硬盘，光盘等等；
GetLogicalDriveStrings(dwBufferLength,lpBuffer);
//获得逻辑设备的信息；
GetVolumeInformation(lpRootPathName,lpVolumeNameBuffer,
dwVolumeNameSize,&dwVolumeSerialNumber,
&dwMaximumComponentLength,&dwFileSystemFlags,
lpFileSystemNameBuffer,dwFileSystemNameSize);
//获得磁盘卷信息，包括卷名称和格式类型；
GetDiskFreeSpaceEx(lpRootPathName,&FreeBytesAvailable,
&TotalNumberOfBytes,&TotalNumberOfFreeBytes);
//探测磁盘的空间使用情况；
4.环境变量
我们可以从注册表中获得环境块的信息：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment，当然要使用注册表的函数。
RegOpenKeyEx(HKEY_LOCAL_MACHINE,RegKey,0,KEY_QUERY_VALUE,&hKey);
//打开注册表的键；
RegEnumValue(hKey,dwIndex,EnvironVariable,
&dwVariableLength,NULL,NULL,NULL,NULL);
//查询我们需要的信息值；
GetEnvironmentVariable(EnvironVariable,EnvironString,1024);
//获得环境变量的字符串信息；
5.事件记录信息
OpenEventLog(NULL,szLog);
//打开时间日志记录；
GetOldestEventLogRecord(hEvent,&dwThisRecord);
//获得最新的日志信息，以便继续查找；
ReadEventLog(hEvent,EVENTLOG_FORWARDS_READ │ EVENTLOG_SEQUENTIAL_READ,
0,pEventLogRecord,1024*32,&dwRead,&dwNeeded)
//读去日志信息；
LookupAccountSid(NULL,pSid,szName,&dwName,szDomain,&dwDomain,&SNU)；
//获取账户的SID，以便获得账户的用户名称；
GetNumberOfEventLogRecords(hEvent,&dwTotal)；
//获得事件日志的总数；
CloseEventLog(hEvent);
//不要忘记关闭事件句柄；
6.网络共享
我们使用第二等级的网络共享搜索；
NetShareEnum(NULL,dwLevel,(PBYTE *)&pBuf,MAX_PREFERRED_LENGTH,&entriesread,&totalentries,&resume);
//列举所有的共享目录及相关信息；
NetApiBufferFree(pBuf);
//释放缓冲区；
NetShareDel(NULL,(char *)lpShareNameW,0);
//删除网络共享目录；
7.网络适配器信息
我们要探测NIC的信息和网络流量；
GetAdaptersInfo(&AdapterInfo,&OutBufLen);
//获取适配器信息；
8.系统性能
获取系统的存储器使用情况；
GetPerformanceInfo(&PerfInfo,sizeof(PERFORMACE_INFORMATION))
//获取系统性能信息；
9.进程/线程/模块信息
在此我们使用工具帮助函数(ToolHelp32)和系统
OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY │ TOKEN_ADJUST_PRIVILEGES,&hToken)；
//打开进程的令牌，提升权限；
AdjustTokenPrivileges(hToken,FALSE,&TokenPrivileges,sizeof(TOKEN_PRIVILEGES),NULL,NULL);
//将进程的权限提升到支持调试(Debug)；
CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
//创建进程的快照；
Process32First(hProcessSnap,&ProcessEntry32)；
Process32First(hProcessSnap,&ProcessEntry32)；
//枚举所有进程；
OpenProcess(PROCESS_QUERY_INFORMATION,FALSE,ProcessEntry32.th32ProcessID);
//打开特定进程，以查询进程相关信息；
GetProcessTimes(hProcess,&CreateTime,&ExitTime,&KernelTime,&UserTime)；
//获取进程的时间信息；
GetProcessMemoryInfo(hProcess,&PMCounter,sizeof(PMCounter))；
//获取进程的存储区信息；
GetPriorityClass(hProcess);
//获取进程的优先权；
GetProcessIoCounters(hProcess,&IoCounters)；
//获取进程的IO使用情况；
CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessID);
//创建模块快照；
Module32First(hModuleSnap, &ModuleEntry32)；
Module32Next(hModuleSnap, &ModuleEntry32)；
//枚举进程模块信息；
CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
//创建线程快照；
Thread32First(hThreadSnap, &ThreadEntry32)；
Thread32Next(hThreadSnap, &ThreadEntry32)；
//枚举线程信息；
OpenThread(THREAD_ALL_ACCESS,FALSE,ThreadEntry32.th32ThreadID);
//打开线程，须自己获得此函数地址；
TerminateProcess(hProcess,0)；
//终止进程；
SuspendThread(hThread);
//悬挂线程；
ResumeThread(hThread);
//激活线程；
10.关机
AdjustTokenPrivileges(hToken,FALSE,&TokenPrivileges,sizeof(TOKEN_PRIVILEGES),NULL,NULL);
//调整进程令牌，使其支持关机；
ExitWindowsEx(EWX_LOGOFF,0)；
//注销系统；
LockWorkStation()；
//锁定系统；
InitiateSystemShutdown(NULL,szMessage,dwTimeout,FALSE,bSig)；
//支持到记时和消息显示的关机/重启；
SetSystemPowerState(bSig,FALSE)；
//系统休眠/冬眠；
11.用户信息
NetUserEnum(NULL,dwLevel,FILTER_NORMAL_ACCOUNT,(LPBYTE*)&pBuf,
dwPrefMaxLen,&dwEntriesRead,&dwTotalEntries,&dwResumeHandle);
//枚举系统用户信息；
NetUserDel(NULL,lpUserNameW)；
//删除指定用户；
12.系统版本信息
GetVersionEx((LPOSVERSIONINFO)&osviex)；
//获取操作系统的版本信息；
我们也可以通过注册表(HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion)获取相关信息：
GetTickCount();
//获取开机时间；
GetComputerName(szInfo,&dwInfo);
//获取计算机名称；
GetUserName(szInfo,&dwInfo);
//获取计算机用户名；
GetWindowsDirectory(szInfo,MAX_PATH+1);
//获取Windows目录；
GetSystemDirectory(szInfo,MAX_PATH+1);
//获取系统目录；
MS为我们提供了打开特定桌面和枚举桌面窗口的函数。
hDesk=OpenDesktop(lpszDesktop,0,FALSE,DESKTOP_ENUMERATE);
//打开我们默认的Default桌面；
EnumDesktopWindows(hDesk,(WNDENUMPROC)EnumWindowProc,0);
//枚举打开桌面上的所有窗口，由回调函数实现。
BOOL __stdcall EnumWindowProc(HWND, LPARAM);
//在回调函数中，我们可以获得窗口的标题和相关进程，线程信息；
GetWindowText(hWnd,szWindowText,dwMaxCount);
GetWindowThreadProcessId(hWnd,&dwPID);
2.设备驱动器信息(服务和设备驱动器差不多，在此不做重复)
设备驱动信息由服务控制管理器(SCM)来管理，需要打开服务控制管理器，并枚举所有的设备驱动器。
OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
//以所有权限打开服务控制管理器；
EnumServicesStatus(schManager,dwDeviceType,dwDeviceState,
EnumStatus,dwBufSize,&dwBytesNeeded,
&dwDevicesReturned,&dwResumeHandle))
//枚举所有设备的当前状态；
CloseServiceHandle(schManager);
//记住，在结束访问后要关闭服务句柄；
OpenService(schManager,szDeviceName,SERVICE_ALL_ACCESS);
//打开特定的设备驱动器；
QueryServiceConfig(schDevice,lpDeviceConfig,
1024*8,&dwBytesNeeded)；
//查询驱动器的服务配置信息；
QueryServiceStatus(schDevice,&DeviceStatus)；
//查询设备驱动器的当前状态；
QueryServiceConfig2(schDevice,SERVICE_CONFIG_DESCRIPTION,
(LPBYTE)lpDeviceDescription,8*1024,&dwBytesNeeded)
//查询设备的描述信息；
StartService(schDevice,0,NULL)；
//启动设备；
ControlService(schDevice,SERVICE_CONTROL_STOP,&DeviceStatus)；
//停止设备；
DeleteService(schDevice)；
//删除设备；
3.磁盘信息
我们希望获得系统所有磁盘的信息，包括软盘，硬盘，光盘等等；
GetLogicalDriveStrings(dwBufferLength,lpBuffer);
//获得逻辑设备的信息；
GetVolumeInformation(lpRootPathName,lpVolumeNameBuffer,
dwVolumeNameSize,&dwVolumeSerialNumber,
&dwMaximumComponentLength,&dwFileSystemFlags,
lpFileSystemNameBuffer,dwFileSystemNameSize);
//获得磁盘卷信息，包括卷名称和格式类型；
GetDiskFreeSpaceEx(lpRootPathName,&FreeBytesAvailable,
&TotalNumberOfBytes,&TotalNumberOfFreeBytes);
//探测磁盘的空间使用情况；
4.环境变量
我们可以从注册表中获得环境块的信息：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment，当然要使用注册表的函数。
RegOpenKeyEx(HKEY_LOCAL_MACHINE,RegKey,0,KEY_QUERY_VALUE,&hKey);
//打开注册表的键；
RegEnumValue(hKey,dwIndex,EnvironVariable,
&dwVariableLength,NULL,NULL,NULL,NULL);
//查询我们需要的信息值；
GetEnvironmentVariable(EnvironVariable,EnvironString,1024);
//获得环境变量的字符串信息；
5.事件记录信息
OpenEventLog(NULL,szLog);
//打开时间日志记录；
GetOldestEventLogRecord(hEvent,&dwThisRecord);
//获得最新的日志信息，以便继续查找；
ReadEventLog(hEvent,EVENTLOG_FORWARDS_READ │ EVENTLOG_SEQUENTIAL_READ,
0,pEventLogRecord,1024*32,&dwRead,&dwNeeded)
//读去日志信息；
LookupAccountSid(NULL,pSid,szName,&dwName,szDomain,&dwDomain,&SNU)；
//获取账户的SID，以便获得账户的用户名称；
GetNumberOfEventLogRecords(hEvent,&dwTotal)；
//获得事件日志的总数；
CloseEventLog(hEvent);
//不要忘记关闭事件句柄；
6.网络共享
我们使用第二等级的网络共享搜索；
NetShareEnum(NULL,dwLevel,(PBYTE *)&pBuf,MAX_PREFERRED_LENGTH,&entriesread,&totalentries,&resume);
//列举所有的共享目录及相关信息；
NetApiBufferFree(pBuf);
//释放缓冲区；
NetShareDel(NULL,(char *)lpShareNameW,0);
//删除网络共享目录；
7.网络适配器信息
我们要探测NIC的信息和网络流量；
GetAdaptersInfo(&AdapterInfo,&OutBufLen);
//获取适配器信息；
8.系统性能
获取系统的存储器使用情况；
GetPerformanceInfo(&PerfInfo,sizeof(PERFORMACE_INFORMATION))
//获取系统性能信息；
9.进程/线程/模块信息
在此我们使用工具帮助函数(ToolHelp32)和系统
OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY │ TOKEN_ADJUST_PRIVILEGES,&hToken)；
//打开进程的令牌，提升权限；
AdjustTokenPrivileges(hToken,FALSE,&TokenPrivileges,sizeof(TOKEN_PRIVILEGES),NULL,NULL);
//将进程的权限提升到支持调试(Debug)；
CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
//创建进程的快照；
Process32First(hProcessSnap,&ProcessEntry32)；
Process32First(hProcessSnap,&ProcessEntry32)；
//枚举所有进程；
OpenProcess(PROCESS_QUERY_INFORMATION,FALSE,ProcessEntry32.th32ProcessID);
//打开特定进程，以查询进程相关信息；
GetProcessTimes(hProcess,&CreateTime,&ExitTime,&KernelTime,&UserTime)；
//获取进程的时间信息；
GetProcessMemoryInfo(hProcess,&PMCounter,sizeof(PMCounter))；
//获取进程的存储区信息；
GetPriorityClass(hProcess);
//获取进程的优先权；
GetProcessIoCounters(hProcess,&IoCounters)；
//获取进程的IO使用情况；
CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessID);
//创建模块快照；
Module32First(hModuleSnap, &ModuleEntry32)；
Module32Next(hModuleSnap, &ModuleEntry32)；
//枚举进程模块信息；
CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
//创建线程快照；
Thread32First(hThreadSnap, &ThreadEntry32)；
Thread32Next(hThreadSnap, &ThreadEntry32)；
//枚举线程信息；
OpenThread(THREAD_ALL_ACCESS,FALSE,ThreadEntry32.th32ThreadID);
//打开线程，须自己获得此函数地址；
TerminateProcess(hProcess,0)；
//终止进程；
SuspendThread(hThread);
//悬挂线程；
ResumeThread(hThread);
//激活线程；
10.关机
AdjustTokenPrivileges(hToken,FALSE,&TokenPrivileges,sizeof(TOKEN_PRIVILEGES),NULL,NULL);
//调整进程令牌，使其支持关机；
ExitWindowsEx(EWX_LOGOFF,0)；
//注销系统；
LockWorkStation()；
//锁定系统；
InitiateSystemShutdown(NULL,szMessage,dwTimeout,FALSE,bSig)；
//支持到记时和消息显示的关机/重启；
SetSystemPowerState(bSig,FALSE)；
//系统休眠/冬眠；
11.用户信息
NetUserEnum(NULL,dwLevel,FILTER_NORMAL_ACCOUNT,(LPBYTE*)&pBuf,
dwPrefMaxLen,&dwEntriesRead,&dwTotalEntries,&dwResumeHandle);
//枚举系统用户信息；
NetUserDel(NULL,lpUserNameW)；
//删除指定用户；
12.系统版本信息
GetVersionEx((LPOSVERSIONINFO)&osviex)；
//获取操作系统的版本信息；
我们也可以通过注册表(HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion)获取相关信息：
GetTickCount();
//获取开机时间；
GetComputerName(szInfo,&dwInfo);
//获取计算机名称；
GetUserName(szInfo,&dwInfo);
//获取计算机用户名；
GetWindowsDirectory(szInfo,MAX_PATH+1);
//获取Windows目录；
GetSystemDirectory(szInfo,MAX_PATH+1);
//获取系统目录；
2007年11月13日星期二
为什么会出现LNK2005,LNK1169错误
许多Visual C++的使用者都碰到过LNK2005:symbol already defined和LNK1169:one or more multiply defined symbols found这样的链接错误，而且通常是在使用第三方库时遇到的。对于这个问题，有的朋友可能不知其然，而有的朋友可能知其然却不知其所以然，本文就试图为大家彻底解开关于它的种种疑惑。
大家都知道，从C/C++源程序到可执行文件要经历两个阶段:
(1)编译器将源文件编译成汇编代码，然后由汇编器(assembler)翻译成机器指令(再加上其它相关信息)后输出到一个个目标文件(object file,VC的编译器编译出的目标文件默认的后缀名是.obj)中；
(2)链接器(linker)将一个个的目标文件(或许还会有若干程序库)链接在一起生成一个完整的可执行文件。
编译器编译源文件时会把源文件的全局符号(global symbol)分成强(strong)和弱(weak)两类传给汇编器，而随后汇编器则将强弱信息编码并保存在目标文件的符号表中。那么何谓强弱呢？编译器认为函数与初始化了的全局变量都是强符号，而未初始化的全局变量则成了弱符号。比如有这么个源文件:
其中main、buf是强符号，p是弱符号，而errorno则非强非弱，因为它只是个外部变量的使用声明。
有了强弱符号的概念，链接器(Unix平台)就会按如下规则(参考[1]，p549~p550)处理与选择被多次定义的全局符号:
规则1: 不允许强符号被多次定义(即不同的目标文件中不能有同名的强符号)；
规则2: 如果一个符号在某个目标文件中是强符号，在其它文件中都是弱符号，那么选择强符号；
规则3: 如果一个符号在所有目标文件中都是弱符号，那么选择其中任意一个；
虽然上述3条针对的是Unix平台的链接器，但据作者试验，至少VC6.0的linker也遵守这些规则。由此可知多个目标文件不能重复定义同名的函数与初始化了的全局变量，否则必然导致LNK2005和LNK1169两种链接错误。可是，有的时候我们并没有在自己的程序中发现这样的重定义现象，却也遇到了此种链接错误，这又是何解？嗯，问题稍微有点儿复杂，容我慢慢道来。
众所周知，ANSI C/C++ 定义了相当多的标准函数，而它们又分布在许多不同的目标文件中，如果直接以目标文件的形式提供给程序员使用的话，就需要他们确切地知道哪个函数存在于哪个目标文件中，并且在链接时显式地指定目标文件名才能成功地生成可执行文件，显然这是一个巨大的负担。所以C语言提供了一种将多个目标文件打包成一个文件的机制，这就是静态程序库(static library)。开发者在链接时只需指定程序库的文件名，链接器就会自动到程序库中寻找那些应用程序确实用到的目标模块，并把(且只把)它们从库中拷贝出来参与构建可执行文件。几乎所有的C/C++开发系统都会把标准函数打包成标准库提供给开发者使用(有不这么做的吗？)。
程序库为开发者带来了方便，但同时也是某些混乱的根源。我们来看看链接器(Unix平台)是如何解析(resolve)对程序库的引用的(参考[1]，p556)。
在符号解析(symbol resolution)阶段，链接器按照所有目标文件和库文件出现在命令行中的顺序从左至右依次扫描它们，在此期间它要维护若干个集合:(1)集合E是将被合并到一起组成可执行文件的所有目标文件集合；(2)集合D是所有之前已被加入E的目标文件定义的符号集合；(3)集合U是未解析符号(unresolved symbols，即那些被E中目标文件引用过但在D中还不存在的符号)的集合。一开始，E、D、U都是空的。
(1): 对命令行中的每一个输入文件f，链接器确定它是目标文件还是库文件，如果它是目标文件，就把f加入到E，并把f中未解析的符号和已定义的符号分别加入到U、D集合中，然后处理下一个输入文件。
(2): 如果f是一个库文件，链接器会尝试把U中的所有未解析符号与f中各目标模块定义的符号进行匹配。如果某个目标模块m定义了一个U中的未解析符号，那么就把m加入到E中，并把m中未解析的符号和已定义的符号分别加入到U、D集合中。不断地对f中的所有目标模块重复这个过程直至到达一个不动点(fixed point)，此时U和D不再变化。而那些未加入到E中的f里的目标模块就被简单地丢弃，链接器继续处理下一输入文件。
(3): 当扫描完所有输入文件时如果U非空或者有同名的符号被多次加入D，链接器报告错误信息并退出。否则，它把E中的所有目标文件合并在一起生成可执行文件。
上述规则针对的是Unix平台链接器，而VC(至少VC6.0)linker则有相当的不同: 它首先依次处理命令行中出现的所有目标文件，然后依照顺序不停地扫描所有的库文件，直至U为空或者某遍(从头到尾依次把所有的库文件扫描完称为一遍)扫描过程中U、D无任何变化时结束扫描，此刻再根据U是否为空以及是否有同名符号重复加入D来决定是出错退出还是生成可执行文件。很明显Unix链接器对输入文件在命令行中出现的顺序十分敏感，而VC的算法则可最大限度地减少文件顺序对链接的影响。作者不清楚Unix下新的开发工具是否已经改进了相应的做法，欢迎有实践经验的朋友补充这方面的信息(补充于2005年10月10日: 经试验，使用gcc 3.2.3的MinGW 3.1.0的链接器表现与参考[1]描述的一致)。
VC带的编译器是cl.exe，它有这么几个与标准程序库有关的选项: /ML、/MLd、/MT、/MTd、/MD、/MDd。这些选项告诉编译器应用程序想使用什么版本的C标准程序库。/ML(缺省选项)对应单线程静态版的标准程序库(libc.lib)；/MT对应多线程静态版标准库(libcmt.lib)，此时编译器会自动定义_MT宏；/MD对应多线程DLL版(导入库msvcrt.lib，DLL是msvcrt.dll)，编译器自动定义_MT和_DLL两个宏。后面加d的选项都会让编译器自动多定义一个_DEBUG宏，表示要使用对应标准库的调试版，因此/MLd对应调试版单线程静态标准库(libcd.lib)，/MTd对应调试版多线程静态标准库(libcmtd.lib)，/MDd对应调试版多线程DLL标准库(导入库msvcrtd.lib，DLL是msvcrtd.dll)。虽然我们的确在编译时明白无误地告诉了编译器应用程序希望使用什么版本的标准库，可是当编译器干完了活，轮到链接器开工时它又如何得知一个个目标文件到底在思念谁？为了传递相思，我们的编译器就干了点秘密的勾当。在cl编译出的目标文件中会有一个专门的区域(关心这个区域到底在文件中什么地方的朋友可以参考COFF和PE文件格式)存放一些指导链接器如何工作的信息，其中有一项就叫缺省库(default library)，它指定了若干个库文件名，当链接器扫描该目标文件时将按照它们在目标模块中出现的顺序处理这些库名: 如果该库在当前输入文件列表中还不存在，那么便把它加入到输入文件列表末尾，否则略过。说到这里，我们先来做个小实验。写个顶顶简单的程序，然后保存为main.c :
用下面这个命令编译main.c(什么？你从不用命令行来编译程序？这个......) :
cl /c main.c
/c是告诉cl只编译源文件，不用链接。因为/ML是缺省选项，所以上述命令也相当于: cl /c /ML main.c 。如果没什么问题的话(要出了问题才是活见鬼！当然除非你的环境变量没有设置好，这时你应该去VC的bin目录下找到vcvars32.bat文件然后运行它。)，当前目录下会出现一个main.obj文件，这就是我们可爱的目标文件。随便用一个文本编辑器打开它(是的，文本编辑器，大胆地去做别害怕)，搜索"defaultlib"字符串，通常你就会看到这样的东西: "-defaultlib:LIBC -defaultlib:OLDNAMES"。啊哈，没错，这就
是保存在目标文件中的缺省库信息。我们的目标文件显然指定了两个缺省库，一个是单线程静态版标准库libc.lib(这与/ML选项相符)；一个是oldnames.lib(它是为了兼容微软以前的C/C++开发系统，基本不用了，为了简化讨论可以忽略它)。另外，如果在源程序中用了
/* xxxx代表实际的库文件名 */
#pragma comment(lib,"xxxx")
编译指示命令(compiler directive)指定要链接的库，那么这个信息也会被保存到目标文件的缺省库信息项中，且位于缺省标准库之前。如果有多个这样的命令，那么对应库名在目标文件中出现的顺序与它们在源程序中出现的顺序完全一致(且都在缺省标准库之前)。
VC的链接器是link.exe，因为main.obj保存了缺省库信息，所以可以用
link main.obj libc.lib
或者
link main.obj
来生成可执行文件main.exe，这两个命令是等价的。但是如果你用
link main.obj libcd.lib
的话，链接器会给出一个警告: "warning LNK4098: defaultlib "LIBC" conflicts with use of other libs; use /NODEFAULTLIB:library"，因为你显式指定的标准库版本与目标文件的缺省值不一致。通常来说，应该保证链接器合并的所有目标文件指定的缺省标准库版本一致，否则编译器一定会给出上面的警告，而LNK2005和LNK1169链接错误则有时会出现有时不会。那么这个有时到底是什么时候？呵呵，别着急，下面的一切正是为喜欢追根究底的你准备的。
建一个源文件，就叫mylib.c，内容如下:
用
cl /c /MLd mylib.c
命令编译，注意/MLd选项是指定libcd.lib为默认标准库。lib.exe是VC自带的用于将目标文件打包成程序库的命令，所以我们可以用
lib /OUT:my.lib mylib.obj
将mylib.obj打包成库，输出的库文件名是my.lib。接下来把main.c改成:
用
cl /c main.c
编译，然后用
link main.obj my.lib
进行链接。这个命令能够成功地生成main.exe而不会产生LNK2005和LNK1169链接错误，你仅仅是得到了一条警告信息:"warning LNK4098: defaultlib "LIBCD" conflicts with use of other libs; use /NODEFAULTLIB:library"。我们根据前文所述的扫描规则来分析一下链接器此时做了些啥(加一个/VERBOSE选项就可以看到详尽的链接过程，但要注意，几乎所有的C编译器都会在符号前加一个下划线后再输出，所以在目标文件和链接输出信息中看到的符号名都比在源程序中见到的多出一个'_'，此点不可不察。)。
一开始E、U、D都是空集。链接器首先扫描main.obj，把它的默认标准库libc.lib加入到输入文件列表末尾，它自己加入E集合，同时未解析的foo加入U，main加入D。接着扫描my.lib，因为这是个库，所以会拿当前U中的所有符号(当然现在就一个foo)与my.lib中的所有目标模块(当然也只有一个mylib.obj)依次匹配，看是否有模块定义了U中的符号。结果mylib.obj确实定义了foo，于是它加入到E，foo从U转移到D，未解析的printf加入到U，指定的默认标准库libcd.lib也加到输入文件列表末尾(在libc.lib之后)。不断地在my.lib库的各模块上进行迭代以匹配U中的符号，直到U、D都不再变化。很明显，现在就已经到达了这么一个不动点，所以接着扫描下一个输入文件，就是libc.lib。链接器发现libc.lib里的printf.obj里定义有printf，于是printf从U移到D，printf.obj加入到E，它定义的所有符号加入到D，它里头的未解析符号加入到U。如果链接时没有指定/ENTRY(程序入口点选项)，那么链接器默认的入口点就是函数mainCRTStartup(GUI程序的默认入口点则是WinMainCRTStartup)，它在crt0.obj中被定义，所以crt0.obj及它直接或间接引用的模块(比如malloc.obj、free.obj等)都被加入到E中，这些目标模块指定的默认库(只crt0init.obj指定了kernel32.lib)加到输入文件列表末尾，同时更新U和D。不断匹配libc.lib中各模块直至到达不动点，然后处理libcd.lib，但是它里面的所有目标模块都没有定义U中的任何一个符号，所以链接器略过它进入到最后一个输入文件kernel32.lib。事实上，U中已有和将要加入的未解析符号都可以在其中找到定义，那么当处理完kernel32.lib时，U必然为空，于是链接器合并E中的所有模块生成可执行文件。
上文描述了虽然各目标模块指定了不同版本的缺省标准库但仍然链接成功的例子，接下来你将目睹因为这种不严谨而导致的悲惨失败。
修改mylib.c成这个样子:
其中_malloc_dbg不是ANSI C的标准库函数，它是VC标准库提供的malloc的调试版，与相关函数配套能帮助开发者抓各种内存错误。使用它一定要定义_DEBUG宏，否则预处理器会把它自动转为malloc。继续用
cl /c /MLd mylib.c
lib /OUT:my.lib mylib.obj
编译打包。当再次用
link main.obj my.lib
进行链接时，我们看到了什么？天哪，一堆的LNK2005加上个贵为"fatal error"的LNK1169垫底，当然还少不了那个LNK4098。链接器是不是疯了？不，你冤枉可怜的链接器了，我拍胸脯保证它可是一直在尽心尽责地照章办事。
一开始E、U、D为空，链接器扫描main.obj，把libc.lib加到输入文件列表末尾，把main.obj加进E，把foo加进U，把main加进D。接着扫描my.lib，于是mylib.obj加入E，libcd.lib加到输入文件列表末尾，foo从U转移到D，_malloc_dbg加进U。然后扫描libc.lib，这时会发现libc.lib里任何一个目标模块都没有定义_malloc_dbg(它只在调试版的标准库中存在)，所以不会有任何一个模块因为_malloc_dbg而加入E。但因为libc.lib中的crt0.obj定义了默认入口点函数mainCRTStartup，所以crt0.obj及它直接或间接引用的模块(比如malloc.obj、free.obj等)都被加入到E中，这些目标模块指定的默认库(只crt0init.obj指定了kernel32.lib)加到输入文件列表末尾，同时更新U和D。不断匹配libc.lib中各模块直至到达不动点后再处理libcd.lib，发现dbgheap.obj定义了_malloc_dbg，于是dbgheap.obj加入到E，它的未解析符号加入U，它定义的所有其它符号加入D，这时灾难便来了。之前malloc等符号已经在D中(随着libc.lib里的malloc.obj加入E而加入的)，而dbgheap.obj及因它而引入的其它模块又定义了包括malloc在内的许多同名符号，导致了重定义冲突。所以链接器在处理完所有输入文件(是的，即使中途有重定义冲突它也会处理所有的文件以便生成一个完整的冲突列表)后只好报告: 这活儿没法儿干。
现在我们该知道，链接器完全没有责任，责任在我们自己的身上。是我们粗心地把缺省标准库版本不一致的目标文件(main.obj)与程序库(my.lib)链接起来，引发了大灾难。解决办法很简单，要么用/MLd选项来重编译main.c；要么用/ML选项重编译mylib.c；再或者干脆在链接时用/NODEFAULTLIB:XXX选项忽略默认库XXX，但这种方法非常不保险(想想为什么？)，所以不推荐。
在上述例子中，我们拥有库my.lib的源代码(mylib.c)，所以可以用不同的选项重新编译这些源代码并再次打包。可如果使用的是第三方的库，它并没有提供源代码，那么我们就只有改变自己程序的编译选项来适应这些库了。但是如何知道库中目标模块指定的默认库呢？其实VC提供的一个小工具便可以完成任务，这就是dumpbin.exe。运行下面这个命令
dumpbin /DIRECTIVES my.lib
然后在输出中找那些"Linker Directives"引导的信息，你一定会发现每一处这样的信息都会包含若干个类似"-defaultlib:XXXX"这样的字符串，其中XXXX便代表目标模块指定的缺省库名(注意，如果在编译时指定了/Zl选项，那么目标模块中将不会有defaultlib信息)。
知道了第三方库指定的默认标准库，再用合适的选项编译我们的应用程序，就可以避免LNK2005和LNK1169链接错误。喜欢IDE的朋友，你一样可以到 "Project属性" -> "C/C++" -> "代码生成(code generation)" -> "运行时库(run-time library)" 项下设置应用程序的默认标准库版本，这与命令行选项的效果是一样的。
---------------------------------------------------------------------------------------------------
在vc 2003下，如果使用了静态库，很有可能会发生link 2005的连接错误，主要是由于crt 库引起的，CRT 库对 new、delete 和 DllMain 函数使用弱外部链接，如果我们改变一下库的连接顺序，就可以解决这个错误
解决方案
解决该问题有两种方法：第一种解决方案涉及到强制链接程序按照正确的顺序链接库。第二种解决方案是让您查找导致问题的模块并纠正它。
解决方案一：强制链接程序按照正确的顺序链接库
1.在“生成”菜单上，单击“设置”。2.在“项目设置”对话框的“以下项目的设置”视图中，单击以选中出现链接错误的项目配置。3.在“链接”选项卡上，单击以选中“类别”组合框中的“INPUT”。4.在“要忽略的库”中，插入库名（例如，Nafxcwd.lib;Libcmtd.lib）。
注意：等效的链接程序命令行是：/NOD:。5.在“对象/库模块”框中，插入库名。必须确保这些库按顺序列出，且作为命令行中的前两个库（例如，Nafxcwd.lib 和 Libcmtd.lib）列出。要在 Visual C++ .NET 中设置该选项，请阅读“设置 Visual C++ 项目属性”联机帮助主题。
解决方案二：找到并纠正出现问题的模块
要查看当前的库链接顺序，请按照下列步骤操作： 1.在“生成”菜单上，单击“设置”。2.在“项目设置”对话框的“以下项目的设置”视图中，单击以选中出现链接错误的项目配置。3.在“链接”选项卡上，在“项目选项”框中键入 /verbose:lib
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1431093
大家都知道，从C/C++源程序到可执行文件要经历两个阶段:
(1)编译器将源文件编译成汇编代码，然后由汇编器(assembler)翻译成机器指令(再加上其它相关信息)后输出到一个个目标文件(object file,VC的编译器编译出的目标文件默认的后缀名是.obj)中；
(2)链接器(linker)将一个个的目标文件(或许还会有若干程序库)链接在一起生成一个完整的可执行文件。
编译器编译源文件时会把源文件的全局符号(global symbol)分成强(strong)和弱(weak)两类传给汇编器，而随后汇编器则将强弱信息编码并保存在目标文件的符号表中。那么何谓强弱呢？编译器认为函数与初始化了的全局变量都是强符号，而未初始化的全局变量则成了弱符号。比如有这么个源文件:
extern int errorno;
int buf[2] = {1,2};
int *p;
int main()
{
return 0;
}
其中main、buf是强符号，p是弱符号，而errorno则非强非弱，因为它只是个外部变量的使用声明。
有了强弱符号的概念，链接器(Unix平台)就会按如下规则(参考[1]，p549~p550)处理与选择被多次定义的全局符号:
规则1: 不允许强符号被多次定义(即不同的目标文件中不能有同名的强符号)；
规则2: 如果一个符号在某个目标文件中是强符号，在其它文件中都是弱符号，那么选择强符号；
规则3: 如果一个符号在所有目标文件中都是弱符号，那么选择其中任意一个；
虽然上述3条针对的是Unix平台的链接器，但据作者试验，至少VC6.0的linker也遵守这些规则。由此可知多个目标文件不能重复定义同名的函数与初始化了的全局变量，否则必然导致LNK2005和LNK1169两种链接错误。可是，有的时候我们并没有在自己的程序中发现这样的重定义现象，却也遇到了此种链接错误，这又是何解？嗯，问题稍微有点儿复杂，容我慢慢道来。
众所周知，ANSI C/C++ 定义了相当多的标准函数，而它们又分布在许多不同的目标文件中，如果直接以目标文件的形式提供给程序员使用的话，就需要他们确切地知道哪个函数存在于哪个目标文件中，并且在链接时显式地指定目标文件名才能成功地生成可执行文件，显然这是一个巨大的负担。所以C语言提供了一种将多个目标文件打包成一个文件的机制，这就是静态程序库(static library)。开发者在链接时只需指定程序库的文件名，链接器就会自动到程序库中寻找那些应用程序确实用到的目标模块，并把(且只把)它们从库中拷贝出来参与构建可执行文件。几乎所有的C/C++开发系统都会把标准函数打包成标准库提供给开发者使用(有不这么做的吗？)。
程序库为开发者带来了方便，但同时也是某些混乱的根源。我们来看看链接器(Unix平台)是如何解析(resolve)对程序库的引用的(参考[1]，p556)。
在符号解析(symbol resolution)阶段，链接器按照所有目标文件和库文件出现在命令行中的顺序从左至右依次扫描它们，在此期间它要维护若干个集合:(1)集合E是将被合并到一起组成可执行文件的所有目标文件集合；(2)集合D是所有之前已被加入E的目标文件定义的符号集合；(3)集合U是未解析符号(unresolved symbols，即那些被E中目标文件引用过但在D中还不存在的符号)的集合。一开始，E、D、U都是空的。
(1): 对命令行中的每一个输入文件f，链接器确定它是目标文件还是库文件，如果它是目标文件，就把f加入到E，并把f中未解析的符号和已定义的符号分别加入到U、D集合中，然后处理下一个输入文件。
(2): 如果f是一个库文件，链接器会尝试把U中的所有未解析符号与f中各目标模块定义的符号进行匹配。如果某个目标模块m定义了一个U中的未解析符号，那么就把m加入到E中，并把m中未解析的符号和已定义的符号分别加入到U、D集合中。不断地对f中的所有目标模块重复这个过程直至到达一个不动点(fixed point)，此时U和D不再变化。而那些未加入到E中的f里的目标模块就被简单地丢弃，链接器继续处理下一输入文件。
(3): 当扫描完所有输入文件时如果U非空或者有同名的符号被多次加入D，链接器报告错误信息并退出。否则，它把E中的所有目标文件合并在一起生成可执行文件。
上述规则针对的是Unix平台链接器，而VC(至少VC6.0)linker则有相当的不同: 它首先依次处理命令行中出现的所有目标文件，然后依照顺序不停地扫描所有的库文件，直至U为空或者某遍(从头到尾依次把所有的库文件扫描完称为一遍)扫描过程中U、D无任何变化时结束扫描，此刻再根据U是否为空以及是否有同名符号重复加入D来决定是出错退出还是生成可执行文件。很明显Unix链接器对输入文件在命令行中出现的顺序十分敏感，而VC的算法则可最大限度地减少文件顺序对链接的影响。作者不清楚Unix下新的开发工具是否已经改进了相应的做法，欢迎有实践经验的朋友补充这方面的信息(补充于2005年10月10日: 经试验，使用gcc 3.2.3的MinGW 3.1.0的链接器表现与参考[1]描述的一致)。
VC带的编译器是cl.exe，它有这么几个与标准程序库有关的选项: /ML、/MLd、/MT、/MTd、/MD、/MDd。这些选项告诉编译器应用程序想使用什么版本的C标准程序库。/ML(缺省选项)对应单线程静态版的标准程序库(libc.lib)；/MT对应多线程静态版标准库(libcmt.lib)，此时编译器会自动定义_MT宏；/MD对应多线程DLL版(导入库msvcrt.lib，DLL是msvcrt.dll)，编译器自动定义_MT和_DLL两个宏。后面加d的选项都会让编译器自动多定义一个_DEBUG宏，表示要使用对应标准库的调试版，因此/MLd对应调试版单线程静态标准库(libcd.lib)，/MTd对应调试版多线程静态标准库(libcmtd.lib)，/MDd对应调试版多线程DLL标准库(导入库msvcrtd.lib，DLL是msvcrtd.dll)。虽然我们的确在编译时明白无误地告诉了编译器应用程序希望使用什么版本的标准库，可是当编译器干完了活，轮到链接器开工时它又如何得知一个个目标文件到底在思念谁？为了传递相思，我们的编译器就干了点秘密的勾当。在cl编译出的目标文件中会有一个专门的区域(关心这个区域到底在文件中什么地方的朋友可以参考COFF和PE文件格式)存放一些指导链接器如何工作的信息，其中有一项就叫缺省库(default library)，它指定了若干个库文件名，当链接器扫描该目标文件时将按照它们在目标模块中出现的顺序处理这些库名: 如果该库在当前输入文件列表中还不存在，那么便把它加入到输入文件列表末尾，否则略过。说到这里，我们先来做个小实验。写个顶顶简单的程序，然后保存为main.c :
/* main.c */
int main() { return 0; }
用下面这个命令编译main.c(什么？你从不用命令行来编译程序？这个......) :
cl /c main.c
/c是告诉cl只编译源文件，不用链接。因为/ML是缺省选项，所以上述命令也相当于: cl /c /ML main.c 。如果没什么问题的话(要出了问题才是活见鬼！当然除非你的环境变量没有设置好，这时你应该去VC的bin目录下找到vcvars32.bat文件然后运行它。)，当前目录下会出现一个main.obj文件，这就是我们可爱的目标文件。随便用一个文本编辑器打开它(是的，文本编辑器，大胆地去做别害怕)，搜索"defaultlib"字符串，通常你就会看到这样的东西: "-defaultlib:LIBC -defaultlib:OLDNAMES"。啊哈，没错，这就
是保存在目标文件中的缺省库信息。我们的目标文件显然指定了两个缺省库，一个是单线程静态版标准库libc.lib(这与/ML选项相符)；一个是oldnames.lib(它是为了兼容微软以前的C/C++开发系统，基本不用了，为了简化讨论可以忽略它)。另外，如果在源程序中用了
/* xxxx代表实际的库文件名 */
#pragma comment(lib,"xxxx")
编译指示命令(compiler directive)指定要链接的库，那么这个信息也会被保存到目标文件的缺省库信息项中，且位于缺省标准库之前。如果有多个这样的命令，那么对应库名在目标文件中出现的顺序与它们在源程序中出现的顺序完全一致(且都在缺省标准库之前)。
VC的链接器是link.exe，因为main.obj保存了缺省库信息，所以可以用
link main.obj libc.lib
或者
link main.obj
来生成可执行文件main.exe，这两个命令是等价的。但是如果你用
link main.obj libcd.lib
的话，链接器会给出一个警告: "warning LNK4098: defaultlib "LIBC" conflicts with use of other libs; use /NODEFAULTLIB:library"，因为你显式指定的标准库版本与目标文件的缺省值不一致。通常来说，应该保证链接器合并的所有目标文件指定的缺省标准库版本一致，否则编译器一定会给出上面的警告，而LNK2005和LNK1169链接错误则有时会出现有时不会。那么这个有时到底是什么时候？呵呵，别着急，下面的一切正是为喜欢追根究底的你准备的。
建一个源文件，就叫mylib.c，内容如下:
/* mylib.c */
#include
void foo(void)
{
printf("%s","I am from mylib!\n");
}
用
cl /c /MLd mylib.c
命令编译，注意/MLd选项是指定libcd.lib为默认标准库。lib.exe是VC自带的用于将目标文件打包成程序库的命令，所以我们可以用
lib /OUT:my.lib mylib.obj
将mylib.obj打包成库，输出的库文件名是my.lib。接下来把main.c改成:
/* main.c */
void foo(void);
int main()
{
foo();
return 0;
}
用
cl /c main.c
编译，然后用
link main.obj my.lib
进行链接。这个命令能够成功地生成main.exe而不会产生LNK2005和LNK1169链接错误，你仅仅是得到了一条警告信息:"warning LNK4098: defaultlib "LIBCD" conflicts with use of other libs; use /NODEFAULTLIB:library"。我们根据前文所述的扫描规则来分析一下链接器此时做了些啥(加一个/VERBOSE选项就可以看到详尽的链接过程，但要注意，几乎所有的C编译器都会在符号前加一个下划线后再输出，所以在目标文件和链接输出信息中看到的符号名都比在源程序中见到的多出一个'_'，此点不可不察。)。
一开始E、U、D都是空集。链接器首先扫描main.obj，把它的默认标准库libc.lib加入到输入文件列表末尾，它自己加入E集合，同时未解析的foo加入U，main加入D。接着扫描my.lib，因为这是个库，所以会拿当前U中的所有符号(当然现在就一个foo)与my.lib中的所有目标模块(当然也只有一个mylib.obj)依次匹配，看是否有模块定义了U中的符号。结果mylib.obj确实定义了foo，于是它加入到E，foo从U转移到D，未解析的printf加入到U，指定的默认标准库libcd.lib也加到输入文件列表末尾(在libc.lib之后)。不断地在my.lib库的各模块上进行迭代以匹配U中的符号，直到U、D都不再变化。很明显，现在就已经到达了这么一个不动点，所以接着扫描下一个输入文件，就是libc.lib。链接器发现libc.lib里的printf.obj里定义有printf，于是printf从U移到D，printf.obj加入到E，它定义的所有符号加入到D，它里头的未解析符号加入到U。如果链接时没有指定/ENTRY(程序入口点选项)，那么链接器默认的入口点就是函数mainCRTStartup(GUI程序的默认入口点则是WinMainCRTStartup)，它在crt0.obj中被定义，所以crt0.obj及它直接或间接引用的模块(比如malloc.obj、free.obj等)都被加入到E中，这些目标模块指定的默认库(只crt0init.obj指定了kernel32.lib)加到输入文件列表末尾，同时更新U和D。不断匹配libc.lib中各模块直至到达不动点，然后处理libcd.lib，但是它里面的所有目标模块都没有定义U中的任何一个符号，所以链接器略过它进入到最后一个输入文件kernel32.lib。事实上，U中已有和将要加入的未解析符号都可以在其中找到定义，那么当处理完kernel32.lib时，U必然为空，于是链接器合并E中的所有模块生成可执行文件。
上文描述了虽然各目标模块指定了不同版本的缺省标准库但仍然链接成功的例子，接下来你将目睹因为这种不严谨而导致的悲惨失败。
修改mylib.c成这个样子:
#include
void foo(void)
{
// just a test , don't care memory leak
_malloc_dbg( 1, _NORMAL_BLOCK, __FILE__, __LINE__ );
}
其中_malloc_dbg不是ANSI C的标准库函数，它是VC标准库提供的malloc的调试版，与相关函数配套能帮助开发者抓各种内存错误。使用它一定要定义_DEBUG宏，否则预处理器会把它自动转为malloc。继续用
cl /c /MLd mylib.c
lib /OUT:my.lib mylib.obj
编译打包。当再次用
link main.obj my.lib
进行链接时，我们看到了什么？天哪，一堆的LNK2005加上个贵为"fatal error"的LNK1169垫底，当然还少不了那个LNK4098。链接器是不是疯了？不，你冤枉可怜的链接器了，我拍胸脯保证它可是一直在尽心尽责地照章办事。
一开始E、U、D为空，链接器扫描main.obj，把libc.lib加到输入文件列表末尾，把main.obj加进E，把foo加进U，把main加进D。接着扫描my.lib，于是mylib.obj加入E，libcd.lib加到输入文件列表末尾，foo从U转移到D，_malloc_dbg加进U。然后扫描libc.lib，这时会发现libc.lib里任何一个目标模块都没有定义_malloc_dbg(它只在调试版的标准库中存在)，所以不会有任何一个模块因为_malloc_dbg而加入E。但因为libc.lib中的crt0.obj定义了默认入口点函数mainCRTStartup，所以crt0.obj及它直接或间接引用的模块(比如malloc.obj、free.obj等)都被加入到E中，这些目标模块指定的默认库(只crt0init.obj指定了kernel32.lib)加到输入文件列表末尾，同时更新U和D。不断匹配libc.lib中各模块直至到达不动点后再处理libcd.lib，发现dbgheap.obj定义了_malloc_dbg，于是dbgheap.obj加入到E，它的未解析符号加入U，它定义的所有其它符号加入D，这时灾难便来了。之前malloc等符号已经在D中(随着libc.lib里的malloc.obj加入E而加入的)，而dbgheap.obj及因它而引入的其它模块又定义了包括malloc在内的许多同名符号，导致了重定义冲突。所以链接器在处理完所有输入文件(是的，即使中途有重定义冲突它也会处理所有的文件以便生成一个完整的冲突列表)后只好报告: 这活儿没法儿干。
现在我们该知道，链接器完全没有责任，责任在我们自己的身上。是我们粗心地把缺省标准库版本不一致的目标文件(main.obj)与程序库(my.lib)链接起来，引发了大灾难。解决办法很简单，要么用/MLd选项来重编译main.c；要么用/ML选项重编译mylib.c；再或者干脆在链接时用/NODEFAULTLIB:XXX选项忽略默认库XXX，但这种方法非常不保险(想想为什么？)，所以不推荐。
在上述例子中，我们拥有库my.lib的源代码(mylib.c)，所以可以用不同的选项重新编译这些源代码并再次打包。可如果使用的是第三方的库，它并没有提供源代码，那么我们就只有改变自己程序的编译选项来适应这些库了。但是如何知道库中目标模块指定的默认库呢？其实VC提供的一个小工具便可以完成任务，这就是dumpbin.exe。运行下面这个命令
dumpbin /DIRECTIVES my.lib
然后在输出中找那些"Linker Directives"引导的信息，你一定会发现每一处这样的信息都会包含若干个类似"-defaultlib:XXXX"这样的字符串，其中XXXX便代表目标模块指定的缺省库名(注意，如果在编译时指定了/Zl选项，那么目标模块中将不会有defaultlib信息)。
知道了第三方库指定的默认标准库，再用合适的选项编译我们的应用程序，就可以避免LNK2005和LNK1169链接错误。喜欢IDE的朋友，你一样可以到 "Project属性" -> "C/C++" -> "代码生成(code generation)" -> "运行时库(run-time library)" 项下设置应用程序的默认标准库版本，这与命令行选项的效果是一样的。
---------------------------------------------------------------------------------------------------
在vc 2003下，如果使用了静态库，很有可能会发生link 2005的连接错误，主要是由于crt 库引起的，CRT 库对 new、delete 和 DllMain 函数使用弱外部链接，如果我们改变一下库的连接顺序，就可以解决这个错误
解决方案
解决该问题有两种方法：第一种解决方案涉及到强制链接程序按照正确的顺序链接库。第二种解决方案是让您查找导致问题的模块并纠正它。
解决方案一：强制链接程序按照正确的顺序链接库
1.在“生成”菜单上，单击“设置”。2.在“项目设置”对话框的“以下项目的设置”视图中，单击以选中出现链接错误的项目配置。3.在“链接”选项卡上，单击以选中“类别”组合框中的“INPUT”。4.在“要忽略的库”中，插入库名（例如，Nafxcwd.lib;Libcmtd.lib）。
注意：等效的链接程序命令行是：/NOD:
解决方案二：找到并纠正出现问题的模块
要查看当前的库链接顺序，请按照下列步骤操作： 1.在“生成”菜单上，单击“设置”。2.在“项目设置”对话框的“以下项目的设置”视图中，单击以选中出现链接错误的项目配置。3.在“链接”选项卡上，在“项目选项”框中键入 /verbose:lib
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1431093
订阅：
博文 (Atom)