色彩斑斓的2008（My 2008）

2008年，无论是对国家还是个人，都是不平凡的一年。如果要用一个词形容，我能想到的就是“色彩斑斓”了。在国家来说，今年发生了太多的事情，有好事，有坏事，有些事情的影响还没有全部发酵，未来如何尚难预料。于个人来说，在即将踏上社会前的这一年，面临找工作和毕业双重压力，又适逢金融危机，经历了各种选择、彷徨和痛苦。不管怎么说，路，既然已经选定，那就应该坚定不移的走下去。国家的大事已有众多的记述，这里只是记录自己在2008的流水帐。

1月回家，运气比较好，赶在了雪灾前面，没被堵在路上。

寒假归来，得知毕设改题了：“叠前深度偏移”。六个字每个字都很简单，但连起来就愣是不知道什么意思。好处是还能用上学期学的FM算法。坏处是要完全从零开始去熟悉一个新的领域。

接下来就是痛苦的学习阶段，期间插播5月一个月都是小论文的撰写阶段，原以为简单的问题总是出不来结果，直到最后一刻才发现是个非常低级的错误。三个人里最后一个交上去的，但总算是过了。

6月份各种资料相继到手，才算开始比较正式的学习地震学方面的知识。实验室每周一次的例会鞭策下，必须保证学点东西，否则就没东西讲了。同时也开始关注找工作的事，从网上搜集面试笔试题，看看专业方向的书。憧憬一下进入理想公司之后的情景。

7月份的时候参加了一个Google的在线竞赛，8月份开始关注这方面的内容，做了很多网上练习题，占用了不少时间。实践证明这对后面的面试笔试还是比较有用的，SLB笔试中的一道题就在USACO的题库中看到过。毕竟，计算机学科还是一个实践性很强的学科。

8月份的奥运会就发生在我们身边，切切实实的感受到奥运的气氛，为国家获得的每一块奖牌而高兴，如同一部大戏，虽然早已闭幕，但仍久久回味中。

9月下旬开始，虽然还没什么大动静，但大家已经开始坐立不安了。部分公司开始进入校园宣讲，这个时候大家还比较有热情，宣讲还去听一听，到后面就连听都不听了，直接去笔试或者霸笔。

10月国庆假期一过，意味着找工作的大幕正式拉开。经历了SLB宣讲会上人山人海的恐怖场景，被Google和MS等大公司接连鄙视。也为几个小offer而辗转反侧。在整个过程中自己的目标也逐渐明细，简历投递的倾向性日渐明显。

进入11月，仿佛一阵寒风吹过，不好的消息接连传来，缩招、冻结、裁员……这些词汇不断出现。原本以为遥不可及的金融危机被我们最先体会到了，同时还心存一次侥幸：这些公司怎么说也是大公司，应该会未雨绸缪吧。可事实上证明我们错了，不是所有的公司都喜欢用低廉的新员工代替老员工来降低成本的。原来当保底的现在也一下变得高贵起来，在一堆简历中扒拉来扒拉去，精挑细选。身为被挑选者的我们，也只能忍气吞声，形势比人强，今年这个年景，人出来招就不错了。更多的公司是把招聘会当成了走过场，还听说有公司笔试完后直接把卷子扔掉的。在外企普遍萎靡的情况下，国企、公务员成了大家最后的避风港，可不知为何，对此心中总有些排斥。估计是身在学校，以前也跟里面的人合作过的缘故，对里面的氛围总有些疲惫，担心进去后就出不来了。所以对这方面的准备也不太上心，不上心的后果就是没收获。

12月，找工作和毕设都进入了最后的冲刺阶段。这是北航相比于其他学校的另一个劣势：当别人可以专心一致的找工作，把每次笔试的题目总结总结，吸收经验，迎接下一次考试的时候，我们还得分出一半的精力做毕设，脑子得在两种不同的思维中来回切换，不知道当初政策指定者们是怎么想的。

工作的最后确定也比较具有戏剧性，找工作伊始是完全没有想到自己最后会签这的，热情的hr一次一次的电话，说服心中疑虑，并给出宽松的考虑时间和有吸引力的待遇。心中向往的是另一家公司，可惜最后等来的确是冰冷的“冻结”二字，只能说是无缘了。看好这边的前景是最后下定决心的依据，虽然风险依然存在，但觉得这样的风险尚在可接受的范围之内。趁着年轻多历练历练未尝不是件好事。

工作定了之后，毕设就全力以赴了。熬了近半个月的夜，把以前没解决的问题都解决了，基本上做到了不留遗憾，对得起自己这两年的努力。

其他方面，年初拿了驾照，游泳也一直在坚持着。现在基本上四大泳姿都没问题，肺活量也有长进。

2008年是我的本命年，回顾一年的历程，应该说还是比较幸运的。学习上两次重要的时刻都是在最后时刻得到了结果，找工作在今年的大环境下也应该是不算差了，没有留下什么大的遗憾。

2009年是工作的第一年，作为一个职场新人，最大的目标就是工作顺利上手，学到新东西，增强自身的竞争力，尽快做到从学校到社会的转变。

圣诞节，答辩日（Oral Dissertation Defense on Christmas Day）

不知道是刻意安排还是巧合，研究生答辩竟然安排在圣诞节这天。回忆论文完成前的这一个月，感觉真是不容易啊。虽然11月21日的时候，论文的大致框架就出来了。后来基本上就在这个基础上面改的。但具体到内容的充实上，那就费了老牛鼻子劲了，这是当初所没有想到的。

12月初，进入论文撰写的关键阶段，同时也进入了找工作的决定时期。连续参加了多个单位的笔试和面试，纠结于各种选择之中。为工作的事影响心情，一天没进展的情况出现了多次。最后下定决心的时候已经是17日了。

12月10日开始重新开始打通各章，11日顺完第一章，12日顺完第二章，15-17日整个顺完。2、7、3、2、3、4，这是那几天的熬夜时间。当时也没想到这是后面一段时间系统性熬夜的开始。顺完全文，正想松一口气的时候，18日分组出来，真个晴天霹雳——我们竟然被分在了“尹刀”的组里，他答辩时一向以严格著称，去年直接把两个去Morgen Stanly的挂了延期。看着群里面同学纷纷庆祝自己的分组，心里郁闷有谁知啊。得，继续熬吧。又是一个通宵，准备PPT和送审稿。熬夜的时候发现楼里很多屋子的灯都是亮着的，看来同志们不少啊。

新的一周开始，进入倒计时状态，改PPT和答辩词。24日，答辩前一天的预答辩，始终有个问题没有想好。如同魔术师手中那个圆环的缺口，表演的时候需要拿在手中，不能让观众发现。预答辩的时候也向老师谈到了这个问题，老师指示还是要把他弄出来，不能留遗憾到答辩中。晚上神力加身，连续解决了多个问题，竟然把这个困扰我俩月的问题解决了。回过头来看，这个问题还是一个很简单的问题。用老师的话说，就是“工作作风”问题。（估计这个反面示例要被老师说上一届又一届，sigh～）虽说又熬到两点，但总算是把自己的最大一块心病给去了，对第二天的答辩充满了信心。

真到了答辩那天，就不紧张了，估计是因为心里有底了吧。一上来尹刀就显得不同反响：“虽然学校建议答辩时间是15分钟，但我们不接受这个建议。每个人10分钟！足够把你做的东西讲清楚了。”好在我们当初就对这种情况有准备，PPT都是按照10分钟准备的。虽然又面对顺序的临时调整，但还是把自己的工作说清楚了，老师也没怎么难为。到了下午，看完演示，结果揭晓的时候到来了。大家站在外面，一个一个的进去听结果，我是倒数第三个。当从答辩主席的口中听到“……达到了硕士标准，准许毕业。”的时候，心中真是长舒了一口气，两年半的学习生活算是画上了一个圆满的句号。晚上从答辩秘书那里知道我竟然在小组里排名第一。

感谢孟导，如果不是他把时间安排在了周四，估计跟现在就是截然不同的两个结果了。感谢导师最后的时刻推了我一把，没有让我带着遗憾毕业。还有感谢同窗好友们，大家一块通宵之后去吃早饭，走在学校的路上的情景现在还历历在目。

研究生必读——如何获取文献（zz）

搞研究的人离不开文献， 一下是获得最新专业资料的一些途径：

注意积累，没事干的时候到全国各地的图书馆网站逛逛，肯定有很多收获！使用一些网络书签服务 如： delicious ，diigo 也是非常不错的选择 ，这里是大众筛选后的精华结果,而且，从书签信息中可以找到收藏、关注这些信息的研究者和爱好者，这些关键节点后对学习、交流会更加有帮助。
http://delicious.com
http://www.diigo.com/

*根据作者E-mail地址，向作者索要。

这是最有效的方法之一，可以直接向作者索取原文，但一定要简洁！如果作者有自
己的主页，可以去作者的主页看看。不过一般查找作者的主页倒不容易！记住信箱尽量
大一点，否则一些大的文件搞不定！

Dear Mr./Mrs.: ________（Author name）

