设计模式——单例模式

最新推荐文章于 2017-10-04 06:34:16 发布
最新推荐文章于 2017-10-04 06:34:16 发布
阅读量182 收藏
点赞数
分类专栏： .net 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010855333/article/details/76304095
版权

单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。
关键点：
1）一个类只有一个实例
2）它必须自行创建这个实例
3）它必须自行向整个系统提供这个实例
一、应用场景
一般数据底层封装的connection db连接、Read File、WCF、Mongodb等非托管资源，因为每一次操作目标对象的时候都需要new一个对象，然后在和目标数据建立连接，因为在这个过程中需要耗费很多资源更主要的是耗费时间，所有能否有一个办法能够保存new出来的对象这样就不需要每次调用的时候都要new一个对象,这不我们可以通过将要实例化的对象进行Static这样就相当于在类中缓存了一个静态对象，这样就不需要我们每次调用的时候在实例化了，
二、代码走起来
首先看下面单例模式：

public class SingleClass
    {
        //饿汉单例模式
        //在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快
        private static SingleClass singleClass=new  SingleClass();//静态私有成员，已初始化

        /// <summary>
        /// 构造函数
        /// </summary>
        private SingleClass()
        {
           Thread.Sleep(5000);
            Console.WriteLine("实例化");
        }

        /// <summary>
        /// 获取单例对象
        /// </summary>
        /// <returns></returns>
        public static SingleClass GetInstance()
        {
            //静态，不用同步（类加载时已初始化，不会有多线程的问题）
            return singleClass;
        }
        /// <summary>
        /// 方法
        /// </summary>
        private static void ShowMessage()
        {
            //Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
           Console.WriteLine("ShowMessage");
        }

        private static void Main(string[] args)
        {
            var instance = SingleClass.GetInstance();
            Console.ReadLine();
        }
    }

运行结果是：
这里写图片描述

上面该模式称作为懒汉模式因为在类初始化的时候默认的就初始化静态实例对象singleClass会导致初始化加载的速度会稍微慢，但是在获取对象的时候会很快。但是懒汉模式存在一个缺点就是当调用该类中的其他静态方法的时候，该懒汉单例模式就会初始化静态对象，具体看如下代码：

public class SingleClass
    {
        //饿汉单例模式
        //在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快
        private static readonly SingleClass singleClass=new  SingleClass();//静态私有成员，已初始化

        /// <summary>
        /// 构造函数
        /// </summary>
        private SingleClass()
        {
           Thread.Sleep(5000);
            Console.WriteLine("实例化");
        }

        /// <summary>
        /// 获取单例对象
        /// </summary>
        /// <returns></returns>
        public static SingleClass GetInstance()
        {
            //静态，不用同步（类加载时已初始化，不会有多线程的问题）
            return new SingleClass();
        }
        /// <summary>
        /// 方法
        /// </summary>
        private static void ShowMessage()
        {
            //Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
           Console.WriteLine("ShowMessage");
        }

        private static void Main(string[] args)
        {
            //var instance = SingleClass.GetInstance();
            SingleClass.ShowMessage();
            Console.ReadLine();
        }
    }

运行结果：
这里写图片描述

说道这里不得不说到和懒汉模式相对的就是饱汉模式，首先看下面例子：

public class SingleClass
    {
        //饱汉式单例模式
        //不饿，在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢
        private static  SingleClass singleClass = null;//静态私用成员，没有初始化

        /// <summary>
        /// 构造函数
        /// </summary>
        private SingleClass()
        {
           Thread.Sleep(5000);
            Console.WriteLine("实例化");
        }

        /// <summary>
        /// 获取单例对象
        /// </summary>
        /// <returns></returns>
        public static SingleClass GetInstance()
        {
            if (singleClass == null)
            {
                singleClass = new SingleClass();
            }
            return singleClass;
        }
        /// <summary>
        /// 方法
        /// </summary>
        private static void ShowMessage()
        {
            //Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
           Console.WriteLine("ShowMessage");
        }

        private static void Main(string[] args)
        {
            //var instance = SingleClass.GetInstance();
            SingleClass.ShowMessage();
            Console.ReadLine();
        }
    }

