图解设计模式之单例模式

常见的单例模式创建方式

饿汉式1：

/**饿汉式
 * @author lhb
 * @date 2022/10/26 19:00
 */

public class SmallChangeSys {
    
    //1.构造器私有化 外部不能new
    private SmallChangeSys (){}
    
    //2. 本类内部创建一个实例对象
    private static final SmallChangeSys smallchangeSys = new SmallChangeSys();
    
    //3. 给外部提供一个静态方法来访问对象
    public static SmallChangeSys getInstance(){
        return smallchangeSys;
    }
    
}
class Singlton{
    public static void main(String[] args){
        SmallChangeSys instance = SmallChangeSys.getInstance();
    }
}

 饿汉式2：

/**饿汉式 静态代码块中实现创建
 * @author lhb
 * @date 2022/10/26 19:00
 */

public class SmallChangeSys {

    //1.构造器私有化
    private SmallChangeSys (){}

    //2. 本类内部创建一个对象
    private static  SmallChangeSys smallchangeSys;
    
    //3.静态代码块中去实现
    static{
        smallchangeSys = new SmallChangeSys();
    }

    //4. 给外部提供一个静态方法来访问对象
    public static SmallChangeSys getInstance(){
        return smallchangeSys;
    }

}
class Singlton{
    public static void main(String[] args){
        SmallChangeSys.getInstance();
    }
}

懒汉式（会有线程安全问题）：

/**懒汉式  线程不安全(在方法上加入syschronized关键字)
 * @author lhb
 * @date 2022/10/27 10:21
 */

public class LazySinglton {

    //构造器私有化
    private LazySinglton(){}

    //声明一个私有对象
    private static LazySinglton lazySinglton;
    
    public static  LazySinglton getInstance(){
        //调用方法时才创建对象 存在线程安全问题
        
        if(lazySinglton == null){
            lazySinglton = new LazySinglton();
        }
        
        return lazySinglton;
    }
}

class Main{
    public static void main(String[] args){
        LazySinglton instance = LazySinglton.getInstance();
        
        
    }
}

双重检查

/**双重检查 解决了线程安全 和实现了懒加载
 * @author lhb
 * @date 2022/10/27 10:57
 */

public class Singlton1 {
    
    private Singlton1(){}
    
    //volatile解决双重检查的指令重排 线程间的可见性
    private static volatile Singlton1 singlton1;
    
    public static Singlton1 getInstance(){
        if(singlton1 == null){
            synchronized (Singlton.class){
                if(singlton1 == null){
                    singlton1 = new Singlton1();
                }
            }
            
        } 
        return singlton1;
    }
    
}

枚举类

/**通过枚举实现单例
 * @author lhb
 * @date 2022/10/27 11:20
 */
enum  Singlton5 {
    SPRING;
    private Singlton5(){}
}

静态内部类实现单例

/**静态内部类实现单例
 * @author lhb
 * @date 2022/10/27 11:20
 */
public class Singlton5{
    
    private Singlton5(){}
    
    private static Singlton5 singlton5;
    
    //静态内部类
    private static class SingletonInstance{
        private static final Singlton5 SINGLTON_5 = new Singlton5(); 
    }
    //
    public static Singlton5 getInstance(){
        
        return SingletonInstance.SINGLTON_5;
        
    }
}

推荐使用 枚举 静态内部类 饿汉式 双重检查