I am a graduate student of XXX（您的学校） in China. I major in "__
______"（您的专业）. Recently, I found one of your articles, titled &qu
ot;__________" （Title）in XXX(). I found it may help me achieve my goa
ls in this research field. This would make a really positive contribution to
my work. I would like to be able to read the full text of this article. The
abstract makes the article sound very interesting. I know there is usually
a fee required to obtain the full article from XXX; however, as a student, m
y only income is a small scholarship which is about U S $30.00 per month. I
wonder if you would consider sending me the full text by Email. Perhaps you
would consider this as an act of friendship between our two countries.

Thank you for your kind consideration of this request.

Sincerely: ___________（your name）

My Email address is: ____________________ （your email）

Date：Month/day/year


*利用一些软件NoteExpress，reference manager等等

这些软件的demo版本网络里面都可以有下载，一般自己会收录一些引擎，不妨自己
试一试，而且作学术这些软件至少要有些了解啦！

NoteExpress 简明教程下载地址：
http://www.scinote.com/supportcn/noncgi/at...NoteExpress.rar

免费下载地址：
http://www.scinote.com/support/cgi-bin/download_chs.cgi


*利用搜索引擎：

英文采用著名的搜索引擎，如Lycos，HotBot，Yahoo，输入详细的关键词（一定要具有特征性，防止搜索出太多的东西），末尾加PDF可能效果更好些。要是觉得不方便就到www.5566.org进入后点搜索，里面收集了十多个引擎，足够你查的，不过一般百度和google比较好！Lycos也不错。关键词很重要，要掌握一些技巧，否则不是漏检就是眼前是个文件的海洋，捞不到针！

下面补充一些重要的学术引擎：

综合通用

英文
AltaVista＞http://www.altavista.com
LYCOS ＞http://www.lycos.com
YAHOO! ＞http://www.yahoo.com
EXCITE ＞http://www.excite.com
INFOSEEK ＞http://www.infoseek.com
HOTBOT ＞http://www.hotbot.com
EVLAST ＞http://www.evlast.com
GALAXY ＞http://www.galaxy.com
NORTHERNLIGHT ＞http://www.northernlight.com
OPENTEXT ＞http://pinstripe.opentext.com

中文
Sohu ＞http://www.sohu.com
Yahoo>http://www.yahoo.com.cn

综合科技
Scicentral & SciQuest ＞http://www.sciquest.com
Martindale’srefrence ＞http://www-sci.lib.uci.edu/HSG/REF.html
EEVL ＞http://www.eevl.ac.uk

英文期刊的搜索可以用 citeseer来搜.他有很多相关性比较和引用.很不错.

* 按部就班，根据文章出处，去图书馆查找原文。

这个自然不用多说，大家都会。

*付费中文全文数据库

中文文献，大多需要买。中文文献价值一般欠高！不建议个人购买！（个人意见）

万方数据库（万方系统中有1000余种电子期刊，以理工科技类为主，全部是国内出版的中文和英文期刊，比印刷版略晚。CNKI、999都是全文，花钱吧就没价值了。这里面查的时候注意到里面分为很多小的库，不要漏查！很多可以直接得到文字资料，但很多没有全文，尤其是一些镜像站点的库！

CNKI（CNKI：中国期刊网提供三种类型的数据库，题录数据库、题录摘要数据库和全文数据库，其中前两者属参考数据库类型，只提供目次和摘要，可在网上免费检索，全文数据库需付费。）中“期刊题录数据库”是免费的。和重庆维普资讯公司有一定的相似性，但是看起来舒服一些，一般是近年来的。没有重庆维普资讯公司的年代久！查的时候还有重复文献。可以识别得到文字资料，英文的或者一些符号会有错误要自己修改。

重庆维普资讯公司（收录有中文报纸1000种,中文期刊12000种,外文期刊4000种,拥有固定客户2000余家。维普有两种注册用户，一种是可以查阅全文的，这种是要收费的。另外就是一般注册用户，是使用免费资源的，比如全文检索，讨论版等等。 收费用户中采用包库方式的机构用户或个人，我们将在年末附送期所包库的光盘版作为保存用。流量计费的用户在累计一定金额后，我们将增送使用时间或是光盘版。同时提高其会员级别，将获得更优惠的使用费用。）可以识别得到文字资料，英文的或者一些符号会有错误要自己修改。

超星图书馆（若要文章，可通过超星图书馆，从网易上下载超星图书馆专用下载器即可免费下载了！极好！您可免费下载十万种书，否则你也可以直接阅读。）有些学校购买过就不要钱。一般书比较大，建议有用的可以刻光盘！

联合参考：http://219.137.192.247/
完全免费，万方、超星、维普都有。

这里只是介绍几个常用的啦！还有很多规模没有这么大，但是也很好。

*Science网上杂志找文章。对中国人完全免费！

High Wire Press 网站，斯坦复大学主办，文献量十分大，而且free!斯坦福大学HighWire出版社的电子期刊斯坦福大学HighWire Press是著名的学术出版商，目前已成为全世界最大的、能够联机提供免费学术论文全文的出版商之一。它提供免费检索目次和摘要的期刊为192种，主要包括物理、生物、医学和社会学领域的核心期刊，其中有90种可以得到全文。该站点上列出了所有可供检索的期刊名称，右边标识为free site的期刊是完全免费的期刊，可以看到数据库里任意卷期的全文；标识为free trail的期刊是免费试用的期刊，在一段试用期内可以免费得到期刊全文；标识为free issues的期刊是指不能看到最新出版卷期的论文，但可以回溯几个月以前或1到2年以前所有的过刊文章。http://intl.highwire.org/Medline 就可以买到原文，价钱很贵呀。

到一些高校尤其是211重点高校的同学那里求得帮助。

现在网络很方便，只要在这些学校内部的网络上一般可以下载很多有用的全文，可
以先到相关大学的图书馆看看都有什么数据库。朋友多也是件很好的事情，虽然世界人
与人变得比较远，可是朋友却越来越重要啊！

*到一些论坛寻求帮助

中科院和一些比较大的牛的高校（北大、清华、南大、复旦等等啦！），去那里和
牛人们交流寻求帮助，一定大有裨益！不信你试试看！

精品网站汇总

从网上搜集整理的一些好的网站，当我们被忙碌生活所累，只知道低头赶路的时候，记得头顶上还有一片广阔的蓝天。

编程技术与面试题：
C++
C++专题站，代码很多很全，可以直接拿来用。

TechPreparation
很多笔试面试题的集锦。

在线编程类（Judge Online）：
USACO
大名鼎鼎的USACO，面向美国高中生OI的。非常适合入门级，循序渐进，每道题都有答案，每章还有讲解，从中收获很大。

Timus Online Judge
USACO全做完之后的进阶网站，是俄罗斯的大学开办的。俄罗斯是一个盛产高手、黑客的地方，编程水平自不待言。

PKU JudgeOnline
ZJU JudgeOnline
国内的两个比较有名的在线测试网站，前一个是北京大学的，后一个是浙江大学的，里面卧虎藏龙，高手无数。如果能把里面所有题都做出来那就是当之无愧的高手了。

TopCoder
目前最红火的商业性质的在线网站，不单可以做题，没隔一周还有大型的在线测试，前几名有奖金可能。另外竞赛类型也丰富多样，有很多商机。

Project Euler
用编程来解决一系列数学/编程问题，支持python。目前有210道题，每道题后面有解决了这道题的人数，从几十到数万不等。据说所有题目都有运行时间在1分钟之内的算法，也有高手只用笔和纸就能解决。
Python Challenge
另一个python练习网站。
Code Golf
看谁的代码用得字符最少，在这方面python与perl/ruby还是有点差距的。

Google Summer Code
Google Code Jam


在线视频类：
Stanford Engineering Everywhere

斯坦福大学的全套视频。课程包括
Introduction to Computer Science
Programming Methodology CS106A
Programming Abstractions CS106B
Programming Paradigms CS107

Artificial Intelligence
Introduction to Robotics CS223A
Natural Language Processing CS224N
Machine Learning CS229

Linear Systems and Optimization
The Fourier Transform and its Applications EE261
Introduction to Linear Dynamical Systems EE263
Convex Optimization I EE364A
Convex Optimization II EE364B

其他：
Joel on Software
以辛辣诙谐的言语品评程序员这个行业。中文版的有《Joel说软件》等。

Edubuntu China
目标是用开源软件代替学校中用到的所有的Mircrosoft软件。

译言
由群众动手，翻译很多外网文章，提供看问题的多个角度，不乏精品，有兴趣的话还可以提高下英文。

在准备 SICP 的过程中, 我发现了不少好的资源, 觉得不推荐给大家可惜, 因此不敢藏私, 直接拿出来和大家共享吧 :)

ACM Classic Books Series
ACM 根据很多会员的投票选出的一些经典的计算机科学著作, 大部分都是有全文的。

ACM Turing Award Lectures
历届图灵奖获得者发表的获奖论文, 都很浅显易懂, 也是计算机领域大牛的前瞻和回顾的文章。

Yappr
英文视频网站，中英文字幕都有，练听力比较好，

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函数为：

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 个，是一个环形的缓冲池。

#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）通信方法有管道、消息队列、共享内存、信号量、套接口等。管道分为有名管道和无名管道，无名管道只能用于亲属进程之间的通信，而有名管道则可用于无亲属关系的进程之间。

#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这个操作系统的关键。

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++中不常用的关键字

mutable关键字
关键字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都必须为它加上基地址,才能指向真正的位置.

奥运结束，新学期开始（Olympic passed, a new semester began)

