主题：【注意】道歉--刀耕火种的繁荣时代 的连接上次给错了 -- 柚子

外链出处

刀耕火种的繁荣时代

刘新宇

2006年三月

在以前的一篇文章《资源管理的变法》中，我曾经为了读者理解方便，刻意把宋朝说成自然环境恶劣，生产落后的“刀耕火种”时代。这其实是胡言乱语的，不可当真。实际上宋朝可以说是我国古代极其繁荣的一个顶点。经过了宋朝连年战乱后的元朝，其繁荣和文明的程度仍然让马可波罗感到震惊。在他的游记中即使除去关于元大都的叙述，对于南宋故都杭州的描写，也仍然让人惊讶不已。

问题就是在于，在我们现代人看来的“刀耕火种”时代，没有电，没有石油，没有汽车，没有空调和抽水马桶，文明和繁盛是如何实现的呢？

如果说今天软件开发界的文明和繁盛中，面向对象是一个代表；C++和Java这些是实现繁荣的电，石油和汽车。那么在“刀耕火种”的时代，只有ANSI C这个冷兵器，如何实现“盛世”呢？

首先要看一看盛世的特点，比如汉代的“文景之治”，唐代的“贞观之治”“开元盛世”。在物质丰富的同时，政治也比较宽松，文化得到发展。这些都可以归纳成一些特点。在软件开发领域，面向对象也有一些特点，最主要的是如下三个：

封装性

继承性

多态性

按照一贯的风格，为了方便读者理解，这里按部就班，把上述三个特性类比为文明社会的3个特点：

封装性——政治组织制度

继承性——人才选拔制度

多态性——财政税收制度

实现手法上，做这样的类比：

C++的实现手法——现代社会的实现手法

C 的实现手法——古代社会的实现手法

最后本文再给出在不支持多线程的操作系统上实现多线程的手法。

首先看文明社会中的政治组织制度。政治组织中非常重要的一点就是“按部就班，各司其职”。同时官员和职能也明确划分，共同“封装”在指定的部门里。对应于面相对象的封装性，其特征也是如此。这一特性把算法和数据结构等在概念上属于同一事物的内容，统一包装起来，例如C++中：

class Encapsulate{

public:

void setValue(const int v){value=v;}

const int getValue() const {return value;}

private:

int value;

};

包装内部既有数据value，也有方法如setValue和getValue，这些方法可以按照非常明确的从属关系加以调用，例如：

int main(int argc, char* argv[]){

Encapsulate v;

v.setValue(3);

cout<<"value = "<<v.getValue()<<"\n";

//error cout<<v.value;

reuturn 0;

}

政府分门别类，官员按部就班。现代文明社会可以，汉代的“九品中正”，唐代的“三省六部”也行。用ANSI C实现封装性的思路是使用函数指针。由于在ANSI C中，结构体的含义类似C++和Java中的类。虽然C中的结构体不允许含有函数成员，但是函数指针可以被当作普通的数据成员放入结构体中。唯一要做的就是，一定要正确初始化这些函数指针。所以ANSI C实现的封装特性如下：

首先在头文件中：

struct Encapsulate{

int value;

void (*setValue)(struct Encapsulate* p, const int v);

const int (*getValue)(struct Encapsulate* p);

};

struct Encapsulate* create();

然后在C文件中：

static void setValue(struct Encapsulate* p, const int v){

p->value=v;

}

static const int getValue(struct Encapsulate* p){

return p->value;

}

struct Encapsulate* create(){

Encapsulate* p=(Encapsulate*)malloc(sizeof(Encapsulate));

p->setValue=setValue;

p->getValue=getValue;

return p;

}

现在可以看看封装的效果：

int main(int argc, char* argv[]){

Encapsulate* e=create();

e->setValue(e, 3);

printf("value = %d\n", e->getValue(e));

free(e);

reuturn 0;

}

不仅输出和前面一摸一样，而且在调用方式上也非常相似。如果为了理解方便，还可以定义一个self变量：

struct Encapsulate{

//略

struct Encapsulate* self;

};

在初始化create时：

