单例模式

定义：单例模式（Singleton Pattern）：Ensure a class has only one instance, and provide a global point of access to it. 

（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例）

一、例子

        如 一个朝代只能有一个皇帝：所以我们要求一个类只能生成一个对象（皇帝），那么如何只让一个类只产生一个对象呢？

        我们知道使用new关键字创建对象时，会根据输入的参数调用相应的构造函数，如果我们将构造函数设置为private私有访问权限不就可以禁止外部创建对象了吗？

我们这样设计两个类：Emperor代表皇帝类，Minister代表臣子类，代码如下：

[java]  view plain copy

1. public class Emperor  
2. {  
3.     private static final Emperor emperor = new Emperor();  
4.     //初始化一个皇帝  
5.     private Emperor(){}  
6.     public static Emperor getInstance(){  
7.         return emperor;  
8.     }  
9.     //皇帝发话  
10.     public static void say(){  
11.         System.out.printIn("我是秦始皇.....");  
12.     }  
13. }  

        通过定义一个私有访问权限的构造函数，避免其他类new出来一个对象，而Emperor自己则可以new一个对象出来，其他类对该类的访问都可以通过getInstance获得同一个对象。

臣子类如下：

[java]  view plain copy

1. public class Minister  
2. {  
3.     public static void mian(String[] args){  
4.         for(int day=0; day<3; day++){  
5.             Emperor emperor = Emperor.getInstance();  
6.             emperor.say();  
7.         }  
8.     }  
9. }  

输出结果：

[java]  view plain copy

1. 我是秦始皇.....  
2. 我是秦始皇.....  
3. 我是秦始皇.....  

         这就是单例模式

                            通用类图

        Singleton类称为单例类，通过使用private的构造函数确保了在一个应用中只产生一个实例，并且是自行实例化的（在Singleton中自己使用new Singleton()）。

二、单例模式通用代码：

[java]  view plain copy

1. public class Singleton  
2. {  
3.     private static final Singleton singleton = new Singleton();  
4.     //限制产生多个对象  
5.     private Singleton(){}  
6.     //通过该方法获得实例对象  
7.     public static Singleton getSingleton(){  
8.         return singleton;  
9.     }  
10.     //类中的其他方法，尽量static  
11.     public static void doSomething(){}  
12. }  

三、单例模式优点：

        ● 由于单例模式在内存中只有一个实例，减少了内存开支

        ● 由于单例模式只生成一个实例，所以减少了系统的性能开销

            如：当一个对象的产生需要比较多个的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用中启动时直接产生一个到单例对象，然后用永久驻留内存的方式来解决

        ● 单例模式可以避免对资源的多重占用

        ● 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

四、单例模式缺点：

        ● 单例模式一般没有借口，扩展很困难

            因为借口对单例模式是没有任何意义的，它要求“自行实例化”，并且提供单一实例，而借口或抽象类是不可能被实例化的（特殊情况除外）

        ● 单例模式对测试是不利的

        ● 单例模式与单一职责原则有冲突

            一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中

五、单例模式使用场景：

        ● 要求生成唯一序列号的环境

        ● 在整个项目中需要一个共享访问点或共享数据

            如：一个Web页面上的计数器，可以不用每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的

        ● 创建一个对象需要消耗的资源过多

            如：要访问IO和数据库等资源

        ● 需要定义大量的静态常量和静态方法的场景（当然，可以直接声明为static的方式）

            如：工具类

六、单例模式的注意事项：

        高并发情况下，注意单例模式的线程同步问题。

[java]  view plain copy

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

        上述代码中低并发情况下不会出现问题，如果系统压力增大，并发量增加时则可能在内存中存在多个实例了，为何呢？

        如一个线程A执行到 singleton = new Singleton() ,但是还没有获得对象，第二个线程B也在执行，并且执行到了if(singleton == null) 的判断，那么此时B获得的判断条件也是真，于是继续运行下去，线程A获得了一个对象，线程B也获得了一个对象，内存中存在了两个对象！！

         解决：解决线程不安全的方法很多，可以在getSingleton方法前加synchronized关键字，也可以在getSingleton方法内增加synchronized来实现，但都不是最优秀的单例模式。

                 建议使用上文中出现的：单例模式通用代码 这个方式，该方式成为饿汉式单例

                其次，需要考虑对象复制情况。在Java中对象默认不可复制，若实现了Cloneable接口，并实现了clone方法，则可以直接通过对象复制方法创建一个新对象，对象复制是不用调用类的构造函数的，所以即使是私有的构造函数，对象仍然可以被复制。

                解决该问题的最好方法就是单例类不要事先Cloneable接口！