铁丝网篱笆终于拆了，原来阻塞的道路畅通了，所有的车又能上路了。煎饼摊子、水果车、小吃铺，一夜之间全都冒出来了。一切迹象告诉我们：奥运已经结束了，生活又回复到了以前场景。
这两天新生开学，熙熙攘攘，随处可以看到穿着刚拿到的系服的新生走来走去。早早的就被号子声喊醒，看着排队吃饭的队伍，电梯重新变成拥挤，爬楼又称为选择。深深的体悟到自己现在旁观者的身份。

注：今天是老妈的生日，祝妈妈生日快乐！

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程序文件并依次执行文件中的所有语句。

第十一章 幕后的英雄—风险投资（Venture Capital）（zz）

目录
第一节 风投的起源
第二节 风投的结构
第三节 风投的过程
第四节 投资的决策和公司的估价
第五节 风投的角色
第六节 著名的风投公司

任何一个公司的创办都离不开资金。传统上创业资金的合法来源只有两种渠道：一种是靠积累（比如继承遗产或者是自己多年的积蓄），第二种是靠借贷（比如从家人、亲戚和朋友那里凑钱，或者从银行抵押贷款）。如果要求创业者将自己一辈子的积蓄全部拿出来创业，很多人可能会知难而退，更何况最喜欢创业的年轻人恰恰是积蓄最少的群体。从银行贷款必须要有财产可抵押，对于有房子的人来讲最值钱的就是房子，但是房子一旦抵押出去很可能赎不回来，自己便无家可归了，而且不是人人都有房子可抵押。因此，年轻人要通过这两种传统的方法获得创业资金很不容易。这样，资金就成了创业的瓶颈。在很多国家，包括几乎整个欧洲，很少能看到新的公司兴起，原因就是没有人愿意提供创业的资金。

美国是一个富于冒险精神的年轻的国度。二战后，尤其是六十年代后，一些愿意以高风险换取高回报的投资人发明了一种非常规的投资方式—风险投资（Venture Capital Investment，or VC），在中国又简称风投。风险投资和以往需要有抵押的贷款有本质上的不同之处。风险投资不需要抵押，也不需要偿还。如果投资成功，风投资本家将获得几倍、几十倍甚至上百倍的回报，如果不成功，钱就打水漂了。对创业者来讲，使用风险投资创业即使失败，也不会背上债务。这样就使得年轻人创业成为可能。几十年来，这种投资方式总的来讲非常成功，硅谷在创造科技公司神话的同时，也创造出另一种神话——投资的神话。

第一节 风投的起源

哲学家黑格尔讲：“凡是现实的都是合理的；凡是合理的都是现实的。”（All that is real is rational, and all that is rational is real.）这句话在恩格斯的《反杜林论》中成为最有进步意义的话。任何事情都有它发生、存在和发展的理由，当然如果这个理由不成立了，它终究就会消亡。风投在六十年代后（而不是二战以前）在美国（而不是世界其它国家）蓬勃兴起有它的社会基础。

第二次世界大战后，美国取代英国主导了世界的金融业，在二战后的较长时间里，美国是资本的净输出国，比其它国家有多得多的资本可以进行投资。传统的投资方法是将资本投入到股市上去（Public Equity）或者购买债券（Bonds，比如国债）。前者一百多年来的回报率平均是百分之七左右，后者就更低了（美国国债的回报率是百分之五左右）。要想获得更大的投资收益，过去的办法只有投入到未上市流通的企业中去（Private Equity）。由于吃过 1929 年到 1933 年经济大萧条的亏，美国政府在很长时间里严格限制银行的各种炒作行为。直到七十年代时，闲余资本只能进行投资，很难用于金融炒作。我们今天看到的许多纯金融的一些游戏，比如对冲基金（Hedge Funds），那都是八十年代以后的事了。

而对私有企业的投资大致有两种，一种是收买长期盈利看好但暂时遇到困难的企业，比如投资大师巴菲特经常做的就是这件事，他很成功的案例是在美国大保险公司 Geico（原名政府雇员保险公司，Government Employee Insurance Company）快要破产时，百分之百地以超低价收购了该公司，并将其扭亏为盈，从而获得了几十倍的收益；另一种是投资到一个新的小技术公司中，将它做大上市或者被其它公司收购。后者就是风险投资的对象。

和抵押贷款不同，风险投资是无抵押的，一旦投资失败就血本全无。因此，风投资本家必须有办法确认接受投资的人是老老实实用这笔钱创业的实业家，而不是卷了钱就跑了的骗子（事实上，风险投资钱被骗的事件还时有发生）。第二次世界大战后，经过罗斯福和杜鲁门两任总统的努力，美国建立起了完善的社会保险制度（Social Security System）和信用制度（Credit System），使得美国整个社会都建立在信用（Credit）这一基础之上。每个人（和每个公司）都有一个信用记录，通过其社会保险号可以查到。美国社会对一个人最初的假定都是清白和诚实的（Innocent and Honest），但是只要发现某个人有一次不诚实的行为，这个人的信用就完蛋了——再不会有任何银行借给他钱，而他的话也永远不能成为法庭上的证据。也就是说，一个人在诚信上犯了错误，改了也不是好人。全美国有了这样的信用基础，银行就敢把钱在没有抵押的情况下借出去，投资人也敢把钱交给一无所有的创业者去创业。不仅如此，只要创业者是真正的人才，严格按合同去执行，尽了最大努力，即使失败了，风投公司以后还会愿意给他投资。美国人不怕失败，也宽容失败者。大家普遍相信失败是成功之母，这一点在世界其它国家很难做到（当然，如果创业者是以创业为名骗取投资，他今后的路便全被堵死了）。美国工业化时间长，商业发达，和商业有关的法律健全，也容易保护风险投资。

相比其他发达国家而言，美国是一个年轻的移民国家，很多美国人是第一代移民，爱冒险，而且想象力丰富，乐于通过创业来提升自己的社会和经济地位。美国的大学总体水平领先于世界，并且在理论研究和应用研究方面平衡得比较好，容易做出能够产业化的发明创造。这两条加在一起，使得风险投资人可以很方便的发掘到好的投资项目和人才。上述这一切原因凑到一起，就形成了风险投资出现和发展的环境。

高回报的投资一定伴随着高风险，但反过来高风险常常并不能带来高回报。任何一种长期赚大钱的金融投资必须有它内在的动力做保证。股票长期来讲总是呈上涨趋势，因为全世界经济在发展。风险投资也是一样，它内在的推动力就是科技的不断发展进步。由于新的行业会不断取代老的行业在世界经济中的地位，专门投资新兴行业和技术的风险投资从长期来讲回报必定高于股市。因此风险投资看上去风险大，但是并不是赌博，它和私募基金都是至今为止收益最高的投资方式（回报率分别在 15% 和 20% 上下）。正是鉴于它的高回报，不断有人和单位（Institute）愿意将越来越多的钱放到风险投资基金中去，比如斯坦福大学将其退休基金的很大一部分放到在风投公司 KPBC 去投资。近三十年来，风投基金越滚越大，从早期的一年几万美元，到 2006 年的每季度六七十亿美元。由于风投公司不公开财务报告，很难准确了解美国风投的准确规模，但是普遍估计 2007 年的美国的风投基金规模大约是二三百亿美元。现在，美国自己已经消化不了全部的风投资本了，因此这些年美国大的风投公司也开始在海外投资，其中相当大一部分投在了中国和印度（欧洲的风投至今仍然很少）。

从财务和税务上讲，风险投资和传统的私募基金（以下简称私募基金）类似，但是它们的投资对象和方式完全不同。私募的投资对象大多数是拥有大量不动产和很强的现金流（Cash Flow）的传统上市企业，这些企业所在的市场被看好，但是这些企业因为管理问题，不能盈利。私募基金收购这些企业，首先让它下市，然后采用换管理层、大量裁员、出售不动产等方式，几年内将它扭亏为盈。这时或者让它再上市，比如高盛收购汉堡王（Burger King）后再次上市；或者将它出售，比如 Hellman & Friedman 基金收购双击广告公司 Double Click，重组后卖给 Google。运作私募基金要求能够准确估价一个问题重重的公司、具有高超的谈判技巧和资金运作本领，但是最关键的是要能摆平劳工问题，其中最重要的是蓝领的工人和工会（因为私募基金一旦收购一个公司，第一件事就是卖掉不良资产和大规模裁员）。从这个角度上讲，私募基金是在和魔鬼打交道，但他们是更厉害的魔鬼。

风险投资则相反，他们是和世界上最聪明的人打交道，同时他们又是更聪明的人。风险投资的关键是能够准确评估一项技术，并预见未来科技的发展趋势。所以有人讲，风险投资是世界上最好的行业。

要了解风投首先要了解它的结构和运作方式，然后了解风投的结构和决策过程。

第二节 风投的结构

风险投资基金（Venture Capital Funds）主要有两个来源：机构（Institutes）和非常有钱的个人。比如哈佛大学和斯坦福大学的基金会就属于前者。当然，为了让投资者放心，风险投资公司自己也会拿出些钱一起投资。