struct Encapsulate* create(){

Encapsulate* p=(Encapsulate*)malloc(sizeof(Encapsulate));

p->self = p;

p->setValue=setValue;

p->getValue=getValue;

return p;

}

这样调用的时候，就可以按照这个形式：

e->setValue(e->self, 3);

人才选拔和培养是现代文明社会中非常重要的一环，通过人才的培养和选拔，社会中沉淀的知识和经验得以积累，前人的成果得以被后人“继承”。继承性是“文明中”代码重用的重要基础之一。在C++中，子类从父类继承，可以获得父类的大量特性，例如：

class Base{

public:

void setValue(int v){value=v;}

int getValue(){return value;}

int value;

};

class Derived:public Base{

public:

void increase(){value++;}

void decrease(){value--;}

int key;

};

子类通过继承，可以在具有父类所有特性的同时，再增加子类特殊的内容，而原来针对父类的操作，也可以针对子类而不必重新改动，例如：

void initBase(Base* p){

p->setValue(0);

}

void display(Base* p){

cout<<"value="<<p->getValue()<<"\n";

}

int main(int argc, char* argv[]){

Derived foo;

initBase(&foo);

foo.increase();

foo.increase();

display(&foo);

foo.decrease();

display(&foo);

foo.key=3;

}

现代社会通过社会化的教育体系实现的功能，在古代社会同样可以实现，春秋时孔子就搞“民间教育”，弟子三千，贤者七十有二。在选拔上，现代社会有各种考试，在汉代有“举孝廉和举秀才”，唐代开始有国家统一的考试。因此继承性不是C++和Java的专利，也可以通过ANSI C加以实现，思路是在子结构体的起始位置，放入父结构体的一段数据[3]。这样只要将子结构体强制类型转换为父结构体后，就可以直接被直接当作父结构体操作。这样操作不会出现问题的原因在于，那些针对父结构体的函数，只会访问子结构体数据的前面一段，而不会访问到后继的数据部分。这个思路用ANSI C实现如下：

首先在头文件中这样定义：

struct Base{

void (*setValue)(struct Base* self, int v);

int (*getValue)(struct Base* self);

int value;

};

void constructBase(struct Base* p);

struct Derived{

struct Base base; /*实现继承*/

void (*increase)(struct Derived* self);

void (*decrease)(struct Derived* self);

int key;

};

void constructDerived(struct Derived* p);

void initBase(struct Base* p);

void display(struct Base* p);

由于C中没有构造函数的概念，所以constructXXX负责了一部分的任务，在C文件中，上述定义的实现如下：

/* Base member functions */

static void setValue(struct Base* self, int v){

self->value=v;

}

static int getValue(struct Base* self){

return self->value;

}

void constructBase(struct Base* p){

p->setValue=setValue;

p->getValue=getValue;

}

/* Derived member functions */

static void increase(struct Derived* self){

self->base.value++; /*或者((struct Base*)self)->value++;*/

}

static void decrease(struct Derived* self){

self->base.value--; /*或者((struct Base*)self)->value--;*/

}

void constructDerived(struct Derived* p){

constructBase((struct Base*)p); /*调用父类构造函数*/

p->increase=increase;

p->decrease=decrease;

}

/* global functions */

void initBase(struct Base* p){

p->setValue(p, 0);

}

void display(struct Base* p){

printf("value=%d\n", p->getValue(p));

}

上面代码中，最体现特点的是带有汉字的注释部分，这些都表明，子结构一旦向上转换为父结构后，就可以被当作父结构来对待。这是面向对象中继承的英文解释：is a type of的良好诠释。下面可以测试一下：

int main(int argc, char* argv[]){

struct Derived foo;

constructDerived(&foo);

initBase((struct Base*)&foo);

foo.increase(&foo);

foo.increase(&foo);

display((struct Base*)&foo);

foo.decrease(&foo);

display((struct Base*)&foo);

foo.key=3;

return 0;

}

调用方式和前面C++的基本一致，输出结果也一摸一样。

