单例模式的8种写法

水深无声 2023-07-03 07:17 24阅读 0赞

> JVM内存结构 VS Java内存模型 VS Java对象模型：[https://blog.csdn.net/qq\_40794973/article/details/103960056][https_blog.csdn.net_qq_40794973_article_details_103960056]

> JMM应用实例：单例模式8种写法、单例和并发的关系（真实面试超高频考点）

--------------------

# 1 单例模式的作用和适用场景 #

> 单例模式的作用
> 
> 1.  为什么需要单例：节省内存和计算、保证结果正确、方便管理

private Resource rs = new Resource();
    public Resource getExpensiveResource(){
        return rs;
    }
    public Resource(){
        field1 = //some CPU heavy logic
        field2 = //some value from DB
        field3 = //etc.
    }

> 单例模式适用场景 
> 
> 1.  无状态的工具类：比如日志工具类，不管是在哪里使用，我们需要的只是它帮我们记录日志信息，除此之外，并不需要在它的实例对象上存储任何状态，这时候我们就只需要一个实例对象即可。
> 2.  全局信息类：比如我们在一个类上记录网站的访问次数，我们不希望有的访问被记录在对象A上，有的却记录在对象B上，这时候我们就让这个类成为单例。

--------------------

# 1 饿汉式（静态常量）\[可用\]  #

/**
     * 饿汉式（静态常量）（可用）
     */
    public class Singleton {
        private final static Singleton instance = new Singleton();
        // 构造函数私有化
        private Singleton() {
            //....
        }
        public static Singleton getInstance() {
            return instance;
        }
    }

--------------------

# 2 饿汉式（静态代码块）\[可用\] #

/**
     * 饿汉式（静态代码块）（可用）
     */
    public class Singleton {
        private final static Singleton instance;
        static {
            // 构造对象可能还会从配置文件读取配置
            Properties prop = new Properties();
            try {
                prop.load(Singleton.class.getClassLoader().getResourceAsStream("single.properties"));
            } catch (IOException e) {
                throw new RuntimeException("加载配置文件single.properties失败");
            }
            String name = prop.getProperty("jdbc.name");
            // 构造对象
            instance = new Singleton();
        }
        // 私有构造函数
        private Singleton() {}
        public static Singleton getInstance() {
            return instance;
        }
    }

### single.properties
    jdbc.name=root
    jdbc.password=123456

> 注意！！！

/**
     * 写法不当容易产生NPE
     */
    public class Singleton {
        static {
            instance = new Singleton();
        }
        private static Singleton instance = null;
        private Singleton() {}
        public static Singleton getInstance() {
            return instance;
        }
        public static void main(String[] args) {
            System.out.println(getInstance().hashCode());
        }
    }

--------------------

# 3 懒汉式（线程不安全）\[不可用\] #

/**
     * 懒汉式（线程不安全）
     */
    public class Singleton {
        private static Singleton instance;
        private Singleton() {
            //...
        }
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

>  验证线程安全

// 验证线程安全
    public class Singleton {
        private static Singleton instance;
        private Singleton() {}
        public static Singleton getInstance() {
            if (instance == null) {
                try {
                    TimeUnit.MICROSECONDS.sleep(10);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                }
                instance = new Singleton();
            }
            return instance;
        }
    }

public class Main {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //Callable<Singleton> task = new Callable<Singleton>(){
            //    @Override
            //    public Singleton call() throws Exception {
            //        return Singleton.getInstance();
            //    }
            //};
    
            Callable<Singleton> task = Singleton::getInstance;
            ExecutorService executor = Executors.newFixedThreadPool(2);
            Future<Singleton> f1 = executor.submit(task);
            Future<Singleton> f2 = executor.submit(task);
    
            Singleton s1 = f1.get();
            Singleton s2 = f2.get();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);
            executor.shutdown();
        }
    }

--------------------

# 4 懒汉式（线程安全，同步方法）\[不推荐用\] #