风险投资基金一般是由风险投资公司出面，邀集包括自己在内的不超过 499 位投资者（和投资法人），组成一个有限责任公司（Limited Liability Company， LLC）。为了避税，在美国融资的基金一般注册在特拉华州，在世界上其它地区融资的基金注册在开曼群岛（Cayman Islands）或者是巴哈马(Bahamas)等无企业税的国家和地区（如果读者创业时遇到一个注册在加州或纽约的美国基金，那一定是遇到骗子了）。为什么不能超过 499 人呢？因为根据美国法律规定，一旦一个公司的股东超过五百人，就必须像上市公司那样公布自己的财务情况和经营情况。而风险投资公司不希望外界了解自己投资的去处和资金的运作，以及在所投资公司所占的股份等细节，一般选择不公开财务和经营情况，因此股东不能超过五百人。每一轮基金融资开始时，风投公司要到特拉华等地注册相应的有限责任公司，在注册文件中必须说好最高的融资金额、投资的去处和目的。风险投资公司会定一个最低投资额，作为每个投资人参与这一期投资的条件。 比如红杉风投一期融资常常超过十亿美元，它会要求每个投资人至少投入两百万美元。显然，这只有机构和非常富有的个人才能拿得出。

风险投资公司每一次融资便成立一个有限责任公司，它的寿命从资金到位开始（Close Fund）到所有投资项目要么收回投资、要么关门结束，通常需要十年时间，前几年是投入，后几年是收回投资。一个风险投资公司通常定期融资，成立一期期的风险基金。基金为全体投资人共同拥有。风险投资公司自己扮演一个称作总合伙人的角色（General Partner），其它投资者称为有限合伙人（Limited Partner）。总合伙人除了拿出一定资金外，同时管理这一轮风险基金。有限合伙人参与分享投资回报但是不参加基金的决策和管理。这种所有权和管理权的分离，能保证总投资人能够独立地、不受外界干扰地进行投资。为了监督总投资人的商业操作和财务，风投基金要雇一个独立的财务审计顾问和总律师（Attorney in General），这两个人（或者公司）不参与决策。风险投资比炒股要凶险得多，一旦出错，基本上是血本无归。为了减少和避免错误的决策，同时替有限合伙人监督总投资人的投资和资本运作，一个风投基金需要有一个董事会（Board of Directors）或者顾问委员会(Board of Advisors)。这些董事和顾问们要么是商业界和科技界的精英，要么是其它风险投资公司的投资人。他们会参与每次投资的决策，但是决定由总投资人来做。

风险投资基金的总合伙人的法人代表和基金经理们一般都是非常懂技术的人，很多人是技术精英出身，很多人自己还成功创办过科技公司。比如被称为世界风投之王的约翰.多尔（John Doerr）原来是英特尔公司的工程师。中国最大最好的两个风投公司北光（Northern Light）和赛伯乐（Cybernaut）的创始人以前都是非常成功的企业家。比如创办北极光创投的邓峰和柯岩博士，原来是世界上最大的网络防火墙公司 Netscreen 的创始人，同时是网络安全的专家。赛伯乐的创始人朱敏博士是世界上最大的电话电视会议技术和服务公司 Webex 的创始人。为了确保对最先进技术的了解，风险投资公司会招很多技术精英，同时还会请外面的技术顾问，比如斯坦福大学的教授，一起来帮助评估每一项投资。

风险投资基金一旦进入被投的公司后，就变成了该公司的股份。如果该公司关门了，相对于公司创始人和一般员工，风投基金可以优先把公司财产变卖后的钱拿回去。但是，这时能拿回的钱通常比零多不了多少。如果投资的公司上市或者被收购，那么合伙人或者直接以现金的方式回收投资，或者获得可流通的股票。这两种方式各有利弊，都有可能被采用。前者一般针对较小的基金和较少的投资，总合伙人会在被投资的公司上市或者被收购后的某一个时间（一般是在解禁期Lock Period 以后）将该基金所拥有的全部股票卖掉，将收入分给各个合伙人。这样基金管理的成本较低。但是，如果基金占得股份较大，比如风险投资在很多半导体公司中常常占到股份的一半以上，这种做法就行不通了。因为上市后统统卖掉其拥有的股票，该公司的股价会一落千丈。这时，风险投资的总合伙人必须将股票直接付给每个合伙人，由每个合伙人自己定夺如何出售股票。这么一来，就避免了股票被同时抛售的可能性。虽然这么做基金管理的成本（主要是财务上的成本）增加了不少，但是大的风投公司必须这么做，比如 KPCB 和红杉风投在 Google 上市 180 天后，各自拥有几十亿美元 Google 股票，如果这些股票一下子涌到股市上，就会造成 Google 股票的大跌，于是两家风投将股票分给了有限合伙人，由他们自行处理。事实上大部分合伙人并没有抛售，结果 Google 的股票在 180 天后不降反涨。

为了降低风险，一轮风投基金必须要投十几家到几十家公司。当然，为了投十家公司，基金经理可能需要考察几百家公司，这笔运作的费用不是个小数，必须由有限合伙人出，一般占整个基金的 2%。风投公司总合伙人为了挣钱，还要从有限合伙人赚到的钱中提取一部分利润，一般是基本利润（比如 8%）以上部分的 20%。比如某个风投基金平均每年赚了 20% 的利润，总合伙人将提取（20%-8%）×20%=2.4%，外加 2% 的管理费共 4.4%，而有限合伙人得到的回报其实只有15.6%，只相当于总回报的四分之三。因此，风投公司的收费其实是非常高昂的。

管理风投基金的风投公司本身也是个 LLC，其最高管理者就是风投公司的合伙人了（Partner）。风投公司本身不会有什么 CEO、总裁之类的头衔（有这些头衔的风投公司一定是冒牌货），风投公司的合伙人不仅在风投公司内部地位崇高，而且在科技界呼风唤雨，比如 KPCB 的合伙人约翰•多尔就是 Google、太阳、亚马逊等多家上市公司和更多未上市公司的董事。在风投刚刚进入中国时，发生过这样一件趣事。在一次风险投资研讨会上，来了很多公司的 CEO、总裁等“贵宾”，礼仪小姐一看这些人的职务，便把他们请到前排入座。后来来了一位客人，礼仪小姐一打听是什么合伙人，便把他安排到后面一个不起眼的角落里就座。这位合伙人没说什么就在后排坐下了。结果那些 CEO 和总裁们看他坐到了最后，谁都不敢往前面坐了，因为这些 CEO 和总裁们所在的公司都是他投资的，而他们的职位也是他任命的。由此可见风投合伙人在业界的影响。

大的风险投资公司每一轮融资的资金都很多，比如红杉风投一轮基金动辄十几亿美元，如果每家公司只投资一两百万美元，一来没有这么多公司可供投资，二来即使有，总合伙人要在几年里审查几千几万家公司，也是明显不现实的，因此它们每一笔投资不能太小；而另一方面，新成立的公司本身都很小，尤其是初期，它们只需要融资几十万甚至几万美元就可以了，大风险投资公司就不会参与。对于这些公司的投资就由一类特殊的风险投资商——天使投资人来完成。

天使投资（Angel Investment）本质上是早期风险投资。天使投资人，简称天使，常常是这样一些有钱人：他们很多人以前成功地创办了公司，对技术很敏锐，又不愿意再辛辛苦苦创业了，希望出钱让别人干。在硅谷这样的人很多，他们的想法就是“不愿意当总（经理），只肯当董（事）”。

一些天使投资人独立寻找项目，进行投资，但是更多的情况是几个人凑到一起组成一个小的有限责任公司 LLC 或者有限伙伴关系（Limited Partnership，简称 LP），通常称作天使投资社 Angel Firm 来共同投资。天使投资社的经营管理方法千差万别，有的是大家把钱凑在一起，共同投资；有的是每个人自己选项目各自投资，同时介绍给社里，社里会加倍投入（Match）该天使投资人所投金额。其实，约翰.多尔和麦克.莫利兹投资 Google 是就是采用这种策略，他们两人每人从自己口袋里拿出一些钱投给Google，同时他们所在的KPCB和红杉风投拿出同样（可能更多）的钱也投到了 Google 上。当然，有些天使投资社管理更灵活，当某个天使投资人投资一个公司后，其他合伙人可以选择跟进（Follow），也可以不跟进（Pass），没有什么义务，大家坐到一起只是为了讨论一下问题而已，共同使用一个律师和会计。

了解了风险投资的管理结构，接下来让我们看看天使投资人和风险投资公司是如何投资的。
第三节 风投的过程

风险投资的过程其实就是一个科技公司创办的过程。在美国，一个新兴的科技公司（Startups）的创业过程通常是这样的：来自思科公司的工程师山姆和IBM公司的工程师强尼发明了一种无线通信的技术，当然这种技术和他们所在公司的核心业务无关，两人觉得这种技术很有商业前景，他们就写了个专利草案，又花五千美元找了个专利律师，向美国专利局递交了专利申请（关键之一，知识产权很重要）。两个人下班后以及周末的所有时间全泡在山姆家的车库里用模拟软件 Matlab 进行模拟，证明这种技术可以将无线通信速度提高五十倍（关键之二，是否有数量级的提高是衡量一项新技术是革命性的还是革新性的关键。）两个人想了好几种应用，比如代替现有的计算机 Wifi，或者用到手机上，于是在原有的专利上又添加了两个补充性专利。强尼和山姆于是拿着自己做的 Powerpoint 投影胶片、实验结果和专利申请材料到处找投资者，在碰了七八次壁以后，找到了山姆原来的老板，思科早期雇员亚平。亚平从思科发了财后不再当技术主管了，自己和几个志同道合的有钱人一起在做天使投资人。亚平和不下百十来个创业者谈过投资，对新技术眼光颇为敏锐，发现山姆和强尼的技术很有独到之处，但是因为山姆和强尼讲不清楚这种技术的具体商业前景在哪里，建议他们找一个精通商业的人制定一个商业计划 Business Plan（关键之三，商业计划很重要）。

