单例模式浅析

Posted byron_nj

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了单例模式浅析相关的知识,希望对你有一定的参考价值。

  单例模式 

  单例模式是一种比较常见的模式,看起来很简单,但是要做到高效安全的使用,其中还是有很多要点的。参考了Head First及众多网友的文章,稍微总结一下,以备查看。

  单例模式的定义:确保一个类只有一个实例,并且提供一个全局访问点。

1. 最简单的单例(饿汉模式),程序一加载就对 instance 变量进行初始化,好处是简单明了,缺点:如果初始化的耗费的资源特别多,而之后这个类可能未被使用到,就会造成浪费。

public class Singleton{
    // 单例类静态引用
    private static Singleton instance = new Singleton();  
    // 私有构造方法
    private Singleton(){}  
    // 静态方法:全局访问点
    public static Singleton getInstance(){  
        return instance;  
    }  
}  

 

2. 延迟加载(懒汉模式),作为改进,我们可以在使用到的时候才去创建单例类。

public class LazySingleton {

    private static LazySingleton instance = null;

    private LazySingleton() {}

    public static LazySingleton getInstance() {
        // 使用的时候去检测是否已经初始化
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

  这种方式实现的单例是线程非安全的,假设有线程 A 和 B,同时去获取 LazySingleton 实例,当 A 线程进入 getInstance(),执行到 if (instance == null) 时,此时判断结果为真;之后切换到线程 B 执行,此时也执行到 if (instance == null) ,此时判断结果为真,会对 instance 变量进行初始化;此时切换回线程 A ,根据之前的判断结果,也会对 instance 变量进行初始化,此时就会得到两个不一样的实例,单例失败。

  为了实现线程安全,只要在 getInstance() 方法上添加 synchronized 关键字即可。

 

3. 双重校验锁

  加上 synchronized 关键字,实现了线程安全,但又带来了性能问题。通过同步方法会让性能大幅下降。

  通过代码我们可以看到,instance 变量在整个程序执行期间只会初始化一次,如果只为了这一次初始化,每次获取单例对象都必须在synchronized这里进行排队,实在太损耗性能。为此我们可以如下改进:① instance 变量只会初始化一次,把 synchronized 关键字加载此处;② 为了避免每次获取单例对象都在同步代码上等待,可以在同步代码块外层再加一次 instance == null 判断。

public class DoubleCheckSingleton {

    private static DoubleCheckSingleton instance = null;

    private DoubleCheckSingleton() {}

    public static DoubleCheckSingleton getInstance() {
        // 两层校验才能确保单例
        if (instance == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

 

4. volatile 关键字

   Java中的指令重排优化是指在不改变原语义(即保证运行结果不变)的情况下,通过调整指令的执行顺序让程序运行的更快。JVM中并没有规定编译器优化相关的内容,也就是说JVM可以自由的进行指令重排序的优化。这种优化在单线程中是没有任何问题的,但是在多线程中就会出现问题。

  创建一个变量需要2个步骤:一个是申请一块内存,调用构造方法进行初始化操作;另一个是分配一个指针指向这块内存。这两个操作谁在前谁在后呢?JVM规范并没有规定。那么就存在这么一种情况,JVM是先开辟出一块内存,然后把指针指向这块内存,最后调用构造方法进行初始化。假设线程A开始创建 SingletonClass 的实例,此时线程 B 调用了 getInstance() 方法,首先判断 instance 是否为 null。按照我们上面所说的内存模型,A 已经把 instance 指向了那块内存,只是还没有调用构造方法,因此 B 检测到 instance 不为 null,于是直接把 instance 返回了——问题出现了,尽管instance不为null,但它并没有构造完成,就像一套房子已经给了你钥匙,但你并不能住进去,因为里面还没有收拾。此时,如果B在A将instance构造完成之前就是用了这个实例,程序就会出现错误了!

  在 JDK1.5 及之后版本赋予了volatile关键字明确用法。volatile的一个语义是禁止指令重排序优化,也就保证了instance变量被赋值的时候对象已经是初始化过的,从而避免了上面说到的问题。所以只需要在 instance 变量前加上 volatile 修饰符即可避免Java指令优化带来的问题

public class DoubleCheckSingleton {

    private static volatile DoubleCheckSingleton instance = null;

    private DoubleCheckSingleton() {}

    public static DoubleCheckSingleton getInstance() {
        // 两层校验才能确保单例
        if (instance == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

注:volatile 关键字用法

  ① 可见性。可见性指的是在一个线程中对该变量的修改会马上由工作内存(Work Memory)写回主内存(Main Memory),所以会马上反应在其它线程的读取操作中(工作内存是线程独享的,主存是线程共享的)

  ② 禁止指令重排序优化。

 

5. 静态内部类

  上述 volatile 关键字收到 JDK 版本限制,如下的静态内部类实现方式是确保了延迟加载和线程安全的。

public class StaticInnerSingleton {

    private static class Holder {
        private static StaticInnerSingleton instance = new StaticInnerSingleton();
    }

    private StaticInnerSingleton() {
    }

    public static StaticInnerSingleton getSingleton() {
        return Holder.instance;
    }
}

  可以把 StaticInnerSingleton 实例放到一个静态内部类中,这样就避免了静态实例在 StaticInnerSingleton 类加载的时候就创建对象,并且由于静态内部类只会被加载一次,而类的构造必须是原子性的,非并发的,所以这种写法也是线程安全的

  在上述代码中,因为 StaticInnerSingleton 没有 static 修饰的属性,因此并不会被初始化。直到调用 getInstance() 的时候,会首先加载 Holder

类,这个类有一个 static 的 StaticInnerSingleton 实例,因此需要调用 StaticInnerSingleton 的构造方法,然后 getInstance() 将把这个内部类的instance 返回给使用者。由于这个 instance 是 static 的,因此并不会构造多次。 

 

6. 枚举式单例

public enum EnumSingleton {

    INSTANCE;
    
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public String getSomething() {
        return "String";
    }
}

  使用枚举除了线程安全和防止反射调用构造器之外,还提供了自动序列化机制,防止反序列化的时候创建新的对象。因此,《Effective Java》书中推荐使用的方法。

 

参考: 深入Java单例模式  http://devbean.blog.51cto.com/448512/203501/

    你真的会写单例模式吗--Java实现 http://www.importnew.com/18872.html 

    感谢二位作者文章,本文仅作整理学习,侵删!   

以上是关于单例模式浅析的主要内容,如果未能解决你的问题,请参考以下文章

浅析设计模式——创建型模式之Singleton(单例模式)

浅析java单例模式

C#浅析单例模式

DCL单例模式浅析

单例模式与线程安全问题浅析

设计模式之单例模式