运行结果：
这里写图片描述
在调用ShowMessage方法时候不创建实例,这样就不需要显示多余提示；但是如果多个线程同时调用该静态方法中的实例方法的时候；当第一个线程还没有创建好该对象，那么第二个(或者更多)线程就会创建该实例，这样的本来想一个对象为整个系统服务；但是现在反倒没有达成该想法，具体看如下代码：

public class SingleClass
    {
        //饱汉式单例模式
        //不饿，在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢
        private static  SingleClass singleClass = null;//静态私用成员，没有初始化

        /// <summary>
        /// 构造函数
        /// </summary>
        private SingleClass()
        {
           Thread.Sleep(5000);
            Console.WriteLine("实例化");
        }

        /// <summary>
        /// 获取单例对象
        /// </summary>
        /// <returns></returns>
        public static SingleClass GetInstance()
        {
            if (singleClass == null)
            {
                singleClass = new SingleClass();
            }
            return singleClass;
        }
        /// <summary>
        /// 方法
        /// </summary>
        private static void ShowMessage()
        {
            Console.WriteLine("当前线程编号是:"+Thread.CurrentThread.ManagedThreadId);
           //Console.WriteLine("ShowMessage");
        }

        private static void Main(string[] args)
        {
            //var instance = SingleClass.GetInstance();
            //SingleClass.ShowMessage();
            Parallel.For(1, 10, (i) =>
            {
                 SingleClass.GetInstance();
                ShowMessage();
            });

            Console.ReadLine();
        }
    }

运行结果：
这里写图片描述

本来想一个静态对象就能够解决所有问题但是在多线程中每个方法实例化一个静态对象，导致该单例模式不管用，那有何解决办法呢？
双检锁模式：
为了防止多个线程调用一个静态实例方法会产生多个静态实例，具体解决方法是要用到Lock锁，代码如下：

public class SingleClass
    {
        //饱汉式单例模式
        //不饿，在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢
        private static  SingleClass singleClass = null;//静态私用成员，没有初始化
        //该对象用于Lock保证只能一个线程执行获取实例的代码中
        private static object lockMe=new object() ;

        /// <summary>
        /// 构造函数
        /// </summary>
        private SingleClass()
        {
           Thread.Sleep(5000);
            Console.WriteLine("实例化");
        }

        /// <summary>
        /// 获取单例对象
        /// </summary>
        /// <returns></returns>
        public static SingleClass GetInstance(int chreadId)
        {

            if (singleClass == null)
            {
                lock (lockMe)
                {
                    singleClass = new SingleClass();
                    Console.WriteLine($"线程{chreadId}正在New,创建instance时间是{DateTime.Now}");
                }

            }
            return singleClass;
        }
        /// <summary>
        /// 方法
        /// </summary>
        private static void ShowMessage()
        {
            Console.WriteLine($"当前线程编号是:{Thread.CurrentThread.ManagedThreadId}" );
           //Console.WriteLine("ShowMessage");
        }

        private static void Main(string[] args)
        {
            //var instance = SingleClass.GetInstance();
            //SingleClass.ShowMessage();
            Parallel.For(1, 10, (i) =>
            {
                 SingleClass.GetInstance(i);
                //ShowMessage();
            });

            Console.ReadLine();
        }
    }

运行结果：
这里写图片描述
这个就可以保证多个线程每次请求一个实例方法获取的是相同的实例对象
我们可以吧代码写的更加完整，完整代码如下：

