《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...

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...

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...

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...

Appliction leaved...

Singleton destructor...

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

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

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

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

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：《Head First 设计模式》阅读笔记（五）——单件模式 - Python技术站

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

相关文章