最近看了Eric S. Raymond的被称为开源文化圣典的'Cathedral and Bazaar'(大教堂与市集)以及他的另外一篇文章'How To Become A Hacker'，必须承认的是我不能够完全理解其中的内容，因为没有体验，或者说我还不够资格对Hacker Culture高谈阔论，所以这里仅作部分摘要，并说说自己第一时间的感受，望日后能温故知新。

在开始了解Hacker Culture之前我们应该知道'什么是Hacker'。Hacker不同于Cracker，前者指那些热衷于计算机技术，水平高超的电脑专家，他们把通过自己的实践而获得的知识广泛传播；而后者则尤指那些为了个人利益利用计算机技术搞非法破坏的人。像我们耳熟能详的Hacker先驱包括开源软件运动的发起人Richard M. Stallman、Unix之父Ken Thompson、C语言的发明人之一的Dennis Ritchie、Linux之父Linus Torvalds以及Eric S. Raymond等等。我相信这些人才是从事计算机行业的人们心目中真正的'Hero'。

'Cathedral and Bazaar'可谓是开源世界对Hacker Culture的一个阶段性的小结，当然Hacker Culture还在进化，其内容也在不断的丰富当中。下面是从'Cathedral and Bazaar'摘录的一些我觉得能够代表Hacker Culture的语句：

1.Every good work of software starts by scratching a developer's personal itch.
这里有一个生僻词itch，这个词有'发痒'、'渴望'的意思。这句可理解为“每个好的软件工作都开始于满足开发者个人的渴望或为开发者个人'抓痒'”。Unix的起缘可以很好地证明这一点。而现在的大多数商业软件的开发者则不能归为此类，原因不讲自明。

2. Good programmers know what to write. Great ones know what to rewrite (and reuse).
Linus之所以能独立完成一个操作系统内核，很大原因是因为他没有'从头开始'，而是利用已有的优秀设计思想。

3. When you lose interest in a program, your last duty to it is to hand it off to a competent successor.
Hacker也要'能上能下'。^_^

4. Treating your users as co-developers is your least-hassle route to rapid code improvement and effective debugging.
把用户当作协作开发者。

5. Release Early, Release Often
这与4相辅相成，互利互惠。Linux已经展现给我们一个Best实践，其“早发布、常发布策略”的一个效果就是利用快速的传播反馈修订来使重复劳动达到最小。

6. Smart data structures and dumb code works a lot better than the other way around.
优秀的数据结构设计总是至关重要的，在平时的开发中这一点体会破深。Brooks曾幽默地说："Show me your [code] and conceal your [data structures], and I shall continue to be mystified. Show me your [data structures], and I won’t usually need your [code]; it'll be obvious."

7. Often, the most striking and innovative solutions come from realizing that your concept of the problem was wrong.
当你认识到你对问题的理解是错误的，这时不要灰心，因为一个具有革新性的解决方案也许正摆在你的眼前，我想很多人都有过类似的经历，Me,too。

8. "Perfection (in design) is achieved not when there is nothing more to add, but rather when there is nothing more to take away."
是不是颠覆了你以前对好的设计的理解了呢？

9. To solve an interesting problem, start by finding a problem that is interesting to you.
趣之所在，力之所在。

10. Software is developed for peer recognition not for money.
至高无上的境界，不为'铜臭'打工。

这里再列出一条，这是在一位同行给Eric的回复中提到的一条："杀掉一个项目最快的方法是在你什么都还没有之前就宣布它，我已经见的太多了，尤其是在Linux世界里"，看到这一条相信很多曾组织或参与开源项目的人都会深刻的体会到，Me , too。

中国程序员在开源软件世界中的地位大家也都略知一二，我想这或多或少都与我们对Hacker Culture的理解有关。理解和认同'Hacker Culture'是你进入开源世界的第一步，正所谓思想的融入才是真正的融入。

