java 单例模式

1. 单例模式

（1）概念

单例模式的定义是：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

（2）类图、代码

单例模式的类图设计如下：

单例模式中的主动实例化（加载类时实例化单例类）[推荐使用]：

//主动实例化的单例模式--饿汉式单例
public class Singleton {
    // 自行实例化一个对象 private static final Singleton singleton = new Singleton(); // 私有构造函数，只允许自行实例化对象 private Singleton() { } // 公开唯一对象的调用方法，供外部调用 public static Singleton getInstance() { return singleton; } }

外部通过代码Singleton singleton = Singleton.getInstance();来调用这个实例。

该方法的优点是：能保证线程安全（适用于单、多线程）。

该方法的缺点是：在加载类时实例化导致该static对象一直保存在内存中，无论是否使用都占着内存空间。（饿汉式”的由来：不管你用的用不上，一开始就建立这个单例对象）

单例模式中的被动实例化（调用方法时实例化单例类）：

//被动实例化的单例模式--懒汉式单例
public class Singleton {
    // 声明但不实例化 private static Singleton singleton = null; // 私有构造函数，只允许自行实例化对象 private Singleton() { } // 公开唯一对象的调用方法，供外部调用 public static Singleton getInstance() { // 仅在第一次调用时候实例化对象，其他时候直接返回已有实例 if (singleton == null) { singleton = new Singleton(); } return singleton; } }

外部调用实例的方法与上述相同：Singleton singleton = Singleton.getInstance();

该方法的优点是：只有在第一次调用getInstance()方法时才会创建单一实例，节省了内存空间，不会出现创建对象后一直不使用的情况。（“懒汉式”的由来：在你真正用到的时候才去建这个单例对象）

该方法的缺点是：不能保证线程安全（多线程中）。

比如，有线程1和线程2两个线程，两者都调用getInstance()方法。如果线程1刚刚进入if还没执行new语句时，轮到线程2的时间片导致线程2也进入if语句中（多线程实际上不是同时执行了），就会创建2个实例。

解决该问题的方法是在getInstance()方法前面加上synchronized关键字，使其在运行过程中上同步锁（即如果有一个线程在访问这个方法，那么另外一个线程就不能访问它），改进后的代码如下：

//被动实例化的单例模式--懒汉式单例
public class Singleton {
    // 声明但不实例化 private static Singleton singleton = null; // 私有构造函数，只允许自行实例化对象 private Singleton() { } // 公开唯一对象的调用方法，供外部调用 // synchronized对该方法上同步锁 public synchronized static Singleton getInstance() { // 仅在第一次调用时候实例化对象，其他时候直接返回已有实例 if (singleton == null) { singleton = new Singleton(); } return singleton; } }

然而这种解决方法仍然有缺点：每次调用getInstance()方法获取这个单例都要先获取进程锁，而实际上只有第一次调用该方法创建实例时才需要进程锁，导致它的使用成本过高。

完美解决方法应该是：在对实例的n次调用过程中，仅需要锁定第一次。即应该避免对整个方法进行同步，而仅对关键代码进行同步即可。

按照这样的想法修改getInstance()方法（存在问题）：

    // 公开唯一对象的调用方法，供外部调用
    public static Singleton getInstance() {
        // 仅在第一次调用时候实例化对象，其他时候直接返回已有实例 if (singleton == null) { // synchronized仅对创建实例的关键代码上进程锁 synchronized (Singleton.class) { singleton = new Singleton(); } } return singleton; }

上述代码虽然解决了刚才的问题，却又回到最开始的问题了：线程安全不能保证。

比如，有线程1和线程2两个线程，两者都调用getInstance()方法。如果线程1和线程2都进入if语句，由于同步锁的存在，线程1先创建实例，然后线程2又会创建实例。

为解决这个问题，应该在同步之后再次进行检测实例是否已创建。使用双重检查加锁，最终改进后的代码如下：

//被动实例化的单例模式--懒汉式单例
public class Singleton {
    // 声明但不实例化 private static Singleton singleton = null; // 私有构造函数，只允许自行实例化对象 private Singleton() { } // 公开唯一对象的调用方法，供外部调用 public static Singleton getInstance() { // 仅在第一次调用时候实例化对象，其他时候直接返回已有实例 if (singleton == null) { // synchronized仅对创建实例的关键代码上进程锁 synchronized (Singleton.class) { // 再次检查实例是否存在，主要针对多线程 if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }

（3）优缺点、适用场景

单例模式的优点：

　　单例模式只有一个实例，减少了内存的开支，减少了系统的性能开销（注意JVM回收机制）；

　　避免了对资源的多重占用；

　　在系统中设置对全局的访问点，优化了共享了资源访问。

单例模式的缺点：

　　单例模式一般没有接口，扩展很难（基本只有修改代码的方法）；

　　创建单例模式的子类非常困难（除非基类单例类没有实例化）；

　　单例模式对测试不利（在并行开发环境中单例模式没有完成是不能进行测试的）；

　　与单一职责原则有一定冲突（单例模式把“进行单例”和业务逻辑（其他方法）融合在一个类中）；

单例模式的适用场景：

　　操作系统只需要一个时钟；

　　要求生成唯一序列号；

　　整个项目中需要一个不变的共享访问点或共享数据；

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

（4）扩展

一个类可以只有一个对象，也可以有多个对象（无限个）。如果一个类要有有限个对象，比如3个：

public class SingletonExtend {
    // 定义最多能产生的实例的数量
    private static final int maxNum = 3; // 定义一个列表来容纳所有实例 private static List<SingletonExtend> singletonList = new ArrayList<SingletonExtend>(); // 产生3个实例 static { for (int i = 0; i < maxNum; i++) { singletonList.add(new SingletonExtend()); } } private SingletonExtend() { } public static SingletonExtend getInstance() { // 这里随机返回3个实例 Random rand = new Random(); return singletonList.get(rand.nextInt(3)); } }

 

 

6大设计原则，与常见设计模式（概述）：http://www.cnblogs.com/LangZXG/p/6204142.html

类图基础知识：http://www.cnblogs.com/LangZXG/p/6208716.html

 

转载于   http://www.cnblogs.com/LangZXG/p/6248835.html

转载于:https://www.cnblogs.com/yuanchao120/p/8384072.html