java单例模式

2017-09-13 21:20 出处:segmentfault 人气: 评论(0

写此文初衷源于昨晚线上代码抛出的一个空指针异常。单例是一个类,我们希望该类的对象在任意高并发多线程的调用下,只被初始化一次(例如用于系统环境和词典的加载等),后续线程均直接调用即可。我们首先来讲解几种常见的单例模式和其优缺点吧。

1.懒汉式

// 懒汉式,线程不安全
class SingletonDemo {
    
    // 定义一个私有的静态全局变量来保存该类的唯一实例
    private static SingletonDemo instance;
    
    private SingletonDemo() {
    
    }
    
    public static SingletonDemo getInstance() {
        // 这里可以保证只实例化一次
        if (instance == null) {  //语句(1)
            instance = new SingletonDemo();
        }
        return instance;
    }
}

以上代码很明显不能满足我们的要求。设想有n个线程同时执行语句(1),此时实例还未被初始化,因此均判断为null,于是这n个线程每一个都新建了该类对象。

2.懒汉式改进

// 懒汉式,线程安全,但不高效,因为任何时候只能有一个线程调用getInstance()方法。
class SingletonDemo2 {
    
    private static SingletonDemo2 instance;
    
    private SingletonDemo2() {}
    
    public static synchronized SingletonDemo2 getInstance() { //语句(1)
        if (instance == null) { //区域(1)
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

我们使用synchronized来强制使每个线程串行执行语句(1),因此永远只有第一个线程新建了该类对象。那么这段代码缺点在哪呢?速度慢。假设现在有1000个线程,均在语句(1)处排队,当第一个线程创建新对象后,剩下999个线程仍然需要排队,进入区域(1)判断不为空并返回。

这里懒汉式的意思是:要用的时候才去new。区别于接下来要讲的:

3.饿汉式

/**
 * 饿汉式,单例的实例被声明成static和final,在第一次加载到内存中时会初始化。
 * 
 * 缺点:
 * 不是一种懒加载(lazy initlalization),在一些场景中无法使用:
 * 譬如Singleton实例的创建时以来参数或者配置文件的,在getInstance()之前必须调用
 */
class SingletonDemo5 {
    // 类加载时就初始化
    private static final SingletonDemo5 instance = new SingletonDemo5();
    
    private SingletonDemo5() {}
    
    public static SingletonDemo5 getInstance() {
        return instance;
    }
}

这段代码利用了jvm对private static final只初始化一次的特性,可以解决多线程问题,但是当我们要在getInstance()前做一些配置工作(例如初始化数据库连接等),那么这种方式就捉襟见肘了。

4.双重检验锁

// 双重检验锁(double checked) 
class SingletonDemo3 {
    
    private static volatile SingletonDemo3 instance;
    
    private SingletonDemo3() {}
    
    public static SingletonDemo3 getInstance() {
        if (instance == null) {    // 区域(1)
            synchronized (SingletonDemo3.class) {  // 区域(2)
                if (instance == null) {
                    instance = new SingletonDemo3(); // 语句(1)
                }
            }
        }
        return instance;
    }
}

双重检验锁(double checked)。注意到它有2次判断,一次在同步块内,一次在同步块外。假设现在有4个线程T1,T2,T3,T4。T1,T2进入了区域(1),T3,T4还没启动。T1能进入区域(2)创建instance成功,之后T2进入区域(2),判断非空并出来。此时T3,T4启动了,不会进入区域(1),且无需等待锁。

instance变量声明成volatile, 它可以禁止指令重排序优化。
volatile的两个作用:

  • 禁止指令重排优化。
  • 所修饰的变量一旦被修改,其他线程立即可见。(但是非原子操作,即其他线程可以感知到变量被修改,但无法使用val += 1这种语句使其原子增加。)因此可用于1读者n写者的场景,例如点击"游戏退出按钮",其他(金币累加/音效)线程将立即感知到。

更多单例模式可以看这里

5.异常问题回放

昨晚报出异常的代码片段如下:

class WrongSample {
    
    private volatile static WrongSample instance;
    
    private WrongSample() {

    }
    
    public static WrongSample getInstance() {
        if (instance == null) {    // 区域(1)
            synchronized (WrongSample.class) {  // 区域(2)
                if (instance == null) {
                    instance = new WrongSample(); // 语句(1)
                    instance.init(); //语句(2)
                }
            }
        }
        return instance;
    }

    private void init() {
    
    }
}

该代码使用双重检验锁构建了一个单例,且对单例进行初始化。那么空指针异常抛出对原因在哪呢?设想现在有线程T1,T2。线程T1进入区域(2),T2此时还未启动。T1执行了语句(1),但并未执行语句2,此时instance已经不是null,所以T2启动时在区域(1)判断非null将直接返回instance,但T2并未被初始化,由是产生异常。

解决方案:初始化操作放进构造函数,执行语句(1)时里暗含里执行构造函数。代码如下:

class WrongSample {
    
    private volatile static WrongSample instance;
    
    private WrongSample() {
        init();
    }
    
    public static WrongSample getInstance() {
        if (instance == null) {    // 区域(1)
            synchronized (WrongSample.class) {  // 区域(2)
                if (instance == null) {
                    instance = new WrongSample(); // 语句(1)
                }
            }
        }
        return instance;
    }

    private void init() {
    
    }
}
本文标签: java

相关文章

Copyright © 2002-2017 JISHUX. 技术栈 版权所有

京ICP备15061484号-3