在多线程环境中的单例模式

在多线程环境中的单例模式

目前有三种实现单例模式的方式:

  1. 饿汉模式
  2. 懒汉模式
  3. 静态内部类

1、饿汉模式

class Singleton{
    // 第一步 构造器私有化
    private Singleton(){}
    // 第二步 自行对外提供实例
    private static final Singleton singleton = new singleton();
    // 第三步 提供外界可以获取实例的方法
    public static Singleton getInstance(){
        return singleton;
    }
}

在多线程的情况下,饿汉模式的性能是非常好的,因为获取实例的方法只是简单的返回实例,并没有任何的锁操作,因此在并行的程序中会有良好的表现。

但是这种方式有这明显的不足,就是实例在什么时候创建是不受控制的,对于静态成员singleton,它会在类第一次初始化的时候被创建。这个时刻并不一定是getInstance()第一次被调用的时候。

当类初始化的时候,实例就会被创建。如果希望精确控制singleton的创建时间,可以采用支持延迟加载策略的方法。这种方法只会在第一次调用getInstance()方法的时候才会创建对象。

2. 懒汉模式

class Singleton{
    // 第一步 构造器私有化
    private Singleton(){}
    // 第二步 创建实例的引用
    private static final Singleton singleton = null;
    // 第三步 提供外界可以获取实例的方法,此时需要判断一下引用的状态。
    public static Singleton getInstance(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

懒汉模式的实现思想如下:最初,我们并不需要实例化singleton,而当getInstance()方法第一次被调用的时候,创建单例对象。

但是这个模式有一个特别明显的问题,就是没有考虑多线程下的安全问题,在多线程并发的情况下,会并发调用获取实例方法,从而导致系统同时创建多个单例类实例,显然不符合要求。可以通过给getInstance()方法加锁才行。

class Singleton{
    // 第一步 构造器私有化
    private Singleton(){}
    // 第二步 创建实例的引用
    private static final Singleton singleton = null;
    // 第三步 提供外界可以获取实例的方法,此时需要判断一下引用的状态。
    public static synchronized Singleton getInstance(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

添加synchronized锁虽然可以保证线程安全,但是锁的范围过大,单例类是系统唯一的,在创建出来实例后,后续再加锁就只会造成性能的浪费。需要对代码进行优化,所以又有了双重校验锁的模式。

class Singleton{
    // 第一步 构造器私有化
    private Singleton(){}
    // 第二步 创建实例的引用
    private static final Singleton singleton = null;
    // 第三步 提供外界可以获取实例的方法,此时需要判断一下引用的状态。
    public static synchronized Singleton getInstance(){
        // 第一次校验
        if(singleton==null){
        	synchronized(Singleton.class){
                // 第二次校验
                if(singleton==null){
            		singleton = new Singleton();
                }
        	}
    	}
    	return singleton;
    }
    
}

singleton = new Singleton();并不是原子操作,所以双重校验锁会出现指令重排序问题。可能导致在实例还没又初始化完成之前,就被其他线程使用的问题,可以使用volatile关键字来修饰singleton字段,可以禁止指令的重排序优化。

class Singleton{
    // 第一步 构造器私有化
    private Singleton(){}
    // 第二步 创建实例的引用
    private static volatile Singleton singleton = null;
    // 第三步 提供外界可以获取实例的方法,此时需要判断一下引用的状态。
    public static synchronized Singleton getInstance(){
        // 第一次校验
        if(singleton==null){
        	synchronized(Singleton.class){
                // 第二次校验
                if(singleton==null){
            		singleton = new Singleton();
                }
        	}
    	}
    	return singleton;
    }
    
}

3. 静态内部类

class Singleton{
    // 第一步 构造器私有化
    private Singleton(){}
    //第二步 创建静态内部类
    private static class help{
        private static Singleton singleton = new Singleton();
    }
    // 第三步 提供外界可以获取实例的方法
    public static Singleton getInstance(){
        return help.singleton;
    }
}

可见,双重检查模式是一种丑陋,复杂的方法,而在静态内部类实现方式却可以完美拥有前两种方式的优点,首先getInstance()方法中没有锁,这使得在高并发环境下性能优越。其次,只有在getInstance()才会创建实例,因为这种方法巧妙的使用了内部类和类的初始化方式,私有化内部类,使得我们不可能在外部访问并初始化它。而我们只能在getInstance()内部才能对内部类初始化,利用虚拟机的类初始化机制来创建单例。

在多线程环境中的单例模式

上一篇:STL


下一篇:Leetcode—977. 有序数组的平方