单例模式

一、单例模式

1.介绍：

作用：

​ 保证一个类只有一个实例，并且只提供一个访问该实例的全局访问点。

常见场景：

• Spring中的每个bean

• 数据库连接池

• web应用中的servlet

  。。。

优点：

• 单例模式只生成一个实例，减少系统开销，提高性能
• 方便共享资源访问

常见五种单例模式实现方式：

1. 饿汉式-----------------线程安全、调用效率高、不能延迟加载
2. 懒汉式------------------线程安全、调用效率不高、可以延迟加载
3. DCL懒汉式--------------------由于jvm底层内部模型原因，不建议使用
4. 饿汉式改进-----------------线程安全、调用效率高、可以延迟加载
5. 枚举单例-------------------线程安全、调用效率高、不能延迟加载

2.五种单例模式代码

1）饿汉式

/**
 *饿汉式-----------------线程安全、调用效率高、不能延迟加载
 */
public class Singleton_01 {
    // 1.类初始化创建实例
    private static Singleton_01 instance = new Singleton_01();
    // 2.私有构造器
    private Singleton_01 () {
    }
    // 3.提供获取该对象的访问方法
    public static Singleton_01 getInstance(){
        return instance;
    }
}
class Test {
    public static void main(String[] args) {
        Singleton_01 instance1 = Singleton_01.getInstance();
        Singleton_01 instance2 = Singleton_01.getInstance();
        System.out.println(instance1 == instance2);
    }
}

存在的问题: 无论该类是否被调用，都会去开辟空间，容易浪费资源

2） 懒汉式

/**
 * 懒汉式
 */
public class Singleton_02 {
    // 1.类初始化时候，不立即加载改对象
    private static Singleton_02 instance;
    // 2.私有构造器
    private Singleton_02(){
    }
    // 3.提供获取该对象的访问方法 ,synchronized效率低
    public static synchronized Singleton_02 getInstance(){
        if(instance == null){
            instance = new Singleton_02();
        }
        return instance;
    }
    
}
class Test02 {
    public static void main(String[] args) {
        Singleton_01 instance1 = Singleton_01.getInstance();
        Singleton_01 instance2 = Singleton_01.getInstance();
        System.out.println(instance1 == instance2);
    }
}

存在问题：高并发情况下，效率低下

3）DCL懒汉式

/**
 * DCL懒汉式
 */
public class Singleton_03 {

    // 1.类初始化时候，不立即加载改对象
    private static Singleton_03 instance;
    // 2.私有构造器
    private Singleton_03(){
    }
    // 3.提供获取该对象的访问方法 
    public static  Singleton_03 getInstance(){
        if(instance == null){
            synchronized (Singleton_03.class){
                instance = new Singleton_03();
            }
        }
        return instance;
    }
}

class Test03 {
    public static void main(String[] args) {
        Singleton_01 instance1 = Singleton_01.getInstance();
        Singleton_01 instance2 = Singleton_01.getInstance();
        System.out.println(instance1 == instance2);
    }
}

存在问题：可能会出现这个种情况，当第一个用户进行获取实例时候，会进行实例创建，在实例还未创建完成时，紧接着第二个用户也来获取实例，这时用户2发现实例已经不为null,就直接return，事实上用户2得到的实例可能是不完整的。

4）懒汉式改进

/**
 * 懒汉式改进
 */
public class Singleton_04 {
    // 1.私有构造器
    private Singleton_04 () {
    }
    // 2.内部静态类进行创建对象
    private static class InitClass{
        private static final  Singleton_04 instance = new Singleton_04();

    }
    // 3.提供获取该对象的访问方法
    public static  Singleton_04 getInstance(){
        return InitClass.instance;
    }
}

class Test04 {
    public static void main(String[] args) {
        Singleton_04 instance1 = Singleton_04.getInstance();
        Singleton_04 instance2 = Singleton_04.getInstance();
        System.out.println(instance1 == instance2);
        
        // 反射机制，破坏单例
        Constructor<Singleton_04> declaredConstructor = Singleton_04.class.getDeclaredConstructor(null);
        // 破坏访问权限
        declaredConstructor.setAccessible(true);
        Singleton_04 instance3 = declaredConstructor.newInstance();
        System.out.println(instance1==instance3);
    }
}

存在问题：反射机制，任然可以破坏改单例对象。

5）枚举单例

public enum Singleton_05 {
    INSTRANCE;

    public static Singleton_05 getInstance(){
        return Singleton_05.INSTRANCE;
    }
}
class Test05 {
    public static void main(String[] args) {
        Singleton_05 instance = Singleton_05.getInstance();
        Singleton_05 instance2 = Singleton_05.getInstance();
        System.out.println(instance == instance2);
    }
}