如何创建线程安全的单例模式？线程安全的Singleton！

女爷i 2022-07-14 02:46 154阅读 0赞

# 单例模式的概念 #

单例模式就是确保只有一个实例，而且自行实例化并向整个系统传递这个实例，这个类就称作为单例类

单例模式最重要的一个特点就是构造方法私有化。创建单例模式分为懒汉式和饿汉式。

## 第一种：懒汉式（线程不安全的） ##

传统的懒汉式创建单例模式，是线程不安全的

public class Singleton {  
        private static Singleton instance;  
        private Singleton (){}  
      
        public static 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) {  
            instance = new Singleton();  
        }  
        return instance;  
        }  
    }

线程安全的方式创建单例就是在对外的创建实例方法上加上synchronized。   这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

## 第三种：饿汉式（是线程安全的） ##

public class Singleton {  
        private static Singleton instance = new Singleton();  
        private Singleton (){}  
        public static Singleton getInstance() {  
        return instance;  
        }  
    }

这种方式基于 classloder 机制避免了多线程的同步问题，不过， instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，   但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

## 第四种：静态内部类的方式创建单例模式（static inner class） ##

public class Singleton {
    	private Singleton() {
    	}
    	private static class SingletonHolder {// 静态内部类
    		private static Singleton singleton = new Singleton();
    	}
    	public static Singleton getInstance() {
    		return SingletonHolder.singleton;
    	}
    }

这种方式同样利用了 classloder 的机制来保证初始化 instance 时只有一个线程，它跟第三种方式不同的是（很细微的差别）：第三种方式是只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了， instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有显示通过调用 getInstance 方法时，才会显示装载 SingletonHolder 类，从而实例化 singleton 。想象一下，如果实例化singleton 很消耗资源，我想让他延迟加载，另外一方面，我不希望在 Singleton 类加载时就实例化，因为我不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第三种方式就显得很合理。

## 第五种：双重校验锁（dubble check instance） ##

public class Singleton {
    
    	private static Singleton singleton;
    	private Singleton() {
    	}
    	public static Singleton getInstance(){
    		if (singleton == null) {
    			synchronized (Singleton.class) {
    				if (singleton == null) {
    					/**
    					 * 为什么这里会使用双重判定呢？
    					 */
    					singleton = new Singleton();
    				}
    			}
    		}
    		return singleton;
    	}
    }

这种事用双重判断来创建一个单例的方法，那么我们为什么要使用两个if判断这个对象当前是不是空的呢 ？因为当有多个线程同时要创建对象的时候，多个线程有可能都停止在第一个if判断的地方，等待锁的释放，然后多个线程就都创建了对象，这样就不是单例模式了，所以我们要用两个if来进行这个对象是否存在的判断。

可能好多人在想第五种方式创建单例模式的时候如果把synchronized放在第一个if不就好了吗？如果我们把synchronized放在第一个id上面，那么我们第五种方式创建单例就和线程安全的懒汉式创建单例是同一种了！