单例是Java中最简单也是最常用的设计模式之一，在JVM的启动到停止期间，单例只允许类存在一个实例，这个类的实例是由类自己创建并提供给其他类访问，单例的三个特点：
jvm中始终只有一个实例
由类自己创建
为其他类提供唯一实例
单例有多种写法，以下列举最常用的几种写法。
懒汉式
懒汉式单例声明一个静态的instance = null的对象，因此类在初始化时，类并不会马上实例化，外部对象要调用该类的实例，只能通过getInstance方法，在第一次调用时进行实例化，起到延迟加载的作用。getInstance方法加了同步锁保证线程安全，但在并发时会造成性能瓶颈
public class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton(){
}
//使用内置同步锁，线程安全，但在并发下会造成性能问题
public synchronized static LazySingleton getInstance(){
if(null == instance){
instance = new LazySingleton();
}
return instance;
}
}
饿汉式
饿汉式单例与懒汉式的区别在于：
类初始化时就进行实例化；
getInstance没有加锁;
没有延迟加载，也就意味着即使没有其他类调用，这个实例也一直存在，浪费内存资源，正因为初始化时就实例化，因此不存在线程安全问题，无需在getInstance上加同步锁；
public class EagerSingleton {
private static EagerSingleton instance = new EagerSingleton();
private EagerSingleton(){
}
//直接返回已经类加载时已经实例化的对象，不存在线程安全问题
public static EagerSingleton getInstance(){
return instance;
}
}
静态内部类式
这种方式利用了 classloader 机制来保证初始化 instance 时只有一个线程，即使外部类被加载了，instance 还是未初始化，因为 SingletonHolder 类没有被显式调用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被显示调用从而被加载，那么这个时候用这种写法既可以实现延迟加载，又能保证线程安全性。
public class InnerSingleton {
//静态内部类在单例类初始化时不会初始化
private static class SingletonHolder{
private static InnerSingleton instance = new InnerSingleton();
}
//调用getInstance方法时，才去加载内部类，懒加载的同时也节约空间，同时也是线程安全的
public static InnerSingleton getInstance(){
return SingletonHolder.instance;
}
}
双重校验式
双重校验在没有加volatile修饰符时是线程不安全的，多个线程之间彼此看到不到最新的变量值。volatile保证线程之间内存可见性。这种写法虽然用了同步锁，但只有第一次加载时会加锁，因此不存在性能问题。
public class DoubleCheckSingleton {
//volatile修饰对象，保证线程间内存可见性的问题
private static volatile DoubleCheckSingleton instance = null;
private DoubleCheckSingleton(){}
public static DoubleCheckSingleton getInstance() {
// 1、A\B线程同时到达
if (null == instance) {
synchronized (DoubleCheckSingleton.class) {
//2、A线程获得锁，进入方法块，B线程等待
//4、A线程退出后，B线程进入、发现instance已经实例化，立即退出
if (null == instance) {
// 3、A线程完成实例化，释放锁
instance = new DoubleCheckSingleton();
}
}
}
return instance;
}
}
枚举式单例
枚举式单例可以说是最简洁、最高效的单例模式，用最少的代码既保证实例唯一，又保证线程安全；缺点只有：它无法被继承，也没有实现任何接口，因此无法被动态代理
public enum EnumSingleton {
INSTANCE;
public static void method(){
}
}
ThreadLocal式
很多时候，我们都在考虑线程间变量共享，而ThreadLocal刚好相反，它为每个线程提供一份独立的副本，隔离线程之间对同一变量访问的冲突，互不影响。
public class ThreadLocalSingleton {
//ThreadLocal为每个线程提供了副本，互不影响
private static ThreadLocal<ThreadLocalSingleton> TL_SINGLETON = new ThreadLocal(){
@Override
protected Object initialValue() {
return new ThreadLocalSingleton();
}
};
private ThreadLocalSingleton(){
}
public static ThreadLocalSingleton getInstance(){
return TL_SINGLETON.get();
}
}
CAS式
要获得唯一的实例，可以用利用AtomicReference的原子性，利用jvm的CAS来实现
public class CasSingleton {
private static AtomicReference<CasSingleton> reference = new AtomicReference<>();
private CasSingleton(){}
public static CasSingleton getInstance(){
for(;;){
//自旋，直到唯一实例被创建
CasSingleton instance = reference.get();
if(instance == null){
instance = new CasSingleton();
if(reference.compareAndSet(null,instance)){
return instance;
}
}else{
return instance;
}
}
}
}
感谢您阅读我的文章，如果满意可以帮我点歌赞，谢谢哈。
如果对文章部分还有什么见解或者疑惑，可以私信评论我，欢迎技术讨论。如果需要获取完整的文件资源，可以加我微信z985085305，获取我整理的全套笔记。
思想的碰撞最能促进技术的进步哦。