强尼找到做市场和销售的朋友迪克，并向迪克大致介绍了自己的发明，希望迪克加盟共同开发市场。迪克觉得和这两个人谈得来，愿意共同创业。这时出现了第一次股权分配问题。

到目前为止，所有的工作都是山姆和强尼做的，两个人各占未来公司的 50% 股权和投票权。迪克加盟后，三个人商定，如果迪克制定出一个商业计划书，他将获得 20% 的股权，山姆和强尼将减持到 40%。迪克经过调查发现，山姆和强尼的发明在高清晰度家庭娱乐中心的前景十分可观，于是制定了可行的商业计划书，并得到了 20% 的股权。三个人到目前为止对今后公司的所有权见下表。



三个人再次找到亚平，亚平请他的朋友，斯坦福大学电机工程系的查理曼教授作了评估，证实了山姆等人的技术是先进的并有相当的复杂度，而且有专利保护，别人不易抄袭模仿。亚平觉得可以投资了，他和他的天使投资团觉得山姆、强尼和迪克的工作到目前为止值（未融资前）一百五十万美元，而三个创业者觉得他们的工作值二百五十万，最后商定定价二百万（注：对公司的估价方法有按融资前估价，即 Pre-Money ，和融资后估价，即 Post-Money 两种。从本质上讲，这两种方法是一样的，我们这里的估计都以 Pre-Money 来计算）。亚平和他的投资团投入五十万，占到股份的 20%。同时，亚平提出下列要求：

1.亚平要成为董事会成员；
2.山姆、强尼和迪克三人必须从原有公司辞职，全职为新公司工作。并且在没有新的投资进来以前，三个人的工资不得高于每月四千美元；
3.山姆等三人的股票必须按月在今后的四年里逐步获得（Vested），而不是在公司成立时立即获得。这样如果其中有人离开了，他只能得到一部分股票；
4.如果有新的任何融资行为必须通知亚平的天使投资团。

现在山姆等人就必须正式成立公司了。为了将来融资和开展业务方便起见，他们在特拉华州注册了赛通科技有限公司。山姆任董事会主席、迪克和亚平任董事。山姆任总裁，强尼任主管技术的副总裁兼首席技术官，迪克任主管市场和营销的副总裁。三个人均为共同创始人。公司注册股票一千五百万股，内部核算价格每股二十美分。

在亚平投资后（的那一瞬间），该公司的内部估计已经从两百万增加到二百五十万，以每股二十美分计算，所有股东的股票只占到 1250 万股（250万/0.2=1250万）。那么为什么会多出来 250 万股，它们并没有相应的资金或者技术做抵押，这些股票的存在实际上稀释了（Dilute）所有股东的股权。为什么公司自己要印这些空头钞票呢？因为它们必须留出来给下面的用途：

1.由于山姆等人的工资很低，他们将根据自己的贡献，拿到一部分股票作为补偿；
2.公司正式成立后需要雇人，需要给员工发股票期权；
3.公司还有一些重要的成员没有进来，包括 CEO，他们将获得相当数量的股票。

现在，该公司各位股东股权如下：



接下来，山姆等人辞去以前的职务，全职创业。公司很成功，半年后做出了产品的原型（Prototype）。但是，50 万投资已经花完了，公司也发展到 20 多人。250 万股票也用去了 150 万股。这时，他们必须再融资。由于该公司前景可观，终于得到了红杉风投的青睐。红杉风投为该公司作价 1500 万美元，这时，该公司的股票每股值 1 美元了，比亚平投资时涨了四倍。红杉同意投资 500 万美元，占 25%，这样总股数增加到 2000 万股。同时，红杉风投将委派一人到该公司董事会任职。山姆等人还答应，由红杉风投帮助寻找一位职业经理人做公司的正式 CEO。双方还商定，融资后再稀释 5%，即 100 万股，为以后的员工发期权。现在该公司股权如下：



读者也许已经注意到，红杉风投现在已经成为了最大的股东。

两年后，该公司的样品研制成功，并获得东芝公司的订单，同时请到了前博通公司的 COO 比尔出任 CEO。比尔进入了董事会，并以每股三美元的价钱获得 100 万股的期权。当然新来的员工也用去一些未分配的股票。这时该公司的股价其实比红杉风投投资时，已经涨了两倍。比尔到任后，公司进一步发展，但是仍然没有盈利。于是，董事会决定再一次融资，由红杉风投领头协同另两家风投投资一千五百万。公司在投资时作价一亿五百万，即每股五美元。现在，该公司股权变为：



这时，投资者的股份已占到 44%，和创始人相对，即拥有了一半左右的控制权。又过了两年，该公司开始盈利，并在高盛的帮助下增发六百万股，在纳斯达克上市，上市时原始股定价每股 25 美元。这样，一个科技公司在 VC 的帮助下便创办成功了。上市后，该公司总市值大约七亿五千万美元。该公司股权如下：



这时，创始人山姆等人成了充满传奇色彩的亿万富翁，其员工共持有价值近五千万美元的股票，不少也成了百万富翁。但是，山姆等全体公司员工只持有 44% 的股份，公司的所有权的大部分从创始人和员工手里转移到投资者手中。一般来讲，一个创始人在公司上市时还能握有 10% 的股份已经很不错了。

作为最早的投资者，亚平的天使投资团收益最高，高达一百二十四倍。红杉风投的第一轮获利二十四倍，第二轮和其它两家风投均获利四倍。显然，越早投资一个有希望的公司获利越大，当然，失败的可能性也越大。一般大的风投基金都会按一定比例投入到不同发展阶段的公司，这样既保证基本的回报，也保证有得到几十倍回报的机会。

我不厌其烦地计算每一个阶段创始人和投资人的股权和价值，是想为那些想求助于风险投资创业的人提供一个参考。我遇到了许多创业者，他们在接触投资人时几乎毫无融资的经验，有些漫天要价，有些把自己贬得一钱不值。我们从这个例子中可以看到，风险投资必须是渐进的，在每一个阶段需要多少钱投入多少钱，这样对投资者和创业者都有好处。对投资者来讲，没有任何一家投资商会在刚开始时就把今后五年的开销全包了的，这样风险太大。对创业者来讲，早期的公司股价都不会高，过早大量融资会使得自己的股权占得太低，自己不但在经济上不划算，而且还会失去对公司的控制，甚至在创业的一半就被投资人赶走。在上面的例子中，天使投资人和风投一共投入两千零五十万美元，在上市前占到 43%，三个创始人和其他员工占 57%。如果在最初公司估价只有两百万时就融资两千多万，到上市前，投资方将占股份的 80% 以上，而创始人和员工占不到 20%。

上面的情况是一个简化得不能再简化的投资过程，任何一个成功的投资都会比它复杂得多。比如，通常天使投资人可能是几家而不是一家，很多人都会要求坐到董事会里去，这样在真正风险投资公司投资时，董事会已经变得很庞大。在这种情况下，风投公司通常会以当时合理的股价（Fair Market Value）从天使投资人手中买回股权，并把他们统统从董事会中请出去。否则每次开董事会坐着一屋子大大小小的股东，大家七嘴八舌，还怎么讨论问题。大部分天使投资人也愿意兑现他们的投资收益，以降低自己的投资风险。

上面这个例子是一个非常理想的情况，该公司的发展一帆风顺，每一轮估价都比前一轮高，实际情况可能并非如此。不少公司在某一轮风险投资资金用完的时候，业绩上并没有太大的起色，下一轮融资时估价还会下降。我的一个朋友曾经在这样一家半导体公司工作，他们花掉了近亿美元的投资仍然不能使公司盈利，这样必须继续融资，新的风投公司给的估价只有前一次估价的三十分之一，但是创始人和以前的投资人不得不接受这个估价，以避免公司关门，那样他们的投资一分钱也拿不回来。

第四节 投资的决策和公司的估价

我们在上一节中举了一个风投投资的例子，在这个例子中，我们忽略了两个关键性的问题：风险投资公司如何决定是否投资一个公司（或者一个产业），以及如何决定一个小公司的价值。这两个问题要回答清楚需要专门写一本书，因为每一次投资的情况都不相同，前一次投资的案例通常不能用到下一次。因此，这里我们简单介绍一下一些投资和估价的原则。

我们从上面的例子可以看出，风投常常是分阶段的，可以有天使投资阶段、第一轮和后一轮（或者后几轮）。天使投资阶段的不确定性最大，甚至无章可循，很多成功天使投资回想起来都不知道是如何成功的，包括开始投资 Google 的一些天使投资人都搞不清楚 Google 是干什么的。我的一位朋友是世界上该领域最大的公司的创始人之一，该公司先在纳斯达克上市，后来又以几十亿美元的高价卖掉。这位共同创始人对我讲，他们创业的第一笔钱，是从一个台湾的天使投资人那里拿到的五十万美元。这个投资人根本就不是IT领域的人，也搞不懂他们要干什么，最后请了一位相面先生给他们三个人看了看相，这三个人身材高大，面相也不错，于是那位投资人就投资了。当该公司以几十亿美元的高价被收购时，这位天使投资人也许应该感谢那位相面先生，为她带来了上百倍的投资收益。

