单例模式的几种写法

一、单例模式概述

单例模式定义很简单：一个类中能创建一个实例，所以称之为单例。
那我们为什么要使用单例模式呢？

那既然一个类中只能创建一个实例，那么可以说这是跟类的状态与对象无关的了。
频繁创建对象、管理对象是一件耗费资源的事，我们只需要创建一个对象来用就足够了。

如果你学过J2EE，你可能知道：

Servlet是单例
Struts2是多例
SpringMVC是单例的

Struts2为啥设计成多例呢？

这主要是由于设计层面上的问题，Struts2是基于Filter拦截类的，ognl引擎对变量是注入的，所以它要设计成多例

二、单例模式示例

编写单例模式的代码其实很简单，分为三步：

将构造函数私有化
在类的内部创建示例
提供获取唯一实例的方法

2.1 饿汉式

根据上面的步骤，我们就可以创建单例模式了。

public class Java2y {

    // 1.将构造函数私有化，不可以通过new的方式来创建对象
    private Java2y(){}
    
    // 2.在类的内部创建实例
    private static Java2y y = new Java2y();
    
    // 3.提供获取唯一实例的方法
    public static Java2y getInstance(){
        return y;
    }
}

这种代码我们称之为“饿汉式”：

一上来就创建了对象，如果该实例从始至终都没被使用过，则会造成内存浪费。

2.2 简单饿汉式

既然一上来就创建对象会造成内存浪费，那我们设计成用到的时候再创建对象

public class Java2y {

    // 1.将构造函数私有化，不可以通过new的方式来创建对象
    private Java2y(){}
    
    // 2.1先不创建对象，等用到的时候再创建
    private static Java2y y = null;
    
    // 2.2调用这个方法，创建对象
    public static Java2y getInstance(){
        // 3.如果对象为null，就创建并返回
        if(y == null){
            y = new Java2y();
        }
        return y;
    }
}

上面的代码不行吗？在单线程环境下是可行的，如果在多线程环境下就有问题了，解决方法也很简单，加锁就行。

public class Java2y {

    // 1.将构造函数私有化，不可以通过new的方式来创建对象
    private Java2y(){}
    
    // 2.1先不创建对象，等用到的时候再创建
    private static Java2y y = null;
    
    // 2.2调用这个方法，创建对象
    public static synchronized Java2y getInstance(){
        // 3.如果对象为null，就创建并返回
        if(y == null){
            y = new Java2y();
        }
        return y;
    }
}

2.3 双重检测机制（DCL）懒汉式

上面那种直接在方法上加锁的方式其实不够好，因为在方法上加了内置锁，在多线程环境下性能会比较低，所以我们可以将锁的范围缩小。

public class Java2y {
    
    private Java2y(){}
    
    private static Java2y y = null;
    
    private static Java2y getInstance(){
        if(y == null){
            // 将锁的范围缩小，提高性能 
            synchronized(Java2y.class){
                y = new Java2y();
            }
        }
        return y;
    }
}

这样写以后可行了吗？不行，因为虽然加了锁，但还是有可能创建出两个对象出来：

线程1和线程2同时调用getInstance()方法，它们同时判断y==null，因为结果都为null，所以进入了if代码块。
此时线程1得到CPU的控制权-->进入同步代码块-->创建对象-->返回对象
线程1完成后，线程2得到了CPU控制权，一样是进入同步代码块-->创建对象-->返回对象
然后很明显，最终返回了不止一个对象

然后有人又想到了：进入同步代码块时再判断一下对象是否存在就行了吧，于是有了下面的代码：

public class Java2y {
    
    private Java2y(){}
    
    private static Java2y y = null;
    
    private static Java2y getInstance(){
        if(y == null){
            // 将锁的范围缩小，提高性能 
            synchronized(Java2y.class){
                if(y == null){
                    y = new Java2y();
                }
            }
        }
        return y;
    }
}

然后这种方式又出现了重排序的问题！！！怎么解决呢？加上volatile关键字吧，volatile有内存屏障的功能！

所以说完整的DCL代码是这样子的：

public class Java2y {
    
    private Java2y(){}
    
    private static volatile Java2y y = null;
    
    private static Java2y getInstance(){
        // 这个判空是为了提高性能
        if(y == null){
            // 将锁的范围缩小，提高性能 
            synchronized(Java2y.class){
                if(y == null){
                    y = new Java2y();
                }
            }
        }
        return y;
    }
}

2.4 静态内部类懒汉式

它的原理是这样的：

当任何一个线程第一次调用getInstance()时，都会使SingletonHolder被加载和被初始化，此时静态初始化器将执行Singleton的初始化操作。（被调用时才进行初始化！）
初始化静态数据时，Java提供了的线程安全性保证。（所以不需要任何的同步）

public class Java2y {
    
    private Java2y (){}
    
    // 使用私有静态内部类实现懒加载
    private static class LazyHolder {
        private static final Java2y INSTANCE = new Java2y();
    }
    
    public static Java2y getInstance(){
        return LazyHolder.INSTANCE;
    }
}

这种方式非常推荐使用！！！

2.5 枚举方式

public enum Java2y {
    JAVA_2_y,
}

这种实现：

简单
防止多次实例化，即使是在复杂序列化或者反射攻击时也很安全