文明社会的政府为了保证其财政收入，都拥有一套财政税收制度。基本含义不变而课税方法多样，有的关注生产环节，有的关注流通环节，还有的着眼在消费。这样的“多态性”可以保证提纲挈领，纲举目张。在C++中多态性（这里是指运行时的多态，实现编译期多态的模板技术暂不讨论）通过虚函数(virtual function)和override/overwrite进行实现（这里暂且不提overload）。例如：

class Point{

public:

Point(int _x, int _y):x(_x), y(_y){};

virtual double radius(){ return sqrt(double(x*x+y*y)); }

int x;

int y;

};

class Point3D:public Point{

public:

Point3D(int _x, int _y, int _z):Point(_x, _y), z(_z){};

double radius(){return sqrt(double(x*x+y*y+z*z)); }

int z;

};

int main(int argc, char* argv[]){

Point* p=new Point(1,1);

cout<<"radius ="<<p->radius()<<"\n";

delete p;

p= new Point3D(1,1,2);

cout<<"radius ="<<p->radius()<<"\n";

delete p;

}

在这个例子里，Point定义了平面上的点，而Point3D定义了空间上的点，当计算点到原点的距离radius的时候，平面的计算方法和空间的计算方法不同，在这里多态的表现就是，子类Point3D重新实现了父类Point的计算方法，而其他内容则采取“拿来主义”一并继承过来。

虽然现代社会拥有完善的各种课税，比如生产和销售环节的增值税，建筑服务行业的营业税，针对企业和个人的所得税，其根本是提供国家的财政收入。在中国古代，春秋时期鲁国在前594年即实行了“初税亩”，按照土地向私有者课征。此后各朝变迁变法，税收都是其中重要一环。用ANSI C实现多态的方法如下：

首先在头文件中定义普通平面上的点和三维空间的点，并按照前面的做法，建立继承关系，为了说明多态的灵活性，还增加了一个彩色平面点的定义。：

struct point{

double (*radius)( struct point* self);

void (*display)(struct point* self, const char* name);

int x;

int y;

};

struct point* create_point(int x, int y);

struct point3D{

struct point super;

int z;

};

struct point* create_point3D(int x, int y, int z);

enum color_t{RED, GREEN, BLUE};

struct color_point{

struct point super;

enum color_t color;

};

struct point* create_color_point(int x, int y, enum color_t color);

在这套继承体系中，三维空间点和彩色平面点都从普通平面点继承来，但是在使用虚函数实现多态上有一些区别。三种点各自实现显示信息的方法display，但是彩色点直接使用平面点的radius方法计算到原点的距离，而三维空间点则override这个计算的方法。具体的实现如下：

/* point in 2D plan default member function */

static double radius(struct point* self){

return sqrt((double)(self->x*self->x + self->y*self->y));

}

static void display(struct point* self, const char* name){

printf("point %s: x=%d, y=%d\n", name, self->x, self->y);

}

static void init_point(struct point* p, int x, int y){

p->x=x;

p->y=y;

p->radius=radius;

p->display=display;

}

/* point ctor */

struct point* create_point(int x, int y){

struct point* p=(struct point*)malloc(sizeof(struct point));

init_point(p, x, y);

return p;

}

普通平面点得以实现后，现在实现三维点，需要override的方法包括radius和display，另外在构造时还要额外初始化z成员：

/* point3D overrided member function */

static double radius3D(struct point* self){

/* downcasting will cause warning */

struct point3D* p=(struct poin3D*)self;

return sqrt((double)(self->x*self->x+

self->y*self->y+

p->z*p->z));

}

static void display3D(struct point* self, const char* name){

struct point3D* p=(struct poin3D*)self;

printf("3D point %s: x=%d, y=%d, z=%d\n", name, self->x, self->y, p->z);

}

static void init_point3D(struct point3D* p, int z){

p->z=z;

((struct point*)p)->radius=radius3D; /* override */

p->super.display=display3D; /* override */

}

/* point 3D ctor */

struct point* create_point3D(int x, int y, int z){

struct piont3D* p=(struct point3D*)malloc(sizeof(struct point3D));

init_point((struct point*)p, x, y);

init_point3D(p, z);

return (struct point*)p;

}