public class SingleClass
    {
        //饱汉式单例模式
        //不饿，在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢
        private static  SingleClass singleClass = null;//静态私用成员，没有初始化
        //该对象用于Lock保证只能一个线程执行获取实例的代码中
        private static object lockMe=new object() ;

        /// <summary>
        /// 构造函数
        /// </summary>
        private SingleClass()
        {
           Thread.Sleep(5000);
            Console.WriteLine("实例化");
        }

        /// <summary>
        /// 获取单例对象
        /// </summary>
        /// <returns></returns>
        public static SingleClass GetInstance(int chreadId)
        {
           //初次判断静态对象是否为空为了进入队里排队实例化对象
            if (singleClass == null)
            {
                lock (lockMe)
                {
                    //轮到当前线程实例化静态对象的时候；要判断静态对象是否已经实例化了
                    if (singleClass == null)
                    {
                        singleClass = new SingleClass();
                        Console.WriteLine($"线程{chreadId}正在New,创建instance时间是{DateTime.Now}");
                    }
                    else
                    {
                        Console.WriteLine($"我进入LockMe但是我发现别人已经实例化好了对象我可以直接就用了");
                        return  singleClass;

                    }

                }

            }
            return singleClass;
        }
        /// <summary>
        /// 方法
        /// </summary>
        private static void ShowMessage()
        {
            Console.WriteLine($"当前线程编号是:{Thread.CurrentThread.ManagedThreadId}" );
           //Console.WriteLine("ShowMessage");
        }

        private static void Main(string[] args)
        {
            //var instance = SingleClass.GetInstance();
            //SingleClass.ShowMessage();
            Parallel.For(1, 10, (i) =>
            {
                 SingleClass.GetInstance(i);
                //ShowMessage();
            });

            Console.ReadLine();
        }
    }

运行结果：
这里写图片描述

