【设计模式 - 单例模式】

目录

一、什么是单例模式？

二、单例分类

三、创建单例模式

测试：1-7 实现单例模式测试代码

1、饿汉式（静态属性）线程安全

2、饿汉式（静态代码块）线程安全

3、懒汉式 (普通) 线程不安全

4、懒汉式 (synchronized) 线程安全

5、懒汉式 (同步代码块) 线程安全

6、懒汉式 (静态内部类) 线程安全

7、懒汉式 (DCL 双重锁校验) 线程安全

8、懒汉模式 (枚举) 线程安全

四、应用场景

---

一、什么是单例模式？

        保证一个类仅有一个对象，并提供一个访问它的全局访问点。

二、单例分类

                          

饿汉式：类加载就会导致该单实例对象被创建。

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时被创建。

三、创建单例模式

测试：1-7 实现单例模式测试代码

class Test {
    public static void main(String[] args) {
        SingletonObject instance = SingletonController.getInstance();
        SingletonObject instance1 = SingletonController.getInstance();
        System.out.println(instance.equals(instance1));
    }
}

 结果：true

1、饿汉式（静态属性）线程安全

public class SingletonController {
    //1、创建对象
    private static SingletonObject instance = new SingletonObject();

    //2、构造器私有化 (防止在类的外部产生类的对象)
    private SingletonController(){
    }

    //3、提供外界访问方法
    public static SingletonObject getInstance(){
        return instance;
    }

}

优点：类加载时就创建了对象

缺点：对象不被使用，会造成内存浪费

2、饿汉式（静态代码块）线程安全

public class SingletonController {
    //1、创建对象
    private static SingletonObject instance;

    //2、构造器私有化 (防止在类的外部产生类的对象)
    private SingletonController(){
    }

    //3、静态代码块赋值
    static{
        instance = new SingletonObject();
    }

    //4、提供外界访问方法
    public static SingletonObject getInstance(){
        return instance;
    }

}

优缺点与【1】相同

3、懒汉式 (普通) 线程不安全

public class SingletonController {
    //1、创建对象
    private static SingletonObject instance;

    //2、构造器私有化 (防止在类的外部产生类的对象)
    private SingletonController(){
    }

    //3、提供外界访问方法,加入synchronized,保证安全
    public static  SingletonObject getInstance(){
        if(instance == null){
           instance = new SingletonObject();
        }
        return instance;
    }

}

优点：需要时创建对象，避免造成内存浪费。

缺点：由于不安全，单线程使用。

        如果在多线程下，一个线程进入了if (instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

        在实际开发中，不要使用这种方式。

4、懒汉式 (synchronized) 线程安全

public class SingletonController {
    //1、创建对象
    private static SingletonObject instance;

    //2、构造器私有化 (防止在类的外部产生类的对象)
    private SingletonController(){
    }

    //3、提供外界访问方法,加入synchronized,保证安全
    public static synchronized SingletonObject getInstance(){
        if(instance == null){
           instance = new SingletonObject();
        }
        return instance;
    }

}

优点：解决了线程不安全问题。

缺点：效率低。

        每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步，效率太低。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。

        在实际开发中，不推荐使用这种方式。

5、懒汉式 (同步代码块) 线程安全

public class SingletonController {
    //1、创建对象
    private static SingletonObject instance;

    //2、构造器私有化 (防止在类的外部产生类的对象)
    private SingletonController(){
    }

    //3、提供外界访问方法,加入同步代码块,保证安全
    public static SingletonObject getInstance(){
        if(instance == null){
            synchronized (SingletonController.class){
                instance = new SingletonObject();
            }
        }
        return instance;
    }

}

优点：效率比同步关键字快。

缺点：跟【3】情况一样容易产生多个对象实例。

          实际开发当中不使用这种方式。

6、懒汉式 (静态内部类) 线程安全

public class SingletonController {

    //1、构造器私有化 (防止在类的外部产生类的对象)
    private SingletonController(){
    }

    //2、静态内部代码块
    public static class SingletonInstanceController {
        public static final SingletonObject INSTANCE = new SingletonObject();
    }
    
    //3、提供外界访问方法
    public static SingletonObject getInstance(){
       return SingletonInstanceController.INSTANCE;
    }

}

优点：采用了类装载的机制来保证初始化实例时只有一个线程。保证了懒加载，效率高，线程安全。

        类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

缺点：无

        实际开发推荐使用这种方式。

7、懒汉式 (DCL 双重锁校验) 线程安全

public class SingletonController {
    //1、创建对象
    private static volatile SingletonObject instance = null;

    //2、构造器私有化 (防止在类的外部产生类的对象)
    private SingletonController(){
    }

    //3、提供外界访问方法，使用双重检查
    public static SingletonObject getInstance(){
        // 第一次检查 如果有多个线程到达而还没初始化完毕 显然都可以通过第一次检查
        // 其实去掉第一重检查对于多线程的线程安全不影响 也可以实现单例模式
        // 好处是性能问题
        // 如果没有第一次检查 每次有线程调用getinstance，都会执行同步锁操作很耗费性能
        // 加上第一次检查的话 只有第一次未初始化的时候会执行一次同步锁
        // 初始化之后就直接return
        // 以后就不用进入同步代码块了 性能提升
        if(instance == null){
            // 要保证是单例，加锁 保证只有第一个线程创建完第二个线程才能获取instance
            // 此时 有一个线程进入同步代码块 其他线程等待
            synchronized (SingletonController.class){
                // 第二次检查
                // 如果没有第二次检查的话 那么其他没抢到等待锁线程还是可以调用new Instance语句
                // 这样就违背了单例模式
                if(instance == null){
                    instance = new SingletonObject();
                }
            }
        }
       return instance;
    }

}

优点：懒加载，效率高。

        在多线程情况下，可能会出现空指针问题。问题在于JVM在实例化对象时会进行优化和指令重排序操作。解决空指针问题只需使用volatile关键字，volatile可以保证可见性和有序性。

        实例化代码只用执行一次，后面再次访问时，判断if (instance == null)，直接return实例化对象，也避免的反复进行方法同步。

        实际开发推荐使用这种方式。

8、懒汉模式 (枚举) 线程安全

public enum SingletonController {
    INSTANCE("单例",123);

    private String key;
    private int value;

    SingletonController(String key, int value) {
        this.key = key;
        this.value = value;
    }
    
}


class Test {
    public static void main(String[] args) {
        SingletonController instance = SingletonController.INSTANCE;
        SingletonController instance1 = SingletonController.INSTANCE;
        System.out.println(instance.equals(instance1));
    }
}

结果：true

优点：线程安全、自由串行化、单⼀实例。

        借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

        虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现 Singleton 的最佳方法。

四、应用场景

1、项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
2、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
3、在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理。