C++单例模式——并非你想的那像简单

Author：WenHui，WuHan University，2012-12-10

前段时间忙着找工作，有一次面试官让我用C++写单例模式，我刷刷刷提笔就来。于是就随手写了如下的代码v1版：

 1 class Singlon
 2 { 
 3 private:
 4     static Singlon * inst;
 5 
 6 public:      
 7     static Singlon& instance()
 8     {
 9         if(inst != NULL) 
10         {
11             return *inst;
12         }
13         else 
14         {
15             inst = new Singlon();             
16             return *inst;
17         }
18     } // instance
19 }; // class Singlon
20 
21 Singlon* Singlon::inst = NULL;

v1是一份很标准的单例模式代码，但不够实用。面试官看着我，说“你再好好想想...”

我原本很自负，结果被问傻了，紧张之下依稀想起《程序员面试宝典C++版》的内容，好像没考虑多线程问题。于是绞尽脑汁地回想C++中的线程互斥，还好记起点LINUX C下互斥锁，于是乎就有了改进的v2版：

 1 class Singlon
 2 { 
 3 private:
 4     static Singlon * inst;
 5     pthread_mutex_t inst_lock;
 6 
 7 public:
 8     static Singlon& instance()
 9     {
10         if(inst != NULL)
11         {
12             return *inst;
13         }
14         else 
15         {
16             pthread_mutex_lock(&inst_lock);
17             if(inst == NULL)
18             {
19                 inst = new Singlon();
20             } // if
21             pthread_mutex_unlock(&inst_lock);
22             return *inst;
23         } // else
24     } // instance
25 }; // class Singlon
26 
27 Singlon* Singlon::inst = NULL;
28 Singlon::inst_lock = PTHREAD_MUTEX_INITIALIZER;

v2中首先直接判断inst是否为NULL，若不为NULL则避免调用互斥锁，因为互斥锁不仅使用系统调用，而且将导致多线程竞争等待，产生睡眠。

当写完v2时，终于有种如释重负的感觉，很欣慰，可是面试官冷冷地问我：“你仔细看看，还有什么问题么？”当时脑子一懵，TMD的还有问题？fuck！仔细再check了一下，发现if语句确实还可以有优化的余地，于是胆战心惊地写下了v3版:

 1 class Singlon
 2 { 
 3 private:
 4     static Singlon * inst;
 5     pthread_mutex_t inst_lock;
 6 
 7 public:
 8     static Singlon& instance()
 9     {
10         if(likely(inst != NULL)) 
11         {
12             return *inst;
13         }
14         else 
15         {
16             pthread_mutex_lock(&inst_lock);
17             if(likely(inst != NULL))
18             {
19                 pthread_mutex_unlock(&inst_lock);
20                 return *inst;
21             } // if
22             else 
23             {
24                 inst = new Singlon();
25                 pthread_mutex_unlock(&inst_lock);
26                 return *inst;
27             } // else
28         } // else
29     } // instance
30 }; // class Singlon
31 
32 Singlon* Singlon::inst = NULL;
33 Singlon::inst_lock = PTHREAD_MUTEX_INITIALIZER;

v3由于互拆锁会导致效用问题，越尽早释放越好，所以将一条if语句拆成两条、迟早释放，并且将条件概率大的情况放到if而非else中，用likely在汇编层上优化。我感觉这次大体上应该符合面试官要求了，但是面试官继续追问，“我再给你一次机会好好想想……”当时正值午餐时间，早晨没吃饭，肚子饿得咕咕叫，脑子都快疯了。幸好最后换了个思路，写下v4版:

 1 class Singlon
 2 { 
 3 private:
 4     static Singlon * inst;
 5 
 6 public:
 7     static Singlon& instance()
 8     {           
 9         return *inst;
10     } // instance
11 }; // class Singlon
12 
13 Singlon* Singlon::inst = new Singlon();

当提交给面试官看时，心想”今天真是倒霉”，幸而走屎运，v4预先创建好一个对象。虽然浪费空间，但不用再考虑TMD的线程互斥问题。面试官看了之后，语重心长地讲“你这个浪费空间太大，我要你实现初次使用时再申请。给你最后一次机会检查检查代码。”

晕！当时感觉已经能用的招都用了，后来放弃了，根他解释了下v3版代码，然后问他到底哪有问题。他说：“你为什么要使用互斥锁？”于是给他解释LINUX下互斥锁的实现机制。MutexLock使用SpinLock实现互斥，循环检测并休眠。当时突然想起可以直接用SpinLock实现v3的互斥，因为竞争仅发生一次，SpinLock直接采用循环检测不休眠的方式，使用“内存屏障”、“CPU屏障”等技术保证内存和CPU指令的“有序”。v5版如下：

 1 class Singlon
 2 { 
 3 private:
 4     static Singlon * inst;
 5     static raw_spinlock_t inst_lock;
 6 
 7 public:
 8     static Singlon& instance()
 9     {
10         if(likely(inst != NULL)) 
11         {
12             return *inst;
13         }
14         else 
15         {
16             spin_lock(&inst_lock);
17             if(likely(inst != NULL))
18             {
19                 spin_unlock(&inst_lock);
20                 return *inst;
21             } // if
22             else 
23             {
24                 inst = new Singlon();
25                 spin_unlock(&inst_lock);
26                 return *inst;
27             } // else
28         } // else
29     } // instance
30 }; // class Singlon
31 
32 Singlon* Singlon::inst = NULL;
33 spin_lock_init(Singlon::inst_lock);

面试官看完v5版之后，问spin_lock的实现原理，由于看过LINUX内核怎么实现所以说得比较清楚。听完我的解释，当时已经中午一点多，他也没有再多说什么，终于结束这个该死的问题。其实C++没有像JAVA和C#那样从语法上提供同步互斥的机制，我中间也表示希望换成C#，但他拒绝了，因为自我简介时说精通C++。唉，~~~~~~

其实，v5版本还可以优化，例如采用无锁的办法。但总得说来，只是将spin_lock的代码简化了一下内嵌进来。不知道是否有哪位高人可以指点一二，给一个最终优化的C++版单例模式？

《无锁队列的实现》，http://www.kuqin.com/algorithm/20120907/330193.html