在线程同步方面，Posix标准定义了3种同步模型，分别为互斥量、条件变量和读写锁。APR也“浅”封装了这3种模型，只是在“读写锁”一块儿还没有全部完成。

线程同步的源代码的位置在$(APR_HOME)/locks目录下，本篇blog着重分析unix子目录下的thread_mutex.c、thread_rwlock.c和thread_cond.c文件的内容，其相应头文件为(APR_HOME)/include/apr_thread_mutex.h、apr_thread_rwlock.h和apr_thread_cond.h。

由于APR的封装过于“浅显”，实际上也并没有多少值得分析的“靓点”。所以本篇实际上是在讨论线程同步的3种运行模型。

一、互斥量
互斥量是线程同步中最基本的同步方式。互斥量用于保护代码中的临界区，以保证在任一时刻只有一个线程或进程访问临界区。

1、互斥量的初始化
在POSIX Thread中提供两种互斥量的初始化方式，如下：
(1) 静态初始化
互斥量首先是一个变量，Pthread提供预定义的值来支持互斥量的静态初始化。举例如下：
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
既然是静态初始化，那么必然要求上面的mutex变量需要静态分配。在APR中并不支持apr_thread_mutex_t的使用预定值的静态初始化(但可以变通的利用下面的方式进行静态分配的mutex的初始化)。

(2) 动态初始化
除了上面的情况，如果mutex变量在堆上或在共享内存中分配的话，我们就需要调用一个初始化函数来动态初始化该变量了。在Pthread中的对应接口为pthread_mutex_init。APR封装了这一接口，我们可以使用下面方式在APR中初始化一个apr_thread_mutex_t变量。
        apr_thread_mutex_t *mutex = NULL;
        apr_pool_t  *pool = NULL;
        apr_status_t  stat;

        stat = apr_pool_create(&pool, NULL);
        if (stat != APR_SUCCESS) {
                printf("error in pool %d\n", stat);
        } else {
                printf("ok in pool\n");
        }

        stat = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, pool);
        if (stat != APR_SUCCESS) {
                printf("error %d in mutex\n", stat);
        } else {
                printf("ok in mutex\n");
        }

2、互斥锁的软弱性所在
互斥锁之软弱性在于其是一种协作性锁，其运作时对各线程有一定的要求，即“所有要访问临界区的线程必须首先获取这个互斥锁，离开临界区后释放该锁”，一旦某一线程不遵循该要求，那么这个互斥锁就形同虚设了。如下面的例子：
举例：我们有两个线程，一个线程A遵循要求，每次访问临界区均先获取锁，然后将临界区的变量x按偶数值递增，另一个线程B不遵循要求直接修改x值，这样即使在线程A获取锁的情况下仍能修改临界区的变量x。

static apr_thread_mutex_t       *mutex  = NULL;
static int                                x       = 0;
static apr_thread_t             *t1     = NULL;
static apr_thread_t             *t2     = NULL;

static void * APR_THREAD_FUNC thread_func1(apr_thread_t *thd, void *data)
{
        apr_time_t      now;
        apr_time_exp_t  xt;

        while (1) {
                apr_thread_mutex_lock(mutex);
                now = apr_time_now();
                apr_time_exp_lt(&xt, now);
                printf("[threadA]: own the lock, time[%02d:%02d:%02d]\n", xt.tm_hour, xt.tm_min,
                         xt.tm_sec);
                printf("[threadA]: x = %d\n", x);
                if (x % 2 || x == 0) {
                        x += 2;
                } else {
                        printf("[threadA]: Warning: x变量值被破坏，现重新修正之\n");
                        x += 1;
                }
                apr_thread_mutex_unlock(mutex);
                now = apr_time_now();
                apr_time_exp_lt(&xt, now);
                printf("[threadA]: release the lock, time[%02d:%02d:%02d]\n", xt.tm_hour, xt.tm_min,
                         xt.tm_sec);
                sleep(2);
        }

        return NULL;
}

