荐 设计模式之单例模式（5种实现方式）

1.什么是单例模式

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。

实现步骤：

1. 私有化构造方法
2. 静态化实例对象
3. 提供一个静态对象返回方法

1.1 饿汉模式

• 优点：没有加锁，执行效率会提高。
• 缺点：类加载时就初始化，浪费内存。

public class Singleton1 {

    private Singleton1(){}
    
    private static Singleton1 singleton1 = new Singleton1();
    
    public static Singleton1 getInstance(){
        return singleton1;
    }
}

1.2 懒汉模式

• 优点：第一次调用才初始化，避免内存浪费。
• 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

注：synchronized 关键字用法 https://www.cnblogs.com/fnlingnzb-learner/p/10335662.html

public class Singleton2 {
    private Singleton2(){}
    private static Singleton2 singleton2;
    public static synchronized Singleton2 getInstance(){
        if (singleton2 == null){
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

1.3 静态内部类

• 优点：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。
• 缺点：需要两个类去做到这一点，虽然不会创建静态内部类的对象，但是其 Class 对象还是会被创建，而且是属于永久带的对象。

注：静态内部类只有在被调用时才会被加载

public class Singleton3 {
    private Singleton3(){}

    public static class Single3ClassInstance{
        private static final Singleton3 singleton3 = new Singleton3();
    }

    public static Singleton3 getInstance(){
        return Single3ClassInstance.singleton3;
    }

}

• 1.4  双重检查锁

• 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

public class Singleton4 {

    private Singleton4(){}

    private static Singleton4 singleton4;

    public static Singleton4 getInstance(){
        if (singleton4 == null){
            synchronized (Singleton4.class){
                if (singleton4 == null ){
                   singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }
}

1.5 枚举

这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

注：枚举类型使用 https://blog.csdn.net/newbie_907486852/article/details/81027512

public class Singleton5 {

    private static enum getSingleton5{
        INSTANCE;
        private Singleton5 singleton5;
        private getSingleton5(){
            singleton5 = new Singleton5();
        }
        public Singleton5 getInstance(){
            return  singleton5;

        }
    }
    public static Singleton5 getInstance(){
        return getSingleton5.INSTANCE.getInstance();
    }
}

参考：

https://www.runoob.com/design-pattern/singleton-pattern.html

https://blog.csdn.net/weixin_42152604/article/details/87915944

https://blog.csdn.net/weixin_42762133/article/details/82890555

https://www.cnblogs.com/fnlingnzb-learner/p/10335662.html

https://blog.csdn.net/newbie_907486852/article/details/81027512

附测试类

public class Main {

    public static void main(String[] args) {
        System.out.println("=====饿汉模式=====");
        Singleton1 singleton1 = Singleton1.getInstance();
        Singleton1 singleton11 = Singleton1.getInstance();
        System.out.println(singleton1==singleton11);

        System.out.println("=====懒汉模式=====");
        Singleton2 singleton2 = Singleton2.getInstance();
        Singleton2 singleton21 = Singleton2.getInstance();
        System.out.println(singleton2 == singleton21);

        System.out.println("=====静态内部类模式=====");
        Singleton3 singleton3 = Singleton3.getInstance();
        Singleton3 singleton31 = Singleton3.getInstance();
        System.out.println(singleton3 == singleton31);

        System.out.println("=====双重检查锁模式=====");
        Singleton4 singleton4 = Singleton4.getInstance();
        Singleton4 singleton41 = Singleton4.getInstance();
        System.out.println(singleton4 == singleton41);

        System.out.println("=====枚举类型模式=====");
        Singleton5 singleton5 = Singleton5.getInstance();
        Singleton5 singleton51 = Singleton5.getInstance();
        System.out.println(singleton5 == singleton51);
    }
}

 

本文地址：https://blog.csdn.net/qq_36110736/article/details/107582945