大话设计模式笔记(十八)の单例模式
单例模式
定义
保证一个类仅有一个实例,并提供一个访问它的全局访问点。
通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象。一个最好的办法就是,让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以创建,并且它可以提供一个访问该实例的方法。
UML图
方式一:单线程下的单例
1. /**
2. * Created by callmeDevil on 2019/8/17.
3. */
4. public class Singleton {
5.
6. private static Singleton instance;
7.
8. private Singleton(){} //构造方法私有,防止外界创建实例
9.
10. // 获得本类实例的唯一全局访问点
11. public static Singleton getInstance(){
12. if (instance == null) {
13. //若实例不存在,则创建一个新实例,否则直接返回已有实例
14. instance = new Singleton();
15. }
16. return instance;
17. }
18.
19. }
20.
测试
1. public class Test {
2. public static void main(String[] args) {
3. Singleton s1 = Singleton.getInstance();
4. Singleton s2 = Singleton.getInstance();
5. if (s1 == s2) {
6. System.out.println("两个对象是相同的实例");
7. }
8. }
9. }
10.
测试结果
1. 两个对象是相同的实例
2.
在没有并发问题的情况下,这种方式也是使用比较多的。但缺点也很明显,多线程下根本没法用。
方式二:多线程下的单例
1. /**
2. * Created by callmeDevil on 2019/8/17.
3. */
4. public class SingletonOnLock {
5.
6. private static SingletonOnLock instance;
7.
8. private SingletonOnLock(){}
9.
10. public static SingletonOnLock getInstance(){
11. // 同步代码块,只有一个线程能进入,其他阻塞
12. synchronized (SingletonOnLock.class){
13. if(instance == null){
14. instance = new SingletonOnLock();
15. }
16. }
17. return instance;
18. }
19.
20. }
21.
存在问题
当存在对象实例时,完全不用担心并发时导致堆中创建多个实例,但每次调用 getInstance() 方法时都被加锁,是会影响性能的,因此这个类可以继续改良。
方式三:双重锁定(DCL)
1. /**
2. * Created by callmeDevil on 2019/8/17.
3. */
4. public class SingletonOnDoubleCheckLock {
5.
6. private static SingletonOnDoubleCheckLock instance;
7.
8. private SingletonOnDoubleCheckLock(){}
9.
10. public static SingletonOnDoubleCheckLock getInstance(){
11. // 先判断实例是否存在,不存在再考虑并发问题
12. if (instance == null) {
13. synchronized (SingletonOnDoubleCheckLock.class){
14. if(instance == null){
15. instance = new SingletonOnDoubleCheckLock();
16. }
17. }
18. }
19. return instance;
20. }
21.
22. }
23.
两次判断实例是否存在的原因
当实例存在时,就直接返回,这是没有问题的。当实例为空并且有两个线程调用 getInstance() 方法时,它们都可以通过第一重 instace == null 的判断,然后由于 synchronized 机制,只有一个线程可以进入,另一个阻塞,必须要在同步代码块中的线程出来后,另一个线程才会进入。而此时如果没有第二重的判断,那第二个线程仍然会创建实例,这就达不到单例的目的了。
但这种方式是最让人“诟病”的一种不推荐方式,技巧看上去很好,但实际上同样影响性能。
方式四:静态初始化
1. /**
2. * 该类声明为final ,阻止派生,因为派生可能会增加实例
3. * Created by callmeDevil on 2019/8/17.
4. */
5. public final class SingletonStatic {
6.
7. // 第一次引用类的任何成员时就创建好实例,同时没有并发问题
8. private static final SingletonStatic instance = new SingletonStatic();
9.
10. private SingletonStatic(){}
11.
12. public static SingletonStatic getInstance(){
13. return instance;
14. }
15.
16. }
17.
JVM第一次加载类的时候就已经创建好了实例,如果接下来的很长时间都没有用到的话,占用的内存相当于被浪费了,也不是最让人推荐的一种方式。当然现在的服务器容量也越来越大,单单一个实例的内存也并不是任何情况都要考虑节省。除非追求极致。。
总结
- 静态初始化的方式是自己被加载时就已经将自己实例化,因此也被称为“饿汉式”。
- 其他方式是要在第一次被引用时,才会将自己实例化,所以被称为“懒汉式”。
- 其实单例模式还有很多种实现方式,下面再提一种《大话设计模式》中未提到的实现:静态内部类。 这是楼主在《Java并发编程实战》中看到的,也是最为推荐的一种。
扩展
方式五:静态内部类
1. /**
2. * Created by callmeDevil on 2019/8/17.
3. */
4. public class SingletonStaticClass {
5.
6. private SingletonStaticClass() {}
7.
8. public SingletonStaticClass getInstande() {
9. return InterClass.instance;
10. }
11.
12. // 静态内部类,没有并发问题
13. private static final class InterClass {
14. public static SingletonStaticClass instance = new SingletonStaticClass();
15. }
16.
17. }
18.
推荐原因
JVM第一次加载外部的 SingletonStaticClass 时,并不会直接实例化,所以这种方式也属于“懒汉式”。只有在第一次调用 getInstance() 方法时,JVM才会加载内部类 InterClass,接着才实例化静态变量,也就是我们需要的外部类的单例。这样不仅延时了实例化,同时也解决了并发访问的问题,因此该方式是最为推荐的一种方式。
Pass:以上纯属个人理解~~如果发现有错或是心存建议意见等,欢迎大家评论或联系~(# ゚Д゚)~祝大家身体健康学习进步工作顺利生活愉快!
版权归 callmeDevil 所有,如需转载请标注转载来源
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步