正是因为这种不确定性，很多大的风险投资公司都跳过这一轮。一些更加保守的风投基金只参加最后一轮的投资。有些清清楚楚地说明在下面几种情况下不投资：
1. 不盈利的不投，
2. 增长不稳定的不投，
3. 公司达不到一定规模的不投，

甚至有些风投基金只投已经有了十二到二十四个月内上市计划的公司。当然，到了这一步，常常是融资的公司挑选风投了，能在这一步拿到合同的风投要么是在IT界关系很广的公司，要么是很有名的公司，以至于新兴公司上市时要借助它们的名头。通常，当股民们看到某家将要上市的公司是 KPCB 或者红杉风投投资的，他们会积极认购该公司上市发行（IPO）的股票。

比较复杂的是中间的情况。让我们来看两个我遇到的真实的例子，读者就会对风投的决策过程和股价方法有了解。

一位世界名牌大学的学生发明了一种手机上的软件，非常有用，他在网上让人免费下载试用，然后在试用期满后向愿意继续使用的用户收一些钱，这样几年他也挣了十来万美元。他想成立一家公司把这个软件做大做好。他找到一家风投，正巧这个风投基金的总合伙人是我的朋友，就拉我一起和这个创业者面谈。我们仔细听了他的介绍并且看了他的软件。投资人承认他是个有能力的年轻人，软件也是个好软件，但是不投资。投资人给他算了一笔账。这种手机上的软件要想推广必须在手机出厂时预装，一般来讲，虽然这种软件的零售价可以高达十美元以上，但是手机厂商出的预装费不会超过一毛钱，假定为八美分。通常一个领域在稳定的竞争期会有三个竞争者，不妨假设这个创业者能跻身于三强并排到老二。在软件业中，一般前三名的市场份额是 60%、20% 和 10%（剩下 10% 给其它的竞争者），那么在很理想的情况下，这位创业者可以拿到全世界 20% 的手机市场的预装权。我们不妨假设全世界手机一年销售十亿部，他可以拿到两亿部的预装权，即一年两千万美元的营业额。读者可能会觉得两千万美元是个不小的数目，但实际上在风投眼里却没有多少，在美国一个工程师一年的开销就要二十万美元。世界上有四五个国家近十个主要手机生产厂家，要想拿下这 20% 的市场需要一家一家谈。手机的软件不像个人计算机的软件，有了漏洞（Bug）在网上发布一个补丁自动就补上了，手机软件出了问题有时要将手机回收，因此手机厂商测试时间很长，拿下一个手机合同一般要 18 个月的时间，因此这款软件的销售成本是很高的。我们不妨假设这个小公司的纯利润率有 15%（已经不低了），那么它一年的利润是二百四十万美元，虽然读者觉得一年挣几百万美元已经不错了，但是因为这个生意不可能成长很快（取决于手机市场的成长），在股市上市盈率（ P/E 值）平均也就是 20 倍，那么这个公司的市值最多最多不超过五千万美元。一个价值不超过一亿美元的公司是无法在美国上市的，因此这个公司还没有创办，它无法上市的命运就已经注定了。这位同学失败的原因不在技术上，不在他个人的能力，而是题目没有选好。风投喜欢的是所谓的十亿美元的生意（Billion Dollar Business）。最后，我做风投的朋友建议这位同学找找天使投资人，因为这样一件事做好了还是有利可图的，也许会有天使投资人喜欢投资。

风投由于是高风险的，自然要追求高回报。每当创业者向我介绍他们的发明时，我问的第一个问题就是：“你怎么保证把一块钱变成五十块”。虽然风险投资最终的回报远没有几十倍，但是，投资者每一次投资都会把回报率定在几十倍以上（上面那个手机软件显然达不到几十倍的回报）。因此我这第一句话通常就难倒了一多半创业者。大部分人听到这句话的反应是：“要这么高的回报？是否太贪了？两年有个三五倍不就不错了吗？”一般传统的投资几年有个三五倍的回报确实已经很不错了，但是由于风投失败的可能性太大，它必须把回报率定得非常高才能收回整体投资。据我一位做风投的朋友讲，红杉风投当年投资 Google 的那轮风投基金高达十几亿美元，只有 Google 一家投资成功了，如果 Google 的回报率在一百以下，整轮基金仍是亏损的。从另一方面看，对风投来讲几十倍的投资回报是完全可及的。五十年代早期风投 AR&DC 投资 DEC，回报是五千倍（$70,000 到 $355,000,000），KPCB 和红杉风投投资 Google 是五百倍（一千万到五十亿美元），而 Google 的第一个天使投资人安迪.贝克托森的回报超过万倍（十万美元到今天的十五亿美元）。

要做到高回报必须首先选对题目。一个好的创业题目最要紧的是具有新颖性，通常是别人没想到的，而不是别人已经做成功的。很多创业者喜欢模仿，虽然这样也有成功的可能，却不可能为风投挣到几十上百倍的投资回报。比如中国九十年代出现了很多做 DVD 机的厂家，早期的几家挣到了钱，后面的几百家都没挣到什么钱；其次，创业的题目不能和主流公司的主要业务撞车。九十年代时，风投公司对软件公司的创业者问的第一个问题是“你要做的事情，微软有没有可能做？”这是一个无法回答的问题。如果回答“可能”，那么风投基金的总合伙人接下来就会说“既然微软会做，你们就不必做了。”如果回答是“不会”，那么总合伙人又会说“既然微软不做，看来没必要做，你们做它干什么？”二零零零年后，风投公司还是对软件和互联网的创业者问这个问题，只是微软变成了 Google。这个例子说明，如果创业的项目和微软和 Google 这样的公司的业务有可能撞车，那么失败的可能性极大。

除此之外，一个好的题目还必须具备以下几个条件：

1. 这个项目一旦做成，要有现成的市场，而且容易横向扩展（Leverage）。
这里面要说几句“现成市场”的重要性，因为一个新兴公司不可能等好几年时间，等市场培养成熟才开始销售。事实上有很多失败的例子是技术、产品都很好，但市场条件不成熟。比如当年甲骨文搞的网络 PC，从创意到产品都不错，但是当时既没有普及高速上网，更没有强大的数据中心，因此失败了。直到十年后的今天，Google 提出“云计算”的概念并建立了全球相联的超级数据中心，拉里•埃里森的这个梦想才可能成为现实。但是，没有一个小公司能等得起十年。
横向扩展是指产品一旦做出了，很容易低成本的复制并扩展到相关领域。微软的技术就很好横向扩展，一个软件做成了想复制多少份就复制多少份。太阳能光电转换的硅片就无法横向扩展，因为它要用到制造半导体芯片的设备，成本很高，而且不可能无限制扩大规模，因为全世界半导体制造的剩余能力有限。

2. 今后的商业发展在较长时间内会以几何级数增长。
我们前面介绍的手机软件的项目就不具备这个特点，因为它的增长被手机的增长限制死了。

3. 必须具有革命性。
我通常把科技进步和新的商业模式分成进化（Evolution）和革命（Revolution）两种，虽然它们的英文单词只差一个字母，意义可差远了。创业必须要有革命性的技术或者革命性的商业模式。

现在，让我们看一个好的例子——PayPal，它具备上述好题目所必需的条件。首先，它的市场非常大。世界上每年的商业交易额在数十万亿美元，其中现金占了将近一半，信用卡占四分之一；其次，它的市场条件成熟了。随着网上交易的发展，现金和支票交易显然不现实，只能使用信用卡，其交易方式如下：



而信用卡在网上使用经常发生被盗事件（比如商家是钓鱼的奸商，一旦获得买家信用卡信息，就会滥用其信用卡），安全性有问题。因此，需要一种方便的网上支付方式。

PayPal 的想法很好，由它来统一管理所有人的信用卡或者银行帐号，商家不能直接得到买家的帐号信息。交易时，商家将交易的内容告知 PayPal，并通过 PayPal 向买家要钱，买家确认后，授权 PayPal 将货款交给商家，商家无法得知买家信用卡和银行账户信息。而且，PayPal 要求商家和买家提供并确认真实的地址和身份，尽量避免欺诈行为。对于五百美元以下的交易，PayPal 为付款方提供保险，如果付款方被骗，PayPal 将偿还付款方损失，由它去追款。PayPal 的商业模型如下：



这种付款方式要安全得多，其好处是易见的，当网上购物的发展起来后，其推广的条件便具备了，不需要培养市场。而每年十几万亿美元的交易，对 PayPal 来说几乎是无穷大的发展空间，尽管 PayPal 现在每年以 30-40% 的高速度发展，到 2007 年仍然只有 40 亿美元左右的交易额，发展空间很大。所以 PayPal 这个题目是一个可以在很长时间内高速发展的生意。PayPal 在技术上虽然没有什么独到之处，但是它的商业模式却是革命性的。