/**
     * 懒汉式（线程安全）（不推荐）
     */
    public class Singleton {
        private static Singleton instance;
        private Singleton() {
            //...
        }
        //多个线程无法并行执行，不能及时的响应
        public synchronized static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

--------------------

# 5 懒汉式（线程不安全，同步代码块）\[不可用\] #

/**
     * 懒汉式（线程不安全）（不推荐）
     */
    public class Singleton {
        private static Singleton instance;
        private Singleton() {
            //...
        }
        public static Singleton getInstance() {
            //并没有解决线程安全问题
            if (instance == null) {
                //这里虽然是同步的，但是还是会多次运行
                synchronized (Singleton.class) {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

--------------------

# 6 双重检查\[推荐用\] #

> 优点：线程安全；延迟加载；效率较高。
> 
> --------------------
> 
> 为什么要double-check
> 
> 1.  线程安全
> 2.  单check行不行？//可 第四种
> 3.  性能问题
> 
> --------------------
> 
> 为什么要用volatile
> 
> 1.  新建对象实际上有3个步骤
> 2.  重排序会带来NPE
> 3.  防止重排序

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

/**
     * 双重检查（推荐面试使用）
     */
    public class Singleton {
        //注意volatile
        //1.可见性
        //2.防止重排序
        private volatile static Singleton instance;
        private Singleton() {
            //...
        }
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    //虽然可能进来多个，但是我再做一次检查即可避免多次创建实例
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

> 不加volatile产生错误分析
> 
> 指令重排只会保证串行语义的执行的一致性(单线程)，但并不会关心多线程间的语义一致性，所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。

//非线程安全
    public class Singleton {
        private static Singleton instance = null;
        private Singleton() {}
        // memory = allocate() // 1.分配对象的内存空间
        // ctorInstance()      // 2.初始化对象
        // instance = memory   // 3.设置instance指向刚分配的内存，此时instance!=null
     
        // JVM和cpu优化，发生了指令重排
        // 步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。
     
        // memory = allocate() // 1.分配对象的内存空间
        // instance = memory   //2.设置instance指向刚分配的内存，此时instance!=null，但是对象还没有初始化完成
        // ctorInstance()      //3.初始化对象
        
        // 静态的工厂方法
        public static Singleton getInstance() {
            if (instance == null) { // 线程2：线程1已经执行了重排序后的前两个指令，instance!=mull 了但是单例对象还没有初始化完成，这个时候返回的是未初始化完成的对象
                synchronized (Singleton.class) { // 同步锁
                    if (instance == null) {
                        instance = new Singleton(); // 线程1：在执行指令重排后的3步
                    }
                }
            }
            return instance;
        }
    }

--------------------

# 7 静态内部类\[推荐用\] #

> 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的

/**
     * 静态内部类方式，可用
     */
    public class Singleton {
        private Singleton() {
            //...
        }
        // JVM类加载的性质，保证了即便多个线程同时访问这个SingletonInstance，也不会创建多个实例
        // 在内部类被加载和初始化时，才创建INSTANCE实例对象
        private static class SingletonInstance {
            private static final Singleton INSTANCE = new Singleton();
        }
        public static Singleton getInstance() {
            return SingletonInstance.INSTANCE;
        }
    }

> **懒汉**，调用这个方法才会初始化 ；加载一个类时，其内部类不会同时被加载

public class Singleton {
        static {
            System.out.println("Singleton被初始化啦...");
        }
        private Singleton() {
            //...
        }
        private static class SingletonInstance {
            static {
                System.out.println("Singleton里面的静态内部类被初始化啦...");
            }
            private static final Singleton INSTANCE = new Singleton();
        }
        public static Singleton getInstance() {
            return SingletonInstance.INSTANCE;
        }
        public static void main(String[] args) {
            //Singleton.getInstance();//只有调用这个方法，Singleton里面的静态内部类才会被初始化
        }
    }

--------------------

# 8 枚举\[推荐用\] #

/**
     * 枚举单例（推荐生产实践中使用）
     */
    public enum Singleton {
        INSTANCE;
        /**
         * 类中的方法
         */
        public Connection jdbcConnection() {
            String user = "root";
            String password = "123456";
            String url = "jdbc:mysql://ip:port/dbName?characterEncoding=utf-8&useUnicode=true&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true";
            String className = "com.mysql.cj.jdbc.Driver";
            try {
                Class.forName(className);
                return DriverManager.getConnection(url, user, password);
            } catch (ClassNotFoundException | SQLException e) {
                throw new RuntimeException(e.getMessage());
            }
        }
    }

public class Main {
        public static void main(String[] args) {
            Connection conn = Singleton.INSTANCE.jdbcConnection();
        }
    }

> 另一种写法

public class SingletonExample {
        // 私有构造函数
        private SingletonExample() {
        }
        public static SingletonExample getInstance() {
            return Singleton.INSTANCE.getInstance();
        }
        private enum Singleton {
            INSTANCE;
            private SingletonExample singleton;
            // JVM保证这个方法绝对只调用一次
            Singleton() {
                singleton = new SingletonExample();
            }
            public SingletonExample getInstance() {
                return singleton;
            }
        }
    }

--------------------

# 9 不同写法对比 #

>  *  饿汉：简单，但是没有 lazy loading
>  *  懒汉：有线程安全问题
>  *  静态内部类：可用
>  *  双重检查：面试用
>  *  枚举：最好

## 9.1 用哪种单例的实现方案最好？ ##

>  *  Joshua Bloch大神在《Effective java》中明确表达过的观点：“使用枚举实现单例的方法虽然还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。”
>  *  写法简单
>  *  线程安全有保障
>  *  避免反序列化破坏单例

## 9.2 各种写法的适用场合 ##

>  *  最好的方法是利用枚举，因为还可以防止反序列化重新创建新的对象
>  *  非线程同步的方法不能使用
>  *  如果程序一开始要加载的资源太多，那么就应该使用懒加载
>  *  饿汉式如果是对象的创建需要配置文件就不适用
>  *  懒加载虽然好，但是静态內部类这种方式会引入编程复杂性

## 9.3 其他问题  ##

> 饿汉式的缺点？
> 
>  *  优点：写法简单，线程安全
>  *  缺点：程序启动就加载，不需要这个实例也加载了，造成资源的浪费
> 
> --------------------
> 
> 懒汉式的缺点？
> 
>  *  优点：解决了前期加载浪费的问题，只在需要的时候才加载进来
>  *  缺点：写法相对比较复杂，不注意容易写成线程不安全的情况
> 
> --------------------
> 
> 为什么要用 double-check？不用就不安全吗？
> 
> 1.  为什么单重锁是线程池不安全的
> 2.  逐渐演变升级到双重锁代码 //**懒加载 线程安全**
> 3.  synchronized加方法上虽然安全，但是效率底响应慢
> 
> --------------------
> 
> 为什么双重检査模式要用volatile？
> 
>  
> 
> --------------------
> 
> 应该如何选择，用哪种单例的实现方案最好？
> 
>

//饿汉式
    //java.lang.Runtime
    public class Runtime {
    	private static Runtime currentRuntime = new Runtime();
        public static Runtime getRuntime() {
            return currentRuntime;
        }
        //构造方法私有化
        private Runtime() {}

[https_blog.csdn.net_qq_40794973_article_details_103960056]: https://blog.csdn.net/qq_40794973/article/details/103960056
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020020410522337.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70