static void * APR_THREAD_FUNC thread_func2(apr_thread_t *thd, void *data)
{
        apr_time_t      now;
        apr_time_exp_t  xt;
        while (1) {
                x ++;
                now = apr_time_now();
                apr_time_exp_lt(&xt, now);
                printf("[threadB]: modify the var, time[%02d:%02d:%02d]\n", xt.tm_hour, xt.tm_min,  xt.tm_sec);
                sleep(2);
        }

        return NULL;
}

int main(int argc, const char * const * argv, const char * const *env)
{
        apr_app_initialize(&argc, &argv, &env);
        apr_status_t stat;

        //…

        /*
         * 创建线程
         */
        stat = apr_thread_create(&t1, NULL, thread_func1, NULL, pool);
        stat = apr_thread_create(&t2, NULL, thread_func2, NULL, pool);

         //…

        apr_terminate();
        return 0;
}
//output
… …
[threadA]: own the lock, time[10:10:15]
[threadB]: modify the var, time[10:10:15]
[threadA]: x = 10
[threadA]: Warning: x变量值被破坏，现重新修正之
[threadA]: release the lock, time[10:10:15]
当然这个例子不一定很精确的表明threadB在threadA拥有互斥量的时候修改了x值。

二、条件变量
互斥量一般用于被设计被短时间持有的锁，一旦我们不能确定等待输入的时间时，我们可以使用条件变量来完成同步。我们曾经说过I/O复用，在我们调用poll或者select的时候实际上就是在内核与用户进程之间达成了一个协议，即当某个I/O描述符事件发生的时候内核通知用户进程并且将处于挂起状态的用户进程唤醒。而这里我们所说的条件变量让对等的线程间达成协议，即“某一线程发现某一条件满足时必须发信号给阻塞在该条件上的线程，将后者唤醒”。这样我们就有了两种角色的线程，分别为
(1) 给条件变量发送信号的线程
其流程大致为：
{
        获取条件变量关联锁；
        修改条件为真；
        调用apr_thread_cond_signal通知阻塞线程条件满足了；—— (a)
        释放变量关联锁；
}
(2) 在条件变量上等待的线程
其流程大致为：
{
        获取条件变量关联锁；
        while (条件为假) { ——————— (c)
                调用apr_thread_cond_wait阻塞在条件变量上等待；—— (b)
        }
        修改条件；
        释放变量关联锁；
}
上面两个流程中，理解三点最关键：
a) apr_thread_cond_signal中调用的pthread_cond_signal保证至少有一个阻塞在条件变量上的线程恢复；在《Unix网络编程 Vol2》中也谈过这里存在着一个race。即在发送cond信号的同时，该发送线程仍然持有条件变量关联锁，那么那个恢复线程的apr_thread_cond_wait返回时仍然拿不到这把锁就会再次挂起。这里的这个race要看各个平台实现是如何处理的了。
b) apr_thread_cond_wait中调用的pthread_cond_wait原子的将调用线程挂起，并释放其持有的条件变量关联锁；
c) 这里之所以使用while反复测试条件，是防止“伪唤醒”的存在，即条件并未满足就被唤醒。所以无论怎样，唤醒后我都需要重新测试一下条件，保证该条件的的确确满足了。

条件变量在解决“生产者-消费者”问题中有很好的应用，在我以前的一篇blog中也说过这个问题。

三、读写锁
前面说过，互斥量把想进入临界区而又试图获取互斥量的所有线程都阻塞住了。读写锁则改进了互斥量的这种霸道行为，它区分读临界区数据和修改临界区数据两种情况。这样如果有线程持有读锁的话，这时再有线程想读临界区的数据也是可以再获取读锁的。读锁和写锁的分配规则在《Unix网络编程 Vol2》中有详细说明，这里不详述。

四、小结
三种同步方式如何选择？场合不同选择也不同。互斥量在于完全同步的临界区访问；条件变量在解决“生产者-消费者”模型问题上有独到之处；读写锁则在区分对临界区读写的时候使用。