平面上的彩色点直接使用父类的radius函数，但是需要override计算距离的radius函数。

/* color point used its fathers radius methods,

* only display function is overwrote

*/

static void display_color(struct point* self, const char* name){

struct color_point* p=(struct color_point*)self;

printf("color point %s: x=%d, y=%d, color=%d\n", name, self->x, self->y, p->color);

}

static void init_color_point(struct color_point* p, enum color_t color){

p->color=color;

p->super.display=display_color; /* only display function is overridden */

}

/* color point ctor */

struct point* create_color_point(int x, int y, enum color_t color){

struct color_piont* p=(struct color_point*)malloc(sizeof(struct color_point));

init_point((struct point*)p, x, y);

init_color_point(p, color);

return (struct point*)p;

}

现在可以测试一下这套继承体系的多态特性：

int main(int argc, char* argv[]){

struct point* p=create_point(1, 1);

printf("radius of p1=%f\n", p->radius(p));

p->display(p, "p1");

free(p);

p=create_point3D(1, 1, 2);

printf("radius of p2=%f\n", p->radius(p));

p->display(p, "p2");

free(p);

p=create_color_point(1, 1, RED);

printf("radius of p3=%f\n", p->radius(p));

p->display(p, "p3");

free(p);

return 0;

}

调用方法和C++的如出一辙，运行结果如下：

radius of p1=1.414214

point p1: x=1, y=1

radius of p2=2.449490

3D point p2: x=1, y=1, z=2

radius of p3=1.414214

color point p3: x=1, y=1, color=0

输出结果也和预想的一致，至此“刀耕火种”的ANSI C基本实现了用C++和Java体现出的面向对象三大特性。当然这里还有不完美的地方，比如没有办法限制访问权限。C++和Java提供语言级别的public, private等关键字来实现一定程度的数据隐藏。在本文的实现方法中，虽然可以通过把方法置于C文件内部实现部分private意义上的隐藏，但是却暴露了所有的数据成员。另外C++和Java都提供的函数overload，也没有给出有效的实现。但这已经不足以阻止用“刀耕火种”建立“繁荣时代”了。古代文明的魅力也正在于此。

盛世还有一些代表性的城市繁荣，比如唐的长安，北宋的汴梁，南宋的杭州。虽然现代化的大都市有惊人的硬件环境，但是在缺乏这些现代化硬件的古代，依然能够实现城市的繁荣。比如现代操作系统，天生支持多线程。可是在不支持多线程的系统上，依然不能阻止实现运算调度的尝试。这些尝试虽然不是本质上的并行处理（现代操作系统在单CPU下也不是真正意义上的并行，而是时间片的调度，当然Intel最近热炒的双核不算在内），但是依然能够给使用者并发的感觉。

下面就用C++语言本身（不使用任何多线程库）实现多线程的感觉。其思路来自一种称之为ActiveObject[4]的模式。这种思路往往类似传统的戏剧。比如《三国演义》里面长板坡，开始情节单一，过一会就出现了两个条线(thread)，一条线赵云冲进去救刘备家小去了。另一条线张飞护着刘备跑，并且设置假伏兵。两条线同时发生，都要演出，可是却只有一个舞台。办法是舞台上先演一段赵云，张飞等演员在后台休息，然后大幕落下，赵云等演员撤到后台休息，张飞他们出来再演一段。然后再次赵云上前台演，张飞去后台休息……如此往复。观众们丝毫不觉得奇怪，而很自然的认为这两段故事同时发生。演出的关键在于合理的分隔每段故事上演的时间片，让观众没有割裂的感觉。这个思路其实就是单CPU，单进程实现多线程的思路。

首先定义一个线程类，这个就是张飞和赵云的故事这种并发故事的抽象描述：

class thread{

public:

thread(int period):period_(period*1000),time_(0){};

virtual void run()=0;

virtual bool finish()=0;

bool wait(){

return (time_++%period_)!=0;

}

private:

long period_;

long time_;

};