风投公司一旦确定什么生意、什么公司可以投资，接下来的问题就是如何估价一家投资对象了。和投资股市不同，风险投资的对象大多没有利润甚至没有营业额可言，其估价不能按照传统的市盈率（P/E值）或者折扣现金流（Discounted Cash Flow）来衡量，关键是看今后几年该公司发展的前景以及看到目前为止该公司发展到哪一步了。和投资股市另一个不同之处，新创公司因为没有什么业绩可以衡量，创始人和早期员工的素质就变得很关键。一般来讲，一些 High Profile 的创始人，比如思科公司的资深雇员和斯坦福的教授，创办的公司容易获得较高的股价。

风险投资公司一旦将资金投入一个新创的公司后，它的投资任务还远没有完成，从某种角度上讲，它才刚刚开始。

第五节 风投的角色

对风险投资家来讲，最理想的情况是能当一个甩手掌柜：把钱投到一家公司，不闻不问，几年后几十倍的利润拿回来。这种情况对于天使投资确实发生过，比如有一个从洛杉矶募集资金的天使投资团将钱投入了早期的 Google，等 Google 上市时，该投资团的合伙人，包括 NBA 明星奥尼尔、加州州长施瓦辛格和一些好莱坞明星，稀里糊涂地就挣到了一大笔钱。对于比较大的风险投资，反而很少发生。大多数办公司的人的经验总有局限性，尤其是 IT 行业的创始人大多是技术出身，没有商业经验和“门路”（在美国，门路和在中国一样重要）。风投公司就必须帮助那些创始人把自己投资的公司办好。毕竟，他们已经在一条船上了。

风投公司介入一个新兴公司后的第一个角色就是做顾问。这个顾问不仅需要在大方向比如商业上给予建议，而且还要在很多小的方面帮助创始人少走弯路。我在前一章“硅谷的另一面”中提到，创办一个小公司会遇到形形色色的问题，而创始人常常缺乏处理这些问题的经验，这时风投公司（坐在被投公司董事会席上的那个人）就必须帮忙了。我的一位朋友原来是苹果公司副总裁、乔布斯的朋友，现在是活跃的投资人，他给我讲了下面一个例子。

留心各大公司图标（Logo）的读者也许会注意到，几乎所有大公司的图标和名称字体都是一种简单的颜色设计，尤其是在二十年前。至今很少有公司像 Google 那样使用明暗分明的彩色图标。我的这位朋友告诉我，这主要有两个原因：首先，彩色印刷比单色（和套色，比如普通黑字套蓝色）印刷要贵得多，公司初办，必须本着能省一点是一点的原则，如果一个公司所有的文件和名片都采用彩色印刷，办公成本将增加；第二，也是更重要的，所有的传真机和绝大部分复印件都是黑白的，印有彩色图标的公司传真不仅不可能像原来彩色的那样好看，而且有些颜色可能还印不清楚。这样不仅让商业伙伴感到糊涂，还不容易给客户留下深刻印象。他告诉我，很多年轻的创始人喜欢为自己公司设计漂亮的彩色图标，实际宣传效果并不好。比如下面一个漂亮的彩色图标：



当我在不同复印件上拷贝时，得到两个颇为不同的黑白复印件。不仅原来精心设计的丰富色彩在传真文件中看不到，而且每次黑白复印件深浅不同，反而会让商业伙伴和客户糊涂。






下面是 IBM 和 AT&T 公司早期的图标，它们避免了复印和传真可能带来的迷惑。





当然，上面只是一个小的例子。风投介入一个新兴公司后，可以帮助创业者少走很多弯路，总的来讲好的风投是创业者的伙伴。

当然，风投不可能替公司管理日常事务。这就有必要替公司找一个职业经理人来做 CEO（当然，如果风投公司觉得某个创始人有希望成为 CEO，一般会同意创始人兼 CEO 的职位）。每个风投基金投资的公司都有十几到几十家，要找到几十个 CEO 也并非容易的事。因此，有影响的老牌风投公司实际上手里总攥着一把 CEO 候选人。这些人要么是有经验的职业经理人，要么是该风投公司以前投资过的公司的创始人和执行官。风险投资家给有能力的创始人投资的一个重要原因就是锁定和他的长期关系。如果后者创业成功固然好，万一失败了，风投资本家在合适的时候会把他派到自己投资的公司来替自己掌管该公司日常事务。一个风投公司要想成功，光有钱，有眼光还很不够，还要储备许多能代表自己出去管理公司的人才。这也是著名风险投资公司比小投资公司容易成功的原因之一，前者手中攥着更多更好的管理人才。

风投公司首先会帮助被投资的公司开展业务。自己开公司的人都知道，一个默默无闻的小公司向大客户推销产品时，可能摸不对门路。这时，“联系”广泛的风投公司会帮自己投资的小公司牵线搭桥。越是大的风险投资公司越容易做到这一点。风投公司还会为小公司请来非常成功的销售人才，这些人靠无名小公司创始人的面子是请不来的。风投广泛的关系网对小公司更大的帮助是，它们还会帮助小公司找到买主（下家）。这对于那些不可能上市的公司尤其重要。比如，KPCB 早期成功地投资太阳公司后，就一直在太阳公司的董事会里，利用这个方便之处，KPCB 把它自己后来投的很多小公司卖给了太阳，这些小公司对太阳是否有用就不得而知了，但是，投资者的钱是收回来了，创业者的努力也得到了客观的回报。在这一类未上市公司收购案中，最著名的当属 Google 收购 YouTube 一事。两家公司都是由红杉风投投资，著名投资人莫利兹同时担任两家公司董事。YouTube 能成功地卖给 Google，红杉风投作用不小。风投行业经过几十年的发展，就形成了一种马太效应。越是成功的风投公司，投资成功上市的越多，它们以后投资的公司相对越容易上市、再不济也容易被收购。因此，大多数想去小公司发财的人，选择公司很重要的一个原则就是看它幕后的风投公司的知名度。Google 在很早的时候就已经是求职者眼中的热门公司了，固然有它许多成功之处和吸引人的办法，以及创始人的魅力，但是还有非常重要的一条就是它是第一家KPCB和红杉风投在同一轮一起投资的公司，在此以前，这两家风投从不同时投一家公司。

风投是新兴公司的朋友和帮手，因为它们和创始人的基本利益是一致的。但是通常也有利益冲突的时候。任何一个公司的创办都不是一帆风顺的，当一个被投公司可能前景不妙时，如果投资者对它是控股的，可能会选择马上关闭该公司或者贱卖掉，以免血本无归。这样，创始人就白忙了一场，因此创始人一定会倾向于继续挺下去，这时就看谁控制的股权，更准确的讲是投票权（Voting Power）多了。当一家公司开始盈利有了起色时，风投会倾向于马上上市收回投资，而一些创始人则希望将公司做得更大后再上市。投资人和创始人闹得不欢而散的例子也时常发生，投资人甚至会威胁赶走创始人。

创业者和投资者的关系对于成功的创业至关重要。首先，创始人总是在前台扮演着主角，风投在幕后是辅助者。如果投资者站到了前台，要么说明创始人太无能，要么说明投资人手伸的太长，不管是哪一种情况，公司都办不好；其次，创业者和投资者的关系是长期的，甚至是一辈子的。对投资者来讲，投资的另一个目的是发现并招揽人才。对投资人来讲，创业者能一次成功当然是最好的，但是，非常有能力能干事的创始人也会因为时运不济而失败，这时投资者如果认定创始人是个人才，将来还会为他的其它项目投资，或者将他派到新的公司去掌舵。因此，对创业者来讲，虽然风险投资的钱不需要偿还，但是，拿了投资者的钱就必须使出吃奶的力气尽力将公司做好，以获得投资者的青睐。一些短视的创业者把风投公司当作一次性免费提款机，只拿钱而不承担应尽的义务，实际上便永远地断了自己的后路。和很多行业不同，不同风险公司的投资家们一般会经常通消息，一个人一旦在风投圈子里失去了信用，基本上一辈子就失去了获得风投资金再创业的可能。

第六节 著名的风投公司

就像华尔街已经等同于美国金融业一样，在创业者眼里“沙丘路”（Sand Hill Road）便是风险投资公司的代名词。沙丘路位于硅谷北部的门罗公园市（Menlo Park），斯坦福大学向北一个高速路的出口处。它只有两三公里长，却有十几家大型风险投资公司。在纳斯达克上市的科技公司至少有一半是由这条街上的风险投资公司投资的。其中最著名的包括红杉资本（Sequoia Capital，在中国称作红杉风投）、KPCB（Kleiner，Perkins，Caufield & Byers）、NEA（New Enterprise Associates）、Mayfield 等等。NEA 虽然诞生于美国“古城”巴尔的摩，但经营活动主要在硅谷，它投资了五百家左右的公司，其中三分之一上市，三分之一被收购，投资准确性远远高于同行。它同时是中国的北极光创投的后备公司（backing company）。Mayfield 是最早的风险投资公司之一，它的传奇之处在于成功投资了世界上最大的两家生物公司基因科技（Genentech）公司和 Amgen 公司（这两家公司占全世界生物公司总市值的一半左右）。除此之外，它还成功投资了康柏、3COM、SGI 和 SanDisk 等科技公司。而所有风投公司中，最值得大书特书的便是红杉风投和 KPCB 了。

6.1 红杉风投




