12582人阅读
设计模式（10）
面试的时候，问到许多年轻的Android开发他所会的设计模式是什么，基本上都会提到单例模式，但是对单例模式也是一知半解，在Android开发中我们经常会运用单例模式，所以我们还是要更了解单例模式才对。
定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
单例模式结构图：
单例模式有多种写法各有利弊，现在我们来看看各种模式写法。
1. 饿汉模式
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){
public static Singleton getInstance() {
这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 这种方式基于类加载机制避免了多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。
2. 懒汉模式（线程不安全）
public class Singleton {
private static S
private Singleton (){
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作。
3. 懒汉模式（线程安全）
public class Singleton {
private static S
private Singleton (){
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。
4. 双重检查模式 （DCL）
public class Singleton {
private volatile static S
private Singleton (){
public static Singleton getInstance() {
if (instance== null) {
synchronized (Singleton.class) {
if (instance== null) {
instance= new Singleton();
这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，不了解volatile关键字的可以查看这篇文章，在这篇文章我也提到了双重检查模式是正确使用volatile关键字的场景之一。
在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。
5. 静态内部类单例模式
public class Singleton {
private Singleton(){
public static Singleton getInstance(){
return SingletonHolder.sI
private static class SingletonHolder {
private static final Singleton sInstance = new Singleton();
第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。
6. 枚举单例
public enum Singleton {
public void doSomeThing() {
默认枚举实例的创建是线程安全的，并且在任何情况下都是单例，上述讲的几种单例模式实现中，有一种情况下他们会重新创建对象，那就是反序列化，将一个单例实例对象写到磁盘再读回来，从而获得了一个实例。反序列化操作提供了readResolve方法，这个方法可以让开发人员控制对象的反序列化。在上述的几个方法示例中如果要杜绝单例对象被反序列化是重新生成对象，就必须加入如下方法：
private Object readResolve() throws ObjectStreamException{
枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。
7. 使用容器实现单例模式
public class SingletonManager {
　　private static Map&String, Object& objMap = new HashMap&String,Object&();
　　private Singleton() {
　　public static void registerService(String key, Objectinstance) {
　　　　if (!objMap.containsKey(key) ) {
　　　　　　objMap.put(key, instance) ;
　　public static ObjectgetService(String key) {
　　　　return objMap.get(key) ;
用SingletonManager 将多种的单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
到这里七中写法都介绍完了，至于选择用哪种形式的单例模式，取决于你的项目本身，是否是有复杂的并发环境，还是需要控制单例对象的资源消耗。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1061557次
积分：10576
积分：10576
排名：第1155名
原创：126篇
转载：52篇
评论：586条
Android资深工程师、技术经理6年Android开发经验、1年J2EE经验曾工作于华为北研所、开心网等公司
长期分享原创技术文章，与我一起建立知识体系吧！
(1)(2)(1)(3)(8)(4)(1)(3)(6)(9)(10)(10)(8)(1)(1)(2)(2)(3)(1)(1)(1)(1)(1)(1)(1)(3)(3)(1)(3)(5)(2)(3)(3)(4)(5)(4)(1)(3)(4)(8)(6)(8)(3)(3)(14)(13)C++中的单例模式介绍
字体：[ ] 类型：转载 时间：
单例模式也称为单件模式、单子模式，可能是使用最广泛的设计模式。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享
有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。 单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——也就是说除了一个全局实例外，仍然能创建相同类的本地实例。《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。
单例模式通过类本身来管理其唯一实例，这种特性提供了解决问题的方法。唯一的实例是类的一个普通对象，但设计这个类时，让它只能创建一个实例并提供对此实例的全局访问。唯一实例类Singleton在静态成员函数中隐藏创建实例的操作。习惯上把这个成员函数叫做Instance()，它的返回值是唯一实例的指针。定义如下：
代码如下:class CSingleton{//其他成员public:static CSingleton* GetInstance(){&&&&& if ( m_pInstance == NULL )& //判断是否第一次调用&&&&&&& m_pInstance = new CSingleton();&&&&&&& return m_pI}private:&&& CSingleton(){};&&& static CSingleton * m_pI};
用户访问唯一实例的方法只有GetInstance()成员函数。如果不通过这个函数，任何创建实例的尝试都将失败，因为类的构造函数是私有的。GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。这是一种防弹设计——所有GetInstance()之后的调用都返回相同实例的指针：
CSingleton* p1 = CSingleton :: GetInstance();CSingleton* p2 = p1-&GetInstance();CSingleton & ref = * CSingleton :: GetInstance();
对GetInstance稍加修改，这个设计模板便可以适用于可变多实例情况，如一个类允许最多五个实例。单例类CSingleton有以下特征：
它有一个指向唯一实例的静态指针m_pInstance，并且是私有的；它有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例；它的构造函数是私有的，这样就不能从别处创建该类的实例。大多数时候，这样的实现都不会出现问题。有经验的读者可能会问，m_pInstance指向的空间什么时候释放呢？更严重的问题是，该实例的析构函数什么时候执行？如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面的代码无法实现这个要求。我们需要一种方法，正常的删除该实例。
可以在程序结束时调用GetInstance()，并对返回的指针掉用delete操作。这样做可以实现功能，但不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。一个妥善的方法是让这个类自己知道在合适的时候把自己删除，或者说把删除自己的操作挂在操作系统中的某个合适的点上，使其在恰当的时候被自动执行。我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中的CGarbo类（Garbo意为垃圾工人）： 代码如下:class CSingleton{//其他成员public:static CSingleton* GetInstance();private:&&& CSingleton(){};&&& static CSingleton * m_pIclass CGarbo //它的唯一工作就是在析构函数中删除CSingleton的实例{&&&&&&& public:&&&&&&&&&&& ~CGarbo()&&&&&&&&&&& {&&&&&&&&&&&&&&& if( CSingleton::m_pInstance )&&&&&&&&&&&&&&&&& delete CSingleton::m_pI}&&&&&&&& }&&&&&&& Static CGabor G //定义一个静态成员，程序结束时，系统会自动调用它的析构函数}；
类CGarbo被定义为CSingleton的私有内嵌类，以防该类被在其他地方滥用。程序运行结束时，系统会调用CSingleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。使用这种方法释放单例对象有以下特征：在单例类内部定义专有的嵌套类；在单例类内定义私有的专门用于释放的静态成员；利用程序在结束时析构全局变量的特性，选择最终的释放时机；使用单例的代码不需要任何操作，不必关心对象的释放。
进一步的讨论
但是添加一个类的静态对象，总是让人不太满意，所以有人用如下方法来重现实现单例和解决它相应的问题，代码如下：
代码如下:class CSingleton{&&& //其他成员&&& public:&&&&&&& static Singleton &GetInstance(){&&& static S&&&}&&&&&&& private:&&&&&&&&&&& Singleton() {};};
使用局部静态变量，非常强大的方法，完全实现了单例的特性，而且代码量更少，也不用担心单例销毁的问题。但使用此种方法也会出现问题，当如下方法使用单例时问题来了，
Singleton singleton = Singleton :: GetInstance();
这么做就出现了一个类拷贝的问题，这就违背了单例的特性。产生这个问题原因在于：编译器会为类生成一个默认的构造函数，来支持类的拷贝。最后没有办法，我们要禁止类拷贝和类赋值，禁止程序员用这种方式来使用单例，当时领导的意思是GetInstance()函数返回一个指针而不是返回一个引用，函数的代码改为如下：
代码如下:static Singleton *GetInstance(){static& Sreturn& &}
但我总觉的不好，为什么不让编译器不这么干呢。这时我才想起可以显示的生命类拷贝的构造函数，和重载 = 操作符，新的单例类如下：
代码如下:class Singleton{&&& //其他成员&&& public:&&&&&&& static Singleton &GetInstance(){&&& static S&&&}&&&&&&& private:&&&&&&&&&&& Singleton() {};&&&&&&&&&&& Singleton(const Singleton);&&&&&&&&&&& Singleton & operate = (const Singleton&);};
关于Singleton(const Singleton); 和 Singleton & operate = (const Singleton&); 函数，需要声明成私用的，并且只声明不实现。这样，如果用上面的方式来使用单例时，不管是在友元类中还是其他的，编译器都是报错。不知道这样的单例类是否还会有问题，但在程序中这样子使用已经基本没有问题了。
优化Singleton类，使之适用于单线程应用Singleton使用操作符new为唯一实例分配存储空间。因为new操作符是线程安全的，在多线程应用中你可以使用此设计模板，但是有一个缺陷：就是在应用程序终止之前必须手工用delete摧毁实例。否则，不仅导致内存溢出，还要造成不可预测的行为，因为Singleton的析构函数将根本不会被调用。而通过使用本地静态实例代替动态实例，单线程应用可以很容易避免这个问题。下面是与上面的GetInstance()稍有不同的实现，这个实现专门用于单线程应用：
代码如下:CSingleton* CSingleton :: GetInstance(){&&& static CSingleton inst；&&& return &inst；}
本地静态对象实例inst是第一次调用GetInstance()时被构造，一直保持活动状态直到应用程序终止，指针m_pInstance变得多余并且可以从类定义中删除掉，与动态分配对象不同，静态对象当应用程序终止时被自动销毁掉，所以就不必再手动销毁实例了。
代码如下://版本一#include &iostream&&& && //单例类的C++实现&& class Singleton&& {&& private:&& &&&&&& Singleton();//注意:构造方法私有&& &&&&&& static Singleton*//惟一实例&& &&&&&&//成员变量(用于测试)&& public:&& &&&&&& static Singleton* GetInstance();//工厂方法(用来获得实例)&& &&&&&& int getVar();//获得var的值&& &&&&&& void setVar(int);//设置var的值&& &&&&&& virtual ~Singleton();};&& //构造方法实现&& Singleton::Singleton()&& {&& &&&&&& this-&var = 20;&& &&&&&& cout&&"Singleton Constructor"&&&& }&& Singleton::~Singleton()&& {&& &&&&&& cout&&"Singleton Destructor"&&&&&&&& //&& }&& //初始化静态成员&& /*Singleton* Singleton::instance=NULL;Singleton* Singleton::GetInstance()&& {&& &&&&&& if(NULL==instance)&&&&&&&&&&&&& instance=new Singleton();&&&&&&&& }*/Singleton* Singleton::instance=new SSingleton* Singleton::GetInstance()&& {&& &&&&&&&& }&&&& //seter && getter含数&& int Singleton::getVar()&& {&& &&&&&& return this-&&& }&& void Singleton::setVar(int var)&& {&& &&&&&& this-&var =&& }&& //main&& void main()&& {&& &&&&&& Singleton *ton1 = Singleton::GetInstance();&& &&&&&& Singleton *ton2 = Singleton::GetInstance();&&&&& if(ton1==ton2)&&&&&&&&&&&&& cout&&"ton1==ton2"&&&&&&&& cout&&"ton1 var = "&&ton1-&getVar()&&&&&&&& cout&&"ton2 var = "&&ton2-&getVar()&&&& &&&&&& ton1-&setVar(150);&& &&&&&& cout&&"ton1 var = "&&ton1-&getVar()&&&&&&&& cout&&"ton2 var = "&&ton2-&getVar()&&&&&&&& delete Singleton::GetInstance();//必须显式地删除}&&
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具共有 6260 人关注过本帖
标题：[求助]请问单例模式和工厂模式分别是什么意思(举个例子),区别何在
等　级：新手上路
帖　子：30
&&问题点数：0&&回复次数：6&&&
[求助]请问单例模式和工厂模式分别是什么意思(举个例子),区别何在
搜索更多相关主题的帖子:
等　级：新手上路
帖　子：1583
呵呵，直接看我发的追MM与23种设计模式，看完以后你就明白了，我懒得解释了！
[url]http://bbs.bc-cn.net/thread--1.html[/url]
浮生若梦天边月，醉死如酒水中星。红楼一梦千人叹，岂让万夫空做贱。博客：/rxvip
来　自：聖西羅南看臺
等　级：贵宾
威　望：44
帖　子：4052
专家分：135
只是大致给你介绍一下并举两个简单的例子 如果要深入理解不是几句话能说清楚的
如果楼主学习C#一段时间了 感觉对基本知识都比较熟悉了可以去好好看一下&C#设计模式&
如果基础知识还没掌握好 尤其是对接口以及抽象类还不理解建议楼主先别忙这块 容易把你看晕
单例确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例 比如
public class A
&&& private static const A myclass = new A();
&&& private A()
&&& public static A getInstance()
工厂就比较麻烦了 需要定义接口
public interface A
&&&&&&void a();
&&&&&&void b();
&&&&&&void c();
public class B:A
&&&&&// 实现一系列方法
// 比如还有几个类......
public class AFactory
&&& public static A factory(String name)
&&&&&& if(name == &b&)
&&&&&&&&&&&&return new B();
&&&&&& ..........................
[[italic] 本帖最后由 guoxhvip 于
02:56 编辑 [/italic]]
愛生活 && 愛編程
等　级：新手上路
帖　子：1583
guoxhvip还真勤快也！我现在越来越懒了！
浮生若梦天边月，醉死如酒水中星。红楼一梦千人叹，岂让万夫空做贱。博客：/rxvip
等　级：新手上路
帖　子：938
楼上两位牛人!
msdn == 葵花宝典!!!
等　级：新手上路
帖　子：1583
阿达，那个andy什么什么的不会是你的灌水马甲吧？
浮生若梦天边月，醉死如酒水中星。红楼一梦千人叹，岂让万夫空做贱。博客：/rxvip
等　级：新手上路
帖　子：928
简而言之：单例模式是在一个应用中只能有一个该类的实例存在，所以该类的实例中的信息在整个应用中是共享的。工厂模式是为了可以创建多个相似的类的构造类，比如：
工厂类：自行车工厂
男式自行车类
女式自行车类
可以这样得到山地车类的实例：自行车工厂.getIntance(&山地&);
public class 人生历程 extends Thread{public void run(){while(true){努力，努力，再努力!!;Thread.sleep(0);}}}
版权所有，并保留所有权利。
Powered by , Processed in 0.021633 second(s), 8 queries.
Copyright&, BCCN.NET, All Rights Reserved