实用设计模式之单例模式

1.什么是单例模式

        单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并提供全局访问点。

 2.单例的使用

        教科书中的示例是很简单的，要想实现一个单例类，只需要三点：

• 定义私有的静态成员
• 私有化构造方法
• 提供公有的静态工厂方法

        典型的代码是：

[java]  view plain copy

1. public class Singleton {  
2.       
3.     private static Singleton instance;  
4.       
5.     private Singleton(){}  
6.       
7.     public static Singleton getInstance(){  
8.         if (instance==null){  
9.             instance=new Singleton();  
10.         }  
11.         return instance;  
12.     }  
13. }  

        但常常我们还要面对更复杂的现实问题。

2.1.全部使用静态成员

        有时我们会看到一个Singleton的成员变量全部是static类型的，这种情况下，建议直接删除构造方法和静态工厂方法，直接作为一个工具类就好了。因为这个类已经不需要对象了，何必多此一举呢？

2.2.对构造方法不进行私有化处理

        构造方法不进行私有化，就意味着client可以自由的通过new Singleton()构造新的实例，这已经有违了采用单例模式的本意，不如把静态工厂方法删掉吧，放弃单例的需求。如果有理由让一个类既可以是单例，也可以是多例，我想应该仔细设计了。

2.3.静态工厂方法需要参数

        我们时常会看到这样的构造方法：

        public static Singleton getInstance(Context context)

        如果一个实例的构造需要参数，那么就意味着传递不同的参数将影响到单例的状态。比如我们看这样一段代码。

[java]  view plain copy

1. public class Singleton {  
2.       
3.     private static Singleton instance;  
4.       
5.     private Object value;  
6.       
7.     private Singleton(Object value){  
8.         this.value=value;  
9.     }  
10.       
11.     public static Singleton getInstance(Object value){  
12.         if (instance==null){  
13.             instance=new Singleton(value);  
14.         }  
15.         return instance;  
16.     }  
17.       
18.     public void fun(){  
19.         //value.doSomething();  
20.     }  
21. }  

        在程序中的某处调用时使用了Singleton.getInstance(objA).fun();另一处使用了Singleton.getInstance(objB).fun();显然，同样一个Singleton实例，在运行时出现了未预期的行为。这与设计单例时我们期望的可控性是不符的，你无法预知在下一次使用value时真正的行为。

2.4.派生子类

        如果需要在继承树中使用单例，只要将基类的构造函数由private调整为protected即可，但问题会很多，这个有很多文章来讨论了，在此略过。

        简而言之，如果在基类中实现静态工厂方法，必然会与子类产生依赖，即发生父类依赖于子类的非正常情况。如果在子类中实现静态工厂方法，则整个设计就出现了父类无法约束子类的创建情况，也就是说可能出现违背设计意图的实现。建议对单例类不要再派生。

2.5.多线程问题

        既然在软件运行期内只有一个实例，由于无法限制client的调用时机，就不可避免要处理互斥问题。

        先来看静态工厂方法的互斥处理，典型的代码是：

[java]  view plain copy

1. public static Singleton getInstance(){  
2.     if (instance==null){  
3.         synchronized (Singleton.class) {  
4.             if (instance==null){  
5.                 instance=new Singleton();  
6.             }  
7.         }  
8.     }  
9.     return instance;  
10. }  

        这段代码既完成了在构造这个唯一实例时的保护，又在构造完以后的多次获取实例时不做无谓的互斥处理以提高运行效率，是目前比较推荐的实现方法。

        再来看类的其他成员的互斥问题，这个就与其他class是一样的了，需要小心的处理多线程访问的影响。

2.6.内存回收

        单例的内存问题也是值得关注的，一量单例创建以后，静态变量instance就会持有一份内存引用，而且由于其static性质，这份内存将在程序运行期间持续占用，无法通过GC进行回收。所以对内存敏感的程序要减少对单例的使用，或者妥善处理内存回收问题。

3.小结

        总之，虽然单例看上去很美，但还是有这么多需要认真思考、妥善决策的技术要点，用好单例并不像我们在教科书中看到的那样简单。