《Head First 设计模式》阅读笔记（五）——单件模式

好久不见，又来到了这里。。

博客中断了如此之久，当然是有借口的。首先是单件模式的特殊性，它涉及到多线程！OMG，小弟才疏学浅，还从未写过一个多线程的程序，多进程的倒是写过一个，不过跟该模式就没太大关系了。另外，前一篇工厂模式，费了九牛二虎之力，却只弄清楚一个对象的创建，未免太桑人心了。。再者，寒假一放，就堕落了。。每天睡到中午，整体出去玩，哪有心思看设计模式。。。

 

凡此种种，都成为我没有更新博客的借口。但饭要吃，博客也还是要写，今天恨下心来，果断先放弃多线程的部分。从延迟初始化，析构等等概念入手，先写它一篇，将来弄清楚了多线程，再写一篇。。

 

单件模式，都说是最简单的设计模式，其实也是，你要做的事情就是私有化构造函数，赋值函数，设置一个唯一的静态变量，再写一个静态函数来获取这个唯一的静态变量，就成为单件模式了。

 

如何做呢，先看看Java可以怎么做（再做个声明，以下讨论，没有考虑多线程情况）：

public class Singleton { // 声明并初始化一个静态变量，由于是静态的，该变量唯一 private static Singleton single = new Singleton(); // 初始化 private Singleton() { System.out.println("Singleton constructor..."); } // 模拟析构函数实现 public void finalize() { System.out.println("Singleton destructor..."); } // 返回唯一的静态变量 public static Singleton getInstance() { return single; } // 普通方法 public void method() { System.out.println("The method of Singleton..."); } } 

main函数如下：

System.out.println("Appliction started..."); Singleton sc1,sc2; System.out.println("Start using instance..."); sc1 = Singleton.getInstance(); sc1.method(); sc2 = Singleton.getInstance(); sc2.method(); System.out.println("Appliction leaved..."); 

我们看到，这种方法是先声明一个静态变量并初始化为空，获取实例时判断，若为空，说明仍未创建，则实例化该类给静态，并返回该静态变量。其运行结果如下：

 

Appliction started...

Start using instance...

Singleton constructor...

The method of Singleton...

The method of Singleton...

Appliction leaved...

 

 

可以看到，Singleton只被初始化了一次。

至于为什么没有调用finalize 方法。也许是Java一些内部机制决定的，我不继续研究了，毕竟析构也不是Java应该关心的内容。

 

Java代码实现单例模式，我不做过多介绍了，毕竟不是我熟悉的语言，Head First上的说明也非常详细。

下面就开始考虑如何移植到c++上。

 

受Java代码影响，首先想到的是使用静态指针：

 

 

class Singleton { private: static Singleton* single; Singleton() { std::cout << "Singleton constructor..." << std::endl; } // avoid to use copy constructor function. Singleton(const Singleton&); const Singleton& operator=(const Singleton&); public: ~Singleton() { std::cout << "Singleton destructor..." << std::endl; } // returns an unique instance static Singleton* getInstance() { if (single == NULL) { single = new Singleton(); } return single; } void method() { std::cout << "The method of Singleton..." << std::endl; } }; Singleton* Singleton::single = NULL; 

 

其运行结果与Java相同。

但是，c++没有垃圾回收器！把内存的释放交给OS，让程序运行结束时再释放？根据单件模式的思想，其实这样做也是有一定道理的，因为单件模式中的单件，一定是要等整个程序运行结束才会被释放。所以，new了以后不delete实际上也是可以接受的。

 

但是心里总有疙瘩，所以查阅了很多资料，发现了智能指针。

智能指针就是被设计出来解决c++没有垃圾收集器这一缺陷的。智能指针能使对象在没有引用时，自动销毁。具体实现我就不详述了，详情可以参阅百度百科——智能指针中的内容。

 

智能指针在 <memory> 中定义，用法如下：

 

class Singleton { private: static std::auto_ptr<Singleton> single; Singleton() { std::cout << "Singleton constructor..." << std::endl; } // avoid to use copy constructor function. Singleton(const Singleton&); const Singleton& operator=(const Singleton&); public: ~Singleton() { std::cout << "Singleton destructor..." << std::endl; } // returns an unique instance static Singleton* getInstance() { if (single.get() == NULL) { single.reset( new Singleton() ); } return single.get(); } void method() { std::cout << "The method of Singleton..." << std::endl; } }; std::auto_ptr<Singleton> Singleton::single(NULL); 

使用了智能指针以后，运行结果如下：

 

Appliction started...

Start using instance...

Singleton constructor...

The method of Singleton...

The method of Singleton...

Appliction leaved...

Singleton destructor...

 

 

可以看到，在程序执行完成后，单例被析构了，很完美～

 

受到一些资料的启发，想起c++是可以直接声明静态变量的！

于是有了如下代码：

class Singleton { private: static Singleton single; Singleton() { std::cout << "Singleton constructor..." << std::endl; } // avoid to use copy constructor function. Singleton(const Singleton&); const Singleton& operator=(const Singleton&); public: ~Singleton() { std::cout << "Singleton destructor..." << std::endl; } // returns an unique instance static Singleton* getInstance() { return &single; } void method() { std::cout << "The method of Singleton..." << std::endl; } }; Singleton Singleton::single; 

直接声明一个单件，在获取实例时，返回其地址就行了。这样看来，智能指针似乎没有多大的意义了。。

其结果如下：

 

Singleton constructor...

Appliction started...

Start using instance...

The method of Singleton...

The method of Singleton...

Appliction leaved...

Singleton destructor...

 

可以看到，与之前唯一的不同是，单件的构造在程序运行之前了。。这样的话，如果这个单件很大，就会造成不必要的浪费，这当然是我们想避免的。

 

 

于是我想，局部静态变量能否达到效果呢？

class Singleton { private: // 不再声明静态成员变量 Singleton() { std::cout << "Singleton constructor..." << std::endl; } ... public: // returns an unique instance static Singleton* getInstance() { // 声明为静态局部变量，只在第一次进入函数时初始化 static Singleton single; return &single; } ... }; 

 

经测试，结果如下：

 

Appliction started...

Start using instance...

Singleton constructor...

The method of Singleton...

The method of Singleton...

Appliction leaved...

Singleton destructor...

 

 

perfect！ 初始化，析构，全都是那么称心如意。也许这就是c++中最简单的实现方案？（不知道多线程会造成什么影响-_-||）

 

回过头去看Java，就发现原来Java不支持局部静态变量。。。

 

话说回来，如果多线程中，局部静态变量可以被初始化多次的话，这最简单的方案就无法使用了，而且还不易扩展，也许多线程中，智能指针还能派上用场。

 

待我了解了多线程以后，再回来研究。。。