阅读 1875

设计模式之单例模式

前言

作为一个好学习的程序开发者,应该会去学习优秀的开源框架,当然学习的过程中不免会去阅读源码,这也是一个优秀程序员的必备素养,在学习的过程中很多人会遇到的障碍,那就是设计模式。很多优秀的框架会运用设计模式来达到事半功倍的效果。鉴于自己之前对设计模式的生疏,在阅读源码时遇到设计模式的巧妙运用理解比较吃力。最近搞了一本新书 《图解设计模式》(目测讲的很基础)开始学习设计模式,对今后学习源码打下坚实的基础。后续我在阅读本书的过程中,我将记录下自己学习总结。今天就从最常使用的单例模式说起。

单例模式

在许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。(维基百科)。

懒汉式

在单例模式中,有一种称为懒汉式的单例模式。顾名思义,懒汉式可以理解使用时才进行初始化,它包括私有的构造方法,私有的全局静态变量,公有的静态方法,是一种懒加载机制。

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        System.out.println("初始化");
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}复制代码

上面是最常见的懒汉式单例模式的写法,但是如果在多线程的情况下,上述方法就会出现问题,它达不到只有一个单例对象的效果,例如当某个线程1调用getInstance()方法并判断instance == null
,此时(就在判断为空后new Singleton()之前)另一个线程2也调用getInstance()方法,由于此时线程1还没有new出对象,则线程2执行getInstance()中instance 也为空,那么此时就会出现多个实例的情况,而达不到只有一个实例的目的。

懒汉式(线程安全)

在上述实现中我们提到的懒汉式单例模式是一种非线程安全的,非线程安全即多线程访问时会生成多个实例。那么怎么样实现线程安全呢,也许你应该已经想到使用同步关键字synchronized。

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        System.out.println("初始化");
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}复制代码

使用同步关键字后,也就实现了线程安全访问,因为在任何时候它只能有一个线程调用 getInstance() 方法。那么你可能会发出疑问,这样加入同步,在高并发情况下,效率是很低的,因为真正需要同步的是我们第一次初始化的时候,是的,所以我们要进行进一步的优化。

双重检测机制

双重检测顾名思义就是两次检测,一次是检测instance 实例是否为空,进行第一次过滤,在同步快中进行第二次检测,因为当多个线程执行第一次检测通过后会同时进入同步快,那么此时就有必要进行第二次检测来避免生成多个实例。

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        System.out.println("初始化");
    }

    public static Singleton getInstance() {
        if(instance==null){
            synchronized (Singleton.class) {
                if (instance == null) { 
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}复制代码

对于上面的代码时近乎完美的,既然说近乎完美,那肯定还是有瑕疵的,瑕疵出现的原因就是instance = new Singleton();这一句代码,你可能会问,这会有什么问题,其实我也不知道,哈哈。在计算机语言中,初始化包含了三个步骤

  1. 分配内存
  2. 执行构造方法初始化
  3. 将对象指向分配的内存空间

由于java编译器为了尽可能减少内存操作速度远慢于CPU运行速度所带来的CPU空置的影响,虚拟机会按照自己的一些规则(这规则后面再叙述)将程序编写顺序打乱——即写在后面的代码在时间顺序上可能会先执行,而写在前面的代码会后执行——以尽可能充分地利用CPU就会出现指令重排序(happen-before),从而导致上面的三个步骤执行顺序发生改变。正常情况下是123,但是如果指令重排后执行为1,3,2那么久会导致instance 为空,进而导致程序出现问题。

既然已经知道了上述双重检测机制会出现问题,那么我们该怎么避免出现呢,该如何解决呢,最好的办法就是不要使用,开个玩笑啦。java中有一个关键字volatile,他有一个作用就是防止指令重排序,那么我们把singleton用volatile修饰下就可以了,如下。

private volatile static Singleton singleton;复制代码

饿汉式

饿汉式与懒汉式区别是它在类加载的时候就进行初始化操作,而懒汉式是调用getInstance()方法时才进行初始化。

public class Singleton{
    private static final Singleton instance = new Singleton();

    private Singleton() {
        System.out.println("初始化");
    }

    public static Singleton getInstance(){
        return instance;
    }
}复制代码

与懒汉式相比,它是线程安全的(无需用同步关键字修饰),由于没有加锁,执行效率也相对较高,但是也有一些缺点,在类加载时就初始化,会浪费内存。

静态内部类实现方式

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
        System.out.println("初始化");
    }

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}复制代码

静态内部类相对实现较为简单,并且它是一种懒加载机制, 当Singleton 类被装载了,instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用,只有显示通过调用 getInstance 方法时,才会显示装载 SingletonHolder 类,从而实例化 instance。

好了,关于单例模式到这里已经介绍完毕了。有问题欢迎留言指出,Have a wonderful day .