Sequoia 是加州的一种红杉树，它是地球上最大的（可能也是最长寿的）生物。这种红杉树可以高达一百米，直径八米，寿命长达两千两百年。1972 年，投资家唐纳德.凡伦汀（Don Valentine）在硅谷创立了一家风险投资公司，以加州特有的红杉树命名，即 Sequoia Capital。该公司进入中国后，取名红杉风投。

红杉风投是迄今为止最大、最成功的风险投资公司。它投资成功的公司占整个纳斯达克上市公司市值的十分之一以上，包括苹果公司、Google 公司、思科公司、甲骨文公司、Yahoo 公司、网景公司和 YouTube 等 IT 巨头和知名公司。它在美国、中国、印度和以色列有大约五十名合伙人，包括公司的创始人凡伦汀和因为成功投资 Google 而被称为风投之王的麦克.莫利兹（Michael Moritz）。

红杉风投的投资对象覆盖各个发展阶段的未上市公司，从最早期到马上就要上市的公司。红杉风投内部将这些公司分成三类：

•种子孵化阶段（Seed Stage）。这种公司通常只有几个创始人和一些发明，要做的东西还没有做出来，有时公司还没有成立，处于天使投资人投资的阶段。红杉风投投资思科时，思科就处于这个阶段，产品还没搞出来；

•早期阶段（Early Stage）。这种公司通常已经证明了自己的概念和技术，已经做出了产品，但是在商业上还没有成功，当初它投资 Google 时，Google 就处于这个阶段。当时 Google.com 已经有不少流量了，但是还没有挣钱；

•发展阶段（Growth Stage）。这时公司已经有了营业额，甚至有了利润，但是，为了发展，还需要更多的资金。这个阶段的投资属于锦上添花，而非雪中送炭。

红杉风投在每个阶段的投资额差一个数量级，分别为十到一百万、一百万到一千万和一千万到五千万。

相比其它的风投，红杉风投更喜欢投快速发展的公司（而不是快速盈利的），即使它的风险较大。苹果、Google、Yahoo 等公司都具备这个特点。那么如何判定一个公司是否有发展潜力呢？根据我对红杉风投的了解，它大致有两个标准：

第一、被投公司的技术必须有跳变（用红杉风投自己的话讲叫做 Sudden Change），就是我常说的质变或者革命。当然，如何判断一个技术是真的革命性进步还只是一般的革新，需要有专业人士帮助把关。由于红杉风投名气大，联系广，很容易找到很好的专家；

第二、被投公司最好处在一个别人没有尝试过的行业，即是第一个吃螃蟹的人。比如在苹果以前，微机行业是一片空白，在 Yahoo 以前，互联网还没有门户网站。这样的投资方式风险很大，因为以前无人能证明新的领域有商业潜力，当然，回报也高。这种投资要求总合伙人的眼光要很准。相对来讲，红杉风投的合伙人经历的事情较多，眼光是不错的。

对于想找投资的新创业的公司，红杉风投有一些基本要求
1.公司的业务要能几句话就讲得清楚。红杉风投的投资人会给你一张名片，看你能不能在名牌背面的一点点地方写清楚。显然，一个连创始人自己也说不清楚的业务将来很难向别人推销。
2.就像我前面讲的那样，如果该公司的生意不是十亿美元的生意，就不用上门了。
3.公司的项目（发明、产品）带给客户的好处必须一目了然。
4.要有绝活，这就不用多说了。
5.公司的业务是花小钱就能作成大生意的。比如说当初投资思科，是因为它不需要雇几个人就能搞定路由器的设计。让红杉风投投资一个钢铁厂，它是绝对不干的。

对于创始人，红杉风投也有一些基本要求
1.思路开阔，脑瓜灵活，能证明自己比对手强。
2.公司和创始人的基因要好。当然这里不是指生物基因。红杉风投认为，一个公司的基因在成立的三个月中形成，优秀创始人才能吸引优秀的团队，优秀的团队才能奠定好的公司的基础。
3.动作快，因为只有这样才有可能打败现有的大公司。刚刚创办的小公司和跨国公司竞争无异于婴儿和巨人交战，要想赢必须快速灵活。

有志创业的读者可以记住红杉风投的联系方式：
美国3000 Sand Hill Road 4-180，Menlo Park, CA 94025 电话: 650.854.3927，传真: 650.854.2977
中国北京 朝阳区霄云路 36 号国航大厦 2408 室，邮编 100027
中国上海 南京西路 1366，恒隆广场二座 2808 室，邮编 200040

找红杉风投前，创业者要准备好一份材料，包括
1.公司目的（一句话讲清楚）。
2.要解决的问题和解决办法，尤其要说清楚该方法对用户有什么好处。
3.要分析为什么现在创业，即证明市场已经成熟。
4.市场规模，再强调一遍，没有十亿美元的市场不要找红杉。
5.对手分析，必须知己知彼。
6.产品及开发计划。
7.商业模式，其重要性就不多讲了。
8.创始人及团队介绍，如果创始人背景不够强，可以拉上一些名人做董事。
9.最后，也是最重要的—想要多少钱，为什么，怎么花。

6.2 KPCB

在风投行业，能和红杉风投分庭对抗的只有同是在 1972 年成立的 KPCB 了。KPCB 是它的四个创始人 Kleiner、 Perkins、 Caufield 和 Byers 名字的首字母。近年来，它甚至有超过红杉风投之势。

KPCB 成功投资了太阳公司、美国在线（AOL）、康柏电脑、基因科技、Google、Ebay、亚马逊（Amazon）和网景等著名公司。它投资的科技公司占 Nasdaq 前一百家的十分之一。KPCB 投资效率之高让人膛目结舌。它最成功的投资包括：
•1999 年以每股大约 0.5 美元的价钱投资 Google 一千二百五十万美元，这笔投资的回报今天近千倍；
•1994 年，投资网景四百万美元获得其 25% 的股权，回报 250 倍（以网景公司卖给美国在线的价钱计算）；
•1997 年投资 Cerent 八百万美元，仅两年后当思科收购 Cerent 后这笔投资获利二十亿美元，也是 250 倍。这可能也是它收回大规模投资最快的一次；
•1996 年投资亚马逊八百万美元，获得后者 12% 的股权，这笔投资的回报也有两、三百倍。

它早期成功的投资，包括对太阳公司和康柏电脑等公司的投资回报率不低于上述案例，只是美国证监会没有提供在线的记录，无法计算那些投资准确的回报。从这些成功投资的案例可以看出，风投公司追求五十倍的回报完全是可以做到的。

KPCB 另一个特点就是合伙人知名度极高、联系极广，除了活跃的投资人约翰多尔和布鲁克•贝叶斯（KPCB 中的 B），还包括美国前副总统戈尔、前国务卿鲍威尔和太阳公司的共同创始人 Bill Joy 等人。KPCB 利用他们在政府和工业界的影响，培养新的产业。比如鉴于戈尔同时担任了苹果公司的董事，KPCB 专门设立了一项培养苹果 iPhone 软件开发公司的一亿美元的基金。考虑到今后全球对绿色能源的需求，KPCB 又支持戈尔担任主席的投资绿色能源的基金，并且专门集资四亿美元建立了专门的基金。KPCB 通过这种方式，在美国政府制定能源政策时施加影响。KPCB 的这种做法是一般风险投资公司学不到的。

除了绿色能源外，KPCB 主要的投资集中在IT和生命科学领域。在 IT 领域，KPCB 将重点放在下面六个方向：
通信
消费者产品（比如网络社区）
企业级产品（比如企业数据管理）
信息安全
半导体
无线通信
想创业的读者可以从中找找好的创业题目。

作为世界上最大、最成功的风险投资公司。KPCB 依然保守着“礼贤下士”的好传统。KPCB 的合伙人，包括多尔本人，经常去斯坦福大学的“投资角”参加研讨会。多尔本人对年轻的创业者保证，他一定会读这些创业者写给他的创业计划书和 Email，虽然他可能没有时间一一回复。KPCB对创业者的要求和红杉风投差不多，要找 KPCB 的准备工作也和找红杉风投相似，我们就不再赘述了。中国是 KPCB 在美国本土外唯一有办公室的国家，它在北京和上海设有分部，联系地址是：
北京 100738
北京东长安街一号 东方广场 C 座 503-504 房间
上海 200031
淮海中路 1010 嘉华中心 2505

最后补充一点，除了红杉风投和 KPCB，日本的软银集团（Soft Bank）是亚洲最著名的风投公司，它成功地投资了雅虎和阿里巴巴，并且控股日本雅虎。IDG 虽然在美国没有太大的名气，但是它最早进入中国市场，在中国反而比红杉风投和 KPCB 成功。

结束语

虽然风险投资的目的是追求高利润，但这些高利润是它们应得的报酬。我对风险投资家的敬意远远高于对华尔街，因为风险投资对社会有很大的正面影响，而华尔街经常会起负面作用（最近美国的金融危机和油价暴涨就是华尔街造成的）。风险投资通常是为创业者雪中送炭，不管创业成功与否，它们都在促进技术进步和产业结构的更新。而华尔街做的事，常常是将一个口袋里的钱放到另一个口袋里，并从中攫取巨大的财富。

风险投资者是创业者幕后的帮手，但是他们不能代替创业者到前台去表演。创业的关键还在创业者自己。

发表者：Google（谷歌）研究员 吴军