你还不了解JAVA设计模式之单例模式吗？

你是那一夜知道的我
但我不是从那一夜活过来的

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式为一个面向对象的应用程序提供了对象唯一的访问点，不管它实现何种功能，整个应用程序都会同享一个实例对象。

上面的概念有点抽象，简单来说，所谓单例，就是整个程序有且仅有一个实例。该类负责创建自己的对象，同时确保只有一个对象被创建。

需要注意的是：

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。

懒汉式单例

当程序第一次访问单例模式实例时才进行创建。类似于延迟加载。

基本的代码如下：

public class Singleton1 {
	
    private static Singleton1 singleton;
    private Singleton1() {
    }
    
    public static Singleton1 getInstance() {
    	if(singleton==null) 
    	{
    	  singleton=new Singleton1();
    	}
    	return singleton;
    }
}

当程序需要获取该类的实例化对象的时候，调用getInstance方法，如果该类对象还没有实例化，则进行实例化，如果该类对象已经被实例化，则直接返回。

但明眼人一眼就可以看出来，这个代码存在严重的线程安全问题。没有处理线程安全问题显然是没办法使用的。

因此

懒汉式单例正确的实现方式

• 方法上加锁

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

这种模式的缺点是方法加锁太重了，生产环境会面临严重的效率问题。

• 双端检锁机制

public class Singleton {
    private Singleton() {}
    
    private static volatile Singleton singleton;
    
    public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
    }
}

对代码块加锁相对比较轻量。并且使用双端检锁机制，在保证线程安全的同时，可以尽最大化提升效率。

假设有两个线程同时到达synchronized语句块，那么实例化代码只会由其中先抢到锁的线程执行一次，而后抢到锁的线程会在第二个if判断中发现singleton不为null，所以跳过创建实例的语句。再后面的其他线程再来调用getInstance方法时，只需判断第一次的if(singleton==null)，然后会跳过整个if块，直接return实例化后的对象。

在双重检查锁模式中，给singleton这个对象加了volatile关键字，那为什么要用volatile呢？主要就在于singleton=newSingleton()，它并非是一个原子操作。

• 静态内部类

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

采用了静态内部类实例singleton对象，静态内部类相当于一个静态属性，只有在第一次加载类时才会初始化，在类初始化时，别的线程是无法进入的，因此既实现了线程安全，又避免了同步带来的性能影响。

饿汉式单例

顾名思义，该模式在类被加载时就会实例化一个对象。

该模式能简单快速的创建一个单例对象，而且是线程安全的(只在类加载时才会初始化，以后都不会)。但它有一个缺点，就是不管你要不要都会直接创建一个对象，会消耗一定的性能(当然很小很小，几乎可以忽略不计，所以这种模式在很多场合十分常用而且十分简单)

//饿汉式单例类。在类初始化时，已经自行实例化 
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

文章持续更新，可以微信搜索「 绅堂Style 」第一时间阅读，回复【资料】有我准备的面试题笔记。
GitHub https://github.com/dtt11111/Nodes 有总结面试完整考点、资料以及我的系列文章。欢迎Star。