【Java】单例模式的6种实现方式

单例模式

1、懒汉式

1.1 懒汉式，线程不安全

当有多个线程并行调用 getInstance() 的时候，就会创建多个实例。也就是说在多线程下不能正常工作。

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static Singleton getInstance() {
     if (instance == null) {
         instance = new Singleton();
     }
     return instance;
    }
}

1.2 懒汉式，线程安全

为了解决上面的问题，最简单的方法是将整个 getInstance() 方法设为同步（synchronized）。虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。因为在任何时候只能有一个线程调用 getInstance() 方法。但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。这就引出了双重检验锁。

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

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

2、饿汉式

public class Singleton{
    //类加载时就初始化
    private static final Singleton instance = new Singleton();
    
    private Singleton(){}

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

3、双重检验锁

双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。

class Singleton{
	//第二层锁，volatile关键字禁止指令重排
    private static volatile Singleton singleton;
    private Singleton(){}
    
    public static Singleton getInstance(){
    	//第一层检查，检查是否有引用指向对象，高并发情况下会有多个线程同时进入
        if(singleton==null){
        	//第一层锁，保证只有一个线程进入
            synchronized (Singleton.class){
                //双重检查，防止多个线程同时进入第一层检查(因单例模式只允许存在一个对象，故在创建对象之前无引用指向对象，所有线程均可进入第一层检查)
                //当某一线程获得锁创建一个Singleton对象时,即已有引用指向对象，singleton不为空，从而保证只会创建一个对象
                //假设没有第二层检查，那么第一个线程创建完对象释放锁后，后面进入对象也会创建对象，会产生多个对象
                
                //第二层检查
                if(singleton==null){
                    //volatile关键字作用为禁止指令重排，保证返回Singleton对象一定在创建对象后
                    singleton=new Singleton();
                    //singleton=new Singleton语句为非原子性，实际上会执行以下内容：
                    //(1)在堆上开辟空间；(2)属性初始化;(3)引用指向对象
                    //假设以上三个内容为三条单独指令，因指令重排可能会导致执行顺序为1->3->2(正常为1->2->3),当单例模式中存在普通变量需要在构造方法中进行初始化操作时，单线程情况下，顺序重排没有影响；但在多线程情况下，假如线程1执行singleton=new Singleton()语句时先1再3，由于系统调度线程2的原因没来得及执行步骤2，但此时已有引用指向对象也就是singleton!=null，故线程2在第一次检查时不满足条件直接返回singleton，此时singleton为null(即str值为null)
                    //volatile关键字可保证singleton=new Singleton()语句执行顺序为123，因其为非原子性依旧可能存在系统调度问题(即执行步骤时被打断)，但能确保的是只要singleton!=0，就表明一定执行了属性初始化操作；而若在步骤3之前被打断，此时singleton依旧为null，其他线程可进入第一层检查向下执行创建对象
                }
            }
        }
        return singleton;
    }
}
public class ThreadTest{
    public static void main(String[] args) {
        Singleton singleton=Singleton.getInstance();
        System.out.println(singleton);
    }
}

4、静态内部类

由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。

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

5、枚举

创建枚举默认就是线程安全的，所以不需要担心double checked locking，而且还能防止反序列化导致重新创建新的对象。

public enum EasySingleton{
    INSTANCE;
    public void anyMethod(){
        
    }
}

6、IODH

IoDH实现的单例模式

饿汉式单例类不能实现延迟加载，不管将来用不用始终占据内存；懒汉式单例类线程安全控制烦琐，而且性能受影响。可见，无论是饿汉式单例还是懒汉式单例都存在这样那样的问题，有没有一种方法，能够将两种单例的缺点都克服，而将两者的优点合二为一呢？答案是：Yes！下面我们来学习这种更好的被称之为 Initialization Demand Holder (IoDH) 的技术。
在IoDH中，我们在单例类中增加一个静态(static)内部类，在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用，实现代码如下所示：

public class Singleton {
    // 私有构造函数，防止外部实例化
    private Singleton() { }

    // 静态内部类，在这个静态类中初始化单例对象
    private static class SingletonHolder {
        // 静态变量INSTANCE将在第一次调用getInstance()时进行初始化
        private static final Singleton INSTANCE = new Singleton();
    }

    // 获取单例对象的方法
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

示例：

//Initialization on Demand Holder
class Singleton {
	private Singleton() {
	}
	
	private static class HolderClass {
            private final static Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance() {
	    return HolderClass.instance;
	}
	
	public static void main(String args[]) {
	    Singleton s1, s2; 
            s1 = Singleton.getInstance();
	    s2 = Singleton.getInstance();
	    System.out.println(s1==s2);
	}
}

编译并运行上述代码，运行结果为：true，即创建的单例对象s1和s2为同一对象。由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

通过使用IoDH，我们既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现方式（其缺点是与编程语言本身的特性相关，很多面向对象语言不支持IoDH）。

项目中的实际使用：
使用IODH单例模式创建线程池

//采用单例模式的IoDH封装线程池的工具类
public class ThreadPoolUtil {
    //线程池对象
    public ThreadPoolExecutor poolExecutor;
    //构造函数私有化
    private ThreadPoolUtil(){
        //完成线程池对象的实例化
        poolExecutor=new ThreadPoolExecutor(4,10,3, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(20), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
    }
    //静态内部类 完成对象的实例化 
    private static class PoolInner{
        private final static ThreadPoolUtil pool=new ThreadPoolUtil();
    }
    //获取唯一实例
    public static ThreadPoolUtil getInstance(){
        return PoolInner.pool;
    }
}