【设计模式-手写源码1】-单例模式

最新推荐文章于 2023-07-03 21:38:36 发布

不要迷恋发哥

最新推荐文章于 2023-07-03 21:38:36 发布

阅读量520

点赞数

分类专栏：设计模式文章标签： c# 设计模式架构师

本文链接：https://blog.csdn.net/chongfa2008/article/details/119985612

版权

设计模式专栏收录该内容

25 篇文章 3 订阅

订阅专栏

本文详细介绍了Java中的单例模式，包括单例的三种实现方式（懒汉式和饿汉式）及其优缺点。讨论了线程安全问题，并给出了静态构造函数和静态字段实现单例的优化方法。同时，探讨了单例模式在数据库连接池、线程池等场景的应用，以及其在系统资源节省和控制唯一实例方面的优势。然而，单例模式也存在对象扩展困难、不适合变化对象等问题。总结了选择单例模式的考虑因素，并提供了相关参考资料。

摘要由CSDN通过智能技术生成

1：主题拆解

①单例模式(单线程和多线程)

②单例模式的三种写法

③单例模式的优缺点

④单例模式应用场景

2：基本介绍

一句话描述：某个类只能有一个实例，提供一个全局的访问点。

单例模式比较简单，可以说没有复杂的调用和接口的设计，就是一个简单的类，只是要求这个类只生成一个对象，无论什么时候都要保证这一点，因此只能生成一个实例的模式就是单例模式。3：如何手写一个单例模式

单例模式：保证进程中，类型只有一个实例

①构造函数私有化，防止他人实例化

②对外提供一个获取实例的途径，公开的静态方法

③返回共用一个静态字段

方法一

第一版

    public class Singleton
    { 
        private Singleton()
        { 
            //构造函数私有化
        }
        private static Singleton _Singleton = null;
        public static Singleton CreateInstance()
        {
            if (_Singleton == null)
            {
                _Singleton = new Singleton();
            }
            return _Singleton;
        }
    }

分析：如果对于多线性的访问，此处的会出现类被多次构造的问题，因此需要继续进行改进，加锁用于解决多线程访问的问题

第二版

    public class Singleton
    {
        private Singleton()
        { 
            //构造函数私有化
        }
        private static Singleton _Singleton = null;
        private static readonly object Singleton_Lock = new object();
        public static Singleton CreateInstance()
        {
            lock (Singleton_Lock)
            {
                if (_Singleton == null)
                {
                    _Singleton = new Singleton();
                }
            }
            return _Singleton;
        }
    }

分析：开始多线程初始化，lock锁定，判断对象创建。

但是当类实例化结束之后，再来多个线程请求的时候都需要等待锁。

这无疑是对性能的一种损耗与耗时。因此我们继续做优化

第三版

public class Singleton
    {
        private Singleton()
        { 
            //构造函数私有化
        }
        private static Singleton _Singleton = null;
        private static readonly object Singleton_Lock = new object();
        public static Singleton CreateInstance()
        {
            //对应已经创建，不需要等待锁，直接返回
            if (_Singleton == null)
            {
                lock (Singleton_Lock)//可以保证任意时刻只有一个线程进入，其他线程等待
                {
                    if (_Singleton == null)//这个判断不能去掉，保证只初始化一次
                    {
                        _Singleton = new Singleton();
                    }
                }
            }
            return _Singleton;
        }
    }

分析：

这里的两次判断，第一判断：效率，第二判断：避免同步。之所以这样是因为避免加锁后，再次加锁。大大增强了执行效率。

方式二

public sealed class SingletonSecond
    {        
        private SingletonSecond()
        {            
            //构造函数私有化
        }
        private static SingletonSecond _SingletonSecond = null;
       
        static SingletonSecond()
        {
            _SingletonSecond = new SingletonSecond();
        }
        public static SingletonSecond CreateInstance()
        {
            return _SingletonSecond;
        }
    }

分析：静态构造函数，由CLR保证，在第一次使用到这个类型之前，自动被调用且只调用一次

方式三

public sealed class SingletonThird
    {    
        private SingletonThird()
        {
         
        } 
        private static SingletonThird _SingletonThird = new SingletonThird();
        public static SingletonThird CreateInstance()
        {
            return _SingletonThird;
        }
    }

分析：静态字段:由CLR保障，在第一次使用这个类型之前，会自动初始化且只初始化一次