单例模式全形式

时间 2019-12-08

标签模式形式繁體版

原文原文链接

① 懒汉式：经典写法，线程不安全

public class Singleton {
    private static Singleton instance;    //私有静态自身类属性，因为静态方法只能访问静态成员，所以是静态的
    private Singleton (){}                //私有构造器
 
    public static Singleton getInstance() {  //给外界提供单例类对象的静态函数函数：因为使用第一次从单例类中获取单例对象的时候，没有初始化当前类对象，所以只能经过类调用静态方法的形式
 　　　　if (instance == null) {
    　　　　instance = new Singleton();
  　　　}
  　　　return instance;
    }
}

　　之因此称为懒汉式，是由于当调用静态方法getInstance()的时候才会生成这个单例对象。

②懒汉式：线程安全的

public class Singleton {
    private static Singleton instance;    //私有静态自身类属性，因为静态方法只能访问静态成员，所以是静态的
    private Singleton (){}                //私有构造器
 
    public static synchronized Singleton getInstance() {  //给外界提供单例类对象的静态函数函数：因为使用第一次从单例类中获取单例对象的时候，没有初始化当前类对象，所以只能经过类调用静态方法的形式
      if (instance == null) {
      　　instance = new Singleton();
　　　　}
　　　　return instance;
    }
}

　　能够说这个方式是为了处理懒汉式遇到的线程安全问题而想到的一个最偷懒的改进方式，这个方式确实避免了线程安全的问题，可是同时带来的确实是性能的问题， 同一个函数，在同步操做以后性能多是相差千百倍的。

③双重检查机制

public class Singleton {
    private static Singleton instance;    //私有静态自身类属性，因为静态方法只能访问静态成员，所以是静态的
    private Singleton (){}                //私有构造器
 
    public static synchronized Singleton getInstance() {  //给外界提供单例类对象的静态函数函数：因为使用第一次从单例类中获取单例对象的时候，没有初始化当前类对象，所以只能经过类调用静态方法的形式
        if (instance == null) {                        //Single Checked
             synchronized (Singleton.class) {
                 if (instance == null) {                //Double Checked 第二次检查的缘由：有可能多个线程同时经过了第一个检查，可是遇到了同步操做，其中一个线程获取了操做权，所以必须再一次判断，不然后面的线程会再次建立一个对象
                     instance = new Singleton();
                 }
             }
         }
         return instance ;
    }  
}

这段代码看起来很完美，很惋惜，它是有问题。主要在于instance = new Singleton()这句，这并不是是一个原子操做，事实上在 JVM 中这句话大概作了下面 3 件事情。spring

给 instance 分配内存
调用 Singleton 的构造函数来初始化成员变量
将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

可是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序多是 1-2-3 也多是 1-3-2。若是是后者，则在 3 执行完毕、2 未执行以前，被线程二抢占了，这时 instance 已是非 null 了（但却没有初始化），因此线程二会直接返回 instance，而后使用，而后瓜熟蒂落地报错。安全

咱们只须要将 instance 变量声明成 volatile 就能够了。

public class Singleton {
    private volatile static Singleton instance; //声明成 volatile
    private Singleton (){}

    public static Singleton getSingleton() {
        if (instance == null) {                       
            synchronized (Singleton.class) {
                if (instance == null) {     
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
 
}

　　有些人认为使用 volatile 的缘由是可见性，也就是能够保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但实际上是不对的。使用 volatile 的主要缘由是其另外一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操做后面会有一个内存屏障（生成的汇编代码上），读操做不会被重排序到内存屏障以前。好比上面的例子，取操做必须在执行完 1-2-3 以后或者 1-3-2 以后，不存在执行到 1-3 而后取到值的状况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操做都先行发生于后面对这个变量的读操做（这里的“后面”是时间上的前后顺序）。

可是特别注意在 Java 5 之前的版本使用了 volatile 的双检锁仍是有问题的。其缘由是 Java 5 之前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能彻底避免重排序，主要是 volatile 变量先后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，因此在这以后才能够放心使用 volatile。

因为双重检查机制的复杂性，所以引入了下面的单例模式。

④饿汉式

public class Singleton{
    //类加载时就初始化
    private static final Singleton instance = new Singleton();   //使用final关键字保证instance对象只能初始化一次，其后不变
   
    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

　　这种方式既保证了线程安全，有保证了性能，同时代码也比较简单，可是，仍然存在的问题是： 譬如 Singleton 实例的建立是依赖参数或者配置文件的，在 getInstance() 以前必须调用某个方法设置参数给它，那样这种单例写法就没法使用了。

⑤静态内部类形式

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

　　这种写法仍然使用JVM自己机制保证了线程安全问题；因为 SingletonHolder 是私有的，除了 getInstance() 以外没有办法访问它，所以它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。

⑥枚举类形式：

public enum EasySingleton{
    INSTANCE;   //默认是使用public static final修饰
}

以上是使用枚举类型完成的单例模式，简单易用， 咱们能够经过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了，建立枚举默认就是线程安全的，下面介绍一下枚举类型：

class Season{
    //1.提供类的属性，声明为private final
    private final String seasonName;
    private final String seasonDesc;
    //2.声明为final的属性，在构造器中初始化。
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //3.经过公共的方法来调用属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.建立枚举类的对象:将类的对象声明public static final
    public static final Season SPRING = new Season("spring", "春暖花开");    //若是只有一个对象，那么这个类就是一种单例模式的实现，和相似饿汉式，使用静态本类属性，一加载当前类就初始化，不一样的是经过类名获取单一实例
    public static final Season SUMMER = new Season("summer", "夏日炎炎");
    public static final Season AUTUMN = new Season("autumn", "秋高气爽");
    public static final Season WINTER = new Season("winter", "白雪皑皑");
    @Override
    public String toString() {
        return "Season [seasonName=" + seasonName + ", seasonDesc="
                + seasonDesc + "]";
    }
    public void show(){
        System.out.println("这是一个季节");
    }
}

经过以上代码可使用Season.SPRING的形式获取当前类对象，若是仅仅在内部定义的了一个SPRING对象，那么这就是一种单例模式的实现。

总结：

懒汉式、饿汉式、双重检查式都具有①一个静态的获取当前类对象的方法；②私有的构造函数；③一个私有的静态自身类属性

内部类式：一样具有上述上个条件，区别在于使用了一个静态内部类，将外部类做为内部类的私有静态属性初始化，外部类的静态方法仅仅是获取经过静态内部类获取外部类对象传递。

枚举类型：事实上没有使用enum关键字以前，枚举类型事实上是一种饿汉式的体现，与之不一样的是枚举类型的自身类属性是public的，没有经过一个静态方法传递出去。