范特西科技
关注
专栏目录
C++设计模式——单例模式
jiaoooooo的博客
05-06 1610
文章目录前言一、饿汉模式二、懒汉模式1.简易版2.局部静态变量保证线程安全（c++11新标准）3.使用静态类析构4.使用智能指针析构总结 前言 一个类中只产生一个对象，并提供一个外部访问点，被程序全员共享，简化了在复杂环境下的配置管理，这种模式被成为单例模式。 一、饿汉模式 不管用不用，在程序开始就加载，会导致程序启动慢，且如果有多个单例类对象实例启动顺序不确定 线程安全，一共只生成一个静态对象 /* * HungerSingleton.h */ #pragma once #ifndef _HUNGER
C++ 设计模式——单例模式
最新发布
qq_68194402的博客
08-22 1580
单例模式（Singleton Pattern）也称单件模式/单态模式，是一种创建型模式，用于创建只能产生一个对象实例的类。
java设计模式——单例模式
12-22
【Java设计模式——单例模式】 单例模式是一种常见的软件设计模式，它的核心思想是确保在应用程序的整个生命周期中，某个类只有一个实例存在。这种模式主要用于控制类的实例化过程，减少系统资源的消耗，提高系统...
C++设计模式——单例模式-附件资源
03-05
C++设计模式——单例模式-附件资源
设计模式——单例模式（懒汉模式）
08-10
单例模式是软件设计模式中的一种经典模式，它保证了类在任何情况下都只有一个实例存在。这个模式在很多场景下非常有用，例如控制全局资源、管理配置信息等。本文将详细探讨单例模式的懒汉式实现，并结合源码进行解析...
C# Quartz作业调度配置
热门推荐
u010855333的博客
05-28 1万+
什么是Quartz Quartz是是一个开源的作业调度框架,Quartz根据用户设定的时间规则来执行作业，使用场景：在平时的工作中，估计大多数都做过轮询调度的任务，比如定时轮询数据库同步，定时邮件通知、定时关闭网上商城的用户还未支付的订单等等。 Quartz运用场景 作业场景：公司商城平台中客户未支付的订单超过半个小时未支付就要清理掉 1) . 数据库中订单主表主要字段如下： 2) .下
XSS简单预防
u010855333的博客
05-06 496
原理 跨站脚本（Cross site script，简称xss）是一种“HTML注入”，由于攻击的脚本多数时候是跨域的，所以称之为“跨域脚本”。 我们常常听到“注入”（Injection），如SQL注入，那么到底“注入”是什么？注入本质上就是把输入的数据变成可执行的程序语句。SQL注入是如此，XSS也如此，只不过XSS一般注入的是恶意的脚本代码，这些脚本代码可以用来获取合法用户的数据，如Cook
设计模式——中介模式
u010855333的博客
10-04 449
中介模式：用一个中介者对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使耦合松散，而且可以独立地改变它们之间的交互。 类图： 中介者模式的结构 中介者模式又称为调停者模式，从类图中看，共分为3部分： 抽象中介者：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法，并由子类去实现。 中介者实现类：从抽象中介者继承而
设计模式——过滤模式
u010855333的博客
08-07 436
过滤模式是开发人员根据业务需求对过滤器进行组合也就是多角度过滤对象，来达到获取聚合的目的。 使用场景： 创建对象的时候需要将对象插入到数据库之前对对象中的字段进行验证，有的对象需要验证一个字段有的需要验证多个字段，这种情况我们可以通过对过滤器进行组合来实现对某一个对象中的一个或者多个属性达到验证的目的。 可以根据对象对不同对过滤器进行组合实现过滤器的插拔式。 代码走起来： 代码所要实现的场
反射学习
u010855333的博客
12-15 366
public class RefectionClass { // 反射的定义：审查元数据并收集关於它的类型信息的能力,元数据(编辑后的基本数据单元)就是一大堆表，编译器会创建一个类定义表，一个字段定义表，一个方法定义表等,System.Reflection命名空间包含的几个类，允许你反射(解析)这些元数据的代码 //一、反射的作用： //动态的创建类型的实例,将类型邦定到现
C#中索引器简单使用
u010855333的博客
12-16 355
微软官方描述：索引器允许类或结构的实例就像数组一样进行索引。索引器形态类似于，不同之处在于它们的取值函数采用参数。 通俗理解：索引器（Indexer） 允许一个对象可以像数组一样被索引。当您为类定义一个索引器时，该类的行为就会像一个 虚拟数组（virtual array） 一样。您可以使用数组访问运算符（[ ]）来访问该类的实例。 索引的代码结构接近与类的属性定义，都是通过get和set来进行相
C#入门
u010855333的博客
10-03 325
重新学习C#入门知识，将C#语言和.Net的关系以及C#的范围和用途作出一个整理，首先，本文的水平不高，只是用于记录知识点。 C#语言不能独立单独使用，必须和.Netfromwork一起，C#编译器专门用于.NET，这表示C#语言的所有代码都是运行在.Netfromwork上，之前对于C#的理解是一门和JAva，C，C++等级的，但但实际上可以说如此但也不是如此，Java在跨平台上确实要做的比C#好
ManualResetEven小知识点
u010855333的博客
06-02 302
关于ManualResetEven简单用法： 一、构造函数 // 摘要: //用一个指示是否将初始状态设置为终止的布尔值初始化 System.Threading.ManualResetEvent 类的新实例。 // 参数: // initialState: // 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 public Man
设计模式——原型模式
u010855333的博客
07-30 259
原型模式可以动态的创建一个对象而不需要提供专门的new()操作，这无疑是一种非常有效的方式，快速的创建一个新的对象。 一、使用场景： 1、如果说我们的对象类型不是刚开始就能确定，而是这个类型是在运行期确定的话，那么我们通过这个类型的对象克隆出一个新的类型更容易。 2、获取某一个特定状态下的对象，这个前提很重要，这点怎么理解呢，例如有的时候我们需要对比一个对象经过处理后的状态和处理前的状
设计模式——策略模式
u010855333的博客
08-09 254
策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得可以根据具体场景来使用不同算法。策略模式使得算法可以在不影响到客户端的情况下发生变化。 在软件开发中也常常遇到类似的情况，实现某一个功能有多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。如查找、排序等，一种常用的方法是硬编码(Hard Coding)在一个类中，
Java面试：设计模式详解——单例、工厂、抽象工厂与代理模式
"本文主要介绍了Java面试中常见的几种设计模式，包括单例模式、工厂模式、抽象工厂模式、代理模式以及MVC模式，并通过实际例子帮助理解这些模式的原理和应用。" ### 单例模式 单例模式是一种限制类只能拥有一个实例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值