单例设计模式

一、定义：

单例模式（ Singleton Pattern） 是一个比较简单的模式， 其定义如下：

Ensure a class has only one instance, and provide a global point of access to it.

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

单例模式的通用类图

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

单例模式通用代码

/**饿汉式单例*/public class Singleton {    private static final Singleton singleton = new Singleton();    //限制产生多个对象    private Singleton(){    }    //通过该方法获得实例对象    public static Singleton getSingleton(){    return singleton;    }       //类中其他方法， 尽量是static    public static void doSomething(){    }}

二、单例模式的应用

1.单例模式的优点

• 由于单例模式在内存中只有一个实例， 减少了内存开支， 特别是一个对象需要频繁地 
  创建、 销毁时， 而且创建或销毁时性能又无法优化， 单例模式的优势就非常明显
• 由于单例模式只生成一个实例， 所以减少了系统的性能开销， 当一个对象的产生需要 
  比较多的资源时， 如读取配置、 产生其他依赖对象时， 则可以通过在应用启动时直接产生一 
  个单例对象， 然后用永久驻留内存的方式来解决（ 在Java EE中采用单例模式时需要注意JVM 
  垃圾回收机制） 。
• 单例模式可以避免对资源的多重占用， 例如一个写文件动作， 由于只有一个实例存在 
  内存中， 避免对同一个资源文件的同时写操作。
• 单例模式可以在系统设置全局的访问点， 优化和共享资源访问， 例如可以设计一个单 
  例类， 负责所有数据表的映射处理。

2.单例模式的缺点

• 单例模式一般没有接口， 扩展很困难， 若要扩展， 除了修改代码基本上没有第二种途 
  径可以实现。 单例模式为什么不能增加接口呢？ 因为接口对单例模式是没有任何意义的， 它 
  要求“自行实例化”， 并且提供单一实例、 接口或抽象类是不可能被实例化的。 当然， 在特殊 
  情况下， 单例模式可以实现接口、 被继承等， 需要在系统开发中根据环境判断。

• 单例模式对测试是不利的。 在并行开发环境中， 如果单例模式没有完成， 是不能进行 
  测试的， 没有接口也不能使用mock的方式虚拟一个对象

• 单例模式与单一职责原则有冲突。 一个类应该只实现一个逻辑， 而不关心它是否是单 
  例的， 是不是要单例取决于环境， 单例模式把“要单例”和业务逻辑融合在一个类中。

3.单例模式的使用场景

在一个系统中， 要求一个类有且仅有一个对象， 如果出现多个对象就会出现“不良反 
应”， 可以采用单例模式， 具体的场景如下：

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

• ● 在整个项目中需要一个共享访问点或共享数据， 例如一个Web页面上的计数器， 可以 
  不用把每次刷新都记录到数据库中， 使用单例模式保持计数器的值， 并确保是线程安全的；

• ● 创建一个对象需要消耗的资源过多， 如要访问IO和数据库等资源；

• ● 需要定义大量的静态常量和静态方法（ 如工具类） 的环境， 可以采用单例模式（ 当 
  然， 也可以直接声明为static的方式）

4.单例模式的注意事项

• 首先， 在高并发情况下， 请注意单例模式的线程同步问题。 单例模式有几种不同的实现 
  方式， 上面的例子不会出现产生多个实例的情况， 但是如代码清单7-4所示的单例模式就需 
  要考虑线程同步。

  代码清单7-4 线程不安全的单例public class Singleton {     private static Singleton singleton = null;        //限制产生多个对象     private Singleton(){      }        //通过该方法获得实例对象     public static Singleton getSingleton(){         if(singleton == null){         singleton = new Singleton();         }        return singleton;    }}

• 该单例模式在低并发的情况下尚不会出现问题， 若系统压力增大， 并发量增加时则可能 
  在内存中出现多个实例， 破坏了最初的预期。

• 为什么会出现这种情况呢？ 如一个线程A执行到singleton = new Singleton()， 但还没有获得对象（ 对象初始化是需要时间的）, 第二个线程B也在执行， 执行到（ singleton == null） 判断， 那么线程B获得判断条件也是为真， 于是继续运行下去， 线程A获得了一个对象， 线程B也获得了一个对象， 在内存中就出现两个对象！

• 解决线程不安全的方法很有多， 可以在getSingleton方法前加synchronized关键字， 也可以 
  在getSingleton方法内增加synchronized来实现， 但都不是最优秀的单例模式， 建议读者使用如 
  代码清单7-3所示的方式（ 有的书上把代码清单7-3中的单例称为饿汉式单例， 在代码清单7-4 
  中增加了synchronized的单例称为懒汉式单例） 。

• 其次， 需要考虑对象的复制情况。 在Java中， 对象默认是不可以被复制的， 若实现了 
  Cloneable接口， 并实现了clone方法， 则可以直接通过对象复制方式创建一个新对象， 对象 
  复制是不用调用类的构造函数， 因此即使是私有的构造函数， 对象仍然可以被复制。 在一般 
  情况下， 类复制的情况不需要考虑， 很少会出现一个单例类会主动要求被复制的情况， 解决 
  该问题的最好方法就是单例类不要实现Cloneable接口。

三、单例模式的扩展

---

如果一个类可以产生多个对象， 对象的数量不受限制， 则是非常容易实现的， 直接使用 
new关键字就可以了， 如果只需要一个对象， 使用单例模式就可以了， 但是如果要求一个类 
只能产生两三个对象呢？ 该怎么实现？ 我们还以皇帝为例来说明。

• 一般情况下， 一个朝代的同一个时代只有一个皇帝， 那有没有出现两个皇帝的情况呢？

• 图7-3 多个皇帝类图 
  这个类图看起来还算简单， 但是实现就有点复杂了。 
  

  代码清单7-5 固定数量的皇帝类public class Emperor { //定义最多能产生的实例数量     private static int maxNumOfEmperor = 2;    //每个皇帝都有名字， 使用一个ArrayList来容纳， 每个对象的私有属性     private static ArrayList<String> nameList=new ArrayList<String>();     //定义一个列表， 容纳所有的皇帝实例     private static ArrayList<Emperor> emperorList=new ArrayList<Emperor>();     //当前皇帝序列号     private static int countNumOfEmperor =0;        //产生所有的对象    static{         for(int i=0;i<maxNumOfEmperor;i++){         emperorList.add(new Emperor("皇"+(i+1)+"帝"));        }    }    private Emperor(){    //世俗和道德约束你， 目的就是不产生第二个皇帝    }    //传入皇帝名称， 建立一个皇帝对象    private Emperor(String name){        nameList.add(name);    }    //随机获得一个皇帝对象    public static Emperor getInstance(){         Random random = new Random();        //随机拉出一个皇帝， 只要是个精神领袖就成        countNumOfEmperor = random.nextInt(maxNumOfEmperor);        return emperorList.get(countNumOfEmperor);    }        //皇帝发话了    public static void say(){        System.out.println(nameList.get(countNumOfEmperor));    }}

在Emperor中使用了两个ArrayList分别存储实例和实例变量。 当然， 如果考虑到线程安 
全问题可以使用Vector来代替。 臣子参拜皇帝的过程如代码清单7-6所示。

        代码清单7-6 臣子参拜皇帝的过程        public class Minister {            public static void main(String[] args) {            //定义5个大臣            int ministerNum =5;            for(int i=0;i<ministerNum;i++){                Emperor emperor = Emperor.getInstance();                System.out.print("第"+(i+1)+"个大臣参拜的是： ");                emperor.say();                }            }        }

• 大臣参拜皇帝的结果如下所示。

• 第1个大臣参拜的是： 皇1帝

• 第2个大臣参拜的是： 皇2帝
• 第3个大臣参拜的是： 皇1帝
• 第4个大臣参拜的是： 皇1帝
• 第5个大臣参拜的是： 皇2帝

看， 果然每个大臣参拜的皇帝都可能不一样， 大臣们就开始糊涂了， A大臣给皇1帝汇 
报了一件事情， 皇2帝不知道， 然后就开始怀疑大臣A是皇1帝的亲信， 然后就想办法开始 
整……

• 这种需要产生固定数量对象的模式就叫做有上限的多例模式， 它是单例模式的一种扩 
  展， 采用有上限的多例模式， 我们可以在设计时决定在内存中有多少个实例， 方便系统进行 
  扩展， 修正单例可能存在的性能问题， 提供系统的响应速度。 例如读取文件， 我们可以在系 
  统启动时完成初始化工作， 在内存中启动固定数量的reader实例， 然后在需要读取文件时就 
  可以快速响应。

四、最佳实践

单例模式是23个模式中比较简单的模式， 应用也非常广泛， 如在spring中， 每个Bean默 
认就是单例的， 这样做的优点是Spring容器可以管理这些Bean的生命期， 决定什么时候创建 
出来， 什么时候销毁， 销毁的时候要如何处理， 等等。 如果采用非单例模式（ Prototype类 
型） ， 则Bean初始化后的管理交由J2EE容器， Spring容器不再跟踪管理Bean的生命周期。

五、简而图之

 

=========================================

转载地址：http://blog.csdn.net/sunpeng19960715/article/details/52029251