设计模式--单例模式

小鱼儿 2021-06-11 15:11 355阅读 0赞

### 文章目录 ###

*  1.定义
 *  2.实现单例的两种方式
 *   *  2.1.实现单例需要注意三点：
     *  2.2.饿汉式
     *  2.3.懒汉式
     *   *  2.3.1.懒汉式--静态方法（非线程安全）
         *  2.3.2.懒汉式--静态方法+内部类（推荐）
         *  2.3.3.懒汉式--静态方法+内部类+synchronized
 *  3.总结

# 1.定义 #

确保一个类只有一个实例，并提供一个全局访问点。

# 2.实现单例的两种方式 #

## 2.1.实现单例需要注意三点： ##

1.  私有构造器，保证只能在本类内部实例对象。
2.  提供私有静态变量保存实例对象。
3.  提供公有静态方法返回实例对象。

## 2.2.饿汉式 ##

**定义：** 饿汉式是在JVM加载类时候就实例化对象，后期每次调用返回的都是在加载类时候创建的对象。  
**缺点：** 加重程序在创建时候的负担，而且如果后期没有调用则相对浪费资源。  
代码如下：

public class SingletonTwo { 
        private static SingletonTwo instance = new SingletonTwo();
    
        private SingletonTwo() { 
        }
    
        public static SingletonTwo getInstance() { 
            return instance;
        }
    }

## 2.3.懒汉式 ##

### 2.3.1.懒汉式–静态方法（非线程安全） ###

**定义：** 饿汉式是在公有静态方法getInstance()中实例化对象，即在调用时候才创建对象。示例代码如下：

public class SingletonOne { 
        private static SingletonOne instance;
    
        private SingletonOne() { 
        }
    
        public static SingletonOne getInstance() { 
            if (instance == null) { 
                instance = new SingletonOne();
            }
            return instance;
        }
    }

**缺点：** 懒汉式V1不能保证线程安全，多线程中仍会出现多个实例。如图：  
![这里写图片描述][70]  
![这里写图片描述][70 1]  
如果上图代表两个线程，执行顺序按照A、B、C、D的顺序执行，还是会出现多个实例的情况。  
**解决多线程问题有四个办法：**

*  **在getInstance()上用synchronized关键字** 。如图：  
    ![这里写图片描述][70 2]  
    但是使用synchronized关键字会严重影响性能，如果对性能要求较高请慎重选择。
 *  **直接在静态变量instance处实例化对象，即饿汉式（上文2.2）** 。
 *  **使用“双重检查加锁”，并且使用volatile关键字。**  
    使用双重检查加锁即是在getInstance()内部先检查instance变量，然后使用synchronized关键字重新检查instance变量(，并且使用volatile关键字保证在instance实例化时，多个线程能正确的处理instance对象。  
    *注：volatile关键字为java中使用的另一种同步机制，网上这边文章讲的不错：[https://www.cnblogs.com/a31415926/p/6744485.html][https_www.cnblogs.com_a31415926_p_6744485.html]*
 *  **使用懒汉式V2解决。**

### 2.3.2.懒汉式–静态方法+内部类（推荐） ###

**定义：** 使用内部类的私有静态变量创建实例化对象，然后通过静态方法调用内部类中实例化的对象。如下：  
注：只有在第一次调用getInstance()时候，才会加载内部类并且创建SingletonOneV2的实例化对象

public class SingletonOneV2 { 
    
        private SingletonOneV2() { 
        }
    
        static class SingletonInner { 
            private static SingletonOneV2 instance = new SingletonOneV2();
        }
    
        public static SingletonOneV2 getInstance() { 
            return SingletonInner.instance;
        }
    }

**缺点：** 通过反射能破坏懒汉式V2的单例结构。测试如下：  
![这里写图片描述][70 3]  
注：推荐使用此版本，开发人员注意不要使用反射获取单例类的实例就可避免此问题。

### 2.3.3.懒汉式–静态方法+内部类+synchronized ###

**定义：** 使用内部类的私有静态变量创建实例化对象，然后通过静态方法调用内部类中实例化的对象，并且使用synchronized解决懒汉式V2的反射的问题。如下：

public class SingletonOneV3 { 
    
        private static boolean inited = false;
    
        private SingletonOneV3() { 
            synchronized (SingletonOneV3.class) { 
                if (inited == false) { 
                    inited = !inited;
                } else { 
                    throw new RuntimeException("单例被破坏，不能创建实例");
                }
            }
        }
    
        static class SingletonInner { 
            private static SingletonOneV3 instance = new SingletonOneV3();
        }
    
        public static SingletonOneV3 getInstance() { 
            return SingletonInner.instance;
        }
    }

测试解决反射问题如下：  
![这里写图片描述][70 4]

# 3.总结 #

单例模式创建通过饿汉式和懒汉式来时间单例对象的“优先”创建和“延迟”创建。其中延迟创建单例对象有分为通过静态方法、内部类、synchronized等创建，来避免反射及线程安全等出现的问题。还看到有在分布式程序中将单例对象序列化后通过文件存取扔保证单例特性的写法（具体参见：[文件存取后如果保证单例的特性][Link 1]），不过鉴于没有接触这块及不知道使用场景等就没在此处列出。  
参考资料：  
《Head Firsh 设计模式》（中文版）

[70]: /images/20210607/c273bc4962a643eabaa2e7efd9b6e244.png
[70 1]: /images/20210607/61762c62826f413faa3f24a2a508bb6d.png
[70 2]: /images/20210607/23c39956a88744bcbc2fda122dc5e38c.png
[https_www.cnblogs.com_a31415926_p_6744485.html]: https://www.cnblogs.com/a31415926/p/6744485.html
[70 3]: /images/20210607/cd99b52037b248a980a7c981fa6c13db.png
[70 4]: /images/20210607/c8fd1e294b294634b4c2be7204277d0b.png
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzU0OTE4MzYzMw==&mid=2247484702&idx=1&sn=064399af930e9915023b2805e84cee7d&chksm=fbb28ce0ccc505f6ca630d91a5b777584b1e46f07810ca822d516a528dbe5148fe5a8fe39ebb&mpshare=1&scene=23&srcid=050900NjmoA12e7sGD1fm0lv#rd