线程的构造函数中，导演可以事先决定每段故事的演员要在后台休息的时间period，每次休息时间一到(time_++%period为0的时候)，演员们就停止休息上前台演出(run)。故事的每条线有一个结束的标志finish，当故事结束时，就再也不用到舞台上演出了。

舞台调度的实现如下：

class schedular{

public:

static schedular& instance(){

static schedular inst;

return inst;

}

void start(){

while(!queue_.empty()){

thread* p=queue_.front();

queue_.pop_front();

if(!p->wait())

p->run();

if(!p->finish())

queue_.push_back(p);

else

delete p;

}

}

void add(thread* p){

queue_.push_back(p);

}

~schedular(){

while(!queue_.empty()){

delete queue_.front();

queue_.pop_front();

}

}

private:

schedular(){}

schedular(const schedular&);

const schedular& operator=(const schedular&);

list<thread*> queue_;

};

舞台只有一个，所以被设计为singleton。在演出前，导演可以预先把这些故事线索(thread)加入到舞台调度的列表(queue_)中去，然后一旦演出开始(start)，舞台调度就不断查看调度表，把表头的故事拿出来，看看是否他们应该上台，如果该上台了，就通知他们演出(run)一段。这段演出结束后，调度询问他们所演的全部故事是否已经结束了，如果还没有，就把他们的故事再次放到调度表的最后面，然后去准备演下一条故事线索。一旦这个故事线索演出完毕，比如说赵云已经抱着阿斗冲出来了，调度就不会再把故事放到调度表的最后。赵云就可以卸装喝水彻底休息了。

现在就可以给出一个具体的故事线索作为例子了：

class counter: public thread{

public:

counter(const string name, int value, int s):thread(s), name_(name), value_(value){}

void run(){

cout<<"thread "<<name_<<": count "<<value_--<<"\n";

}

bool finish(){

return (value_<=0);

}

private:

string name_;

int value_;

};

这个故事就是：“从前有座山，山上有个庙，庙里有个和尚在将故事，讲的故事是：从前有座山……”这样的循环故事，每次上台演出就讲一句，直到讲到累了(value_为0)为止。每次在后台休息s-1分后，上台讲一句。

此后就可以演出了，导演让两个这样的故事线索同时上演，间隔的时间不同：

int main(int argc, char* argv[]){

schedular::instance().add(new counter(string("hello"), 20, 2));

schedular::instance().add(new counter(string("me"), 10, 5));

schedular::instance().start();

}

演出的效果如下：

thread hello: count 20

thread me: count 10

thread hello: count 19

thread hello: count 18

thread me: count 9

thread hello: count 17

thread hello: count 16

thread hello: count 15

thread me: count 8

thread hello: count 14

thread hello: count 13

thread me: count 7

thread hello: count 12

thread hello: count 11

thread hello: count 10

thread me: count 6

thread hello: count 9

thread hello: count 8

thread me: count 5

thread hello: count 7

thread hello: count 6

thread hello: count 5

thread me: count 4

thread hello: count 4

thread hello: count 3

thread me: count 3

thread hello: count 2

thread hello: count 1

thread me: count 2

thread me: count 1

作为现在的中国人，多少对“古代盛世”怀有一些复杂的情节。有的人怀念，恨不得能够回到唐朝去生活；有的人理性地说光是晚上没有电就受不了。有时面对计算机，手机，汽车这些东西，我也会怀疑究竟人类技术的发展是一种社会的进步还是倒退。有时候看到早上一路小跑赶公共汽车的人们生怕上班打卡迟到，我也会想究竟古代是否要活的这么紧张。

现代人还是很难摆脱历史的阴影，we learn from history that people never learn from history，看着我们一遍一遍重复古人走过的轨迹——揭竿而起，励精图治，贪污腐败，天灾人祸，战乱流离……这样兴衰治乱的演出，上帝一定也觉得很没有意思吧。

参考书目：

[1] Apache httpd source code: http://httpd.apache.org/

[2] APR, apache runtime library source code: http://apr.apache.org/

[3] Peter. Wright. Beginning GTK/GNOME programming. Peer Information. 2000

[4] Robot C. Martin, Agile software development: principles, patterns, and practice. Printice Hall. 2002.