• 有唯一实例

    单例模式 - 搜狗百科 https://baike.sogou.com/v7811899.htm

    单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例
     
    中文名
    单例模式
    外文名
    Singleton pattern
    类    别
    设计模式
    解    释
    常用的软件设计模式

    目录

    1. 1 定义
    2. 2 简介
    3. 3 动机
    1. 4 要点
    2. 5 优缺点
    3. ▪ 优点
    1. ▪ 缺点
    2. 6 实例

    定义

    编辑
    数学与逻辑学中，singleton定义为“有且仅有一个元素的集合”。
    单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”
    Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”
    Java单例模式例子
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class Singleton {
        private Singleton(){
        }
        private static volatile Singleton instance = null;
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized(Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

    简介

    编辑
    单例模式的静态结构图单例模式的静态结构图 [1]
    单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。 [2] 
    Static uniqueInstance是singleton的唯一实例, static sharedInstance将把它返回客户端。通常，sharedInstance会检查uniqueInstance是否已经被实例化。如果没有，它会生成一个实例然后返回uniqueInstance。 [2] 

    动机

    编辑
    对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。 [3] 
    如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。 [3] 

    要点

    编辑
    显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
    从具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。
    在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。
    一些资源管理器常常设计成单例模式。
    在计算机系统中，需要管理的资源包括软件外部资源，譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler， 以避免两个打印作业同时输出到打印机中。每台计算机可以有若干传真卡，但是只应该有一个软件负责管理传真卡，以避免出现两份传真作业同时传到传真卡中的情况。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。
    需要管理的资源包括软件内部资源，譬如，大多数的软件都有一个（甚至多个）属性（properties）文件存放系统配置。这样的系统应当由一个对象来管理一个属性文件。
    需要管理的软件内部资源也包括譬如负责记录网站来访人数的部件，记录软件系统内部事件、出错信息的部件，或是对系统的表现进行检查的部件等。这些部件都必须集中管理，不可整出多头。
    这些资源管理器构件必须只有一个实例，这是其一；它们必须自行初始化，这是其二；允许整个系统访问自己这是其三。因此，它们都满足单例模式的条件，是单例模式的应用。

    优缺点

    编辑

    优点

    一、实例控制
    单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
    二、灵活性
    因为类控制了实例化过程，所以类可以灵活更改实例化过程。

    缺点

    一、开销
    虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
    二、可能的开发混淆
    使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
    三、对象生存期
    不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。。

    实例

    编辑
    Java
    当一个类的实例可以有且只可以一个的时候就需要用到了。为什么只需要有一个呢？有人说是为了节约内存，但这只是单例模式带来的一个好处。只有一个实例确实减少内存占用，可是我认为这不是使用单例模式的理由。我认为使用单例模式的时机是当实例存在多个会引起程序逻辑错误的时候。比如类似有序的号码生成器这样的东西，怎么可以允许一个应用上存在多个呢？
    Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
    一般Singleton模式通常有三种形式:
    第一种形式:懒汉式，也是常用的形式。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class SingletonClass{
        private static SingletonClass instance=null;
        public static　synchronized　SingletonClass getInstance(){
            if(instance==null){
                   instance=new SingletonClass();
            }
            return instance;
        }
        private SingletonClass(){
        }
    }
    第二种形式:饿汉式
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //对第一行static的一些解释
    // java允许我们在一个类里面定义静态类。比如内部类（nested class）。
    //把nested class封闭起来的类叫外部类。
    //在java中，我们不能用static修饰顶级类（top level class）。
    //只有内部类可以为static。
    public class Singleton{
        //在自己内部定义自己的一个实例，只供内部调用
        private static final Singleton instance = new Singleton();
        private Singleton(){
            //do something
        }
        //这里提供了一个供外部访问本class的静态方法，可以直接访问
        public static Singleton getInstance(){
            return instance;
        }
    }
    第三种形式: 双重锁的形式。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class Singleton{
        private static volatile Singleton instance=null;
        private Singleton(){
            //do something
        }
        public static  Singleton getInstance(){
            if(instance==null){
                synchronized(Singleton.class){
                    if(instance==null){
                        instance=new Singleton();
                    }
                }
            }
            return instance;
         }
    }
    //这个模式将同步内容下放到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。
    //这种模式中双重判断加同步的方式，比第一个例子中的效率大大提升，因为如果单层if判断，在服务器允许的情况下，
    //假设有一百个线程，耗费的时间为100*（同步判断时间+if判断时间），而如果双重if判断，100的线程可以同时if判断，理论消耗的时间只有一个if判断的时间。
    //所以如果面对高并发的情况，而且采用的是懒汉模式，最好的选择就是双重判断加同步的方式。
    Flex
    Flex中单例模式,常见的model层实例:
    package models
    {
    import flash.events.EventDispatcher;
    import mx.collections.ArrayCollection;
    import vo.articlesVO;
    import vo.linksVO;
    [Bindable]
    public class ModelLocator extends EventDispatcher
    {
    public static var _instance:ModelLocator;
    public static function getInstance():ModelLocator{
    if(_instance == null){
    _instance = new ModelLocator();
    }
    return _instance;
    }
    public var total:int;
    public var isLogin:Boolean = false;
    public var articles:ArrayCollection;
    public var selectedArticle:articlesVO;
    public var categories:ArrayCollection;
    public var links:ArrayCollection;
    public var selectedLink:linksVO;
    }
    }
    类中自己完成了自身的实例。。
    <mx:Script>
    <![CDATA[
    import models.ModelLocator;
    internal function initApp():void{
    var instance:ModelLocator = ModelLocator.getInstance();
    trace(instance.isLogin);//获得isLogin
    }
    ]]>
    </mx:Script>
    C#
    保证一个类仅有一个实例，并提供一个访问它的全局访问点
    实现要点
    Singleton模式是限制而不是改进类的创建。
    Singleton类中的实例构造器可以设置为Protected以允许子类派生。
    Singleton模式一般不要支持Icloneable接口，因为这可能导致多个对象实例，与Singleton模式的初衷违背。
    Singleton模式一般不要支持序列化，这也有可能导致多个对象实例，这也与Singleton模式的初衷违背。
    Singleton只考虑了对象创建的管理，没有考虑到销毁的管理，就支持垃圾回收的平台和对象的开销来讲，我们一般没必要对其销毁进行特殊的管理。
    理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的构造器的任意调用”。
    可以很简单的修改一个Singleton，使它有少数几个实例，这样做是允许的而且是有意义的。
    优点
    实例控制：Singleton 会阻止其他对象实例化其自己的 Singleton 对象的副本，从而确保所有对象都访问唯一实例
    灵活性：因为类控制了实例化过程，所以类可以更加灵活修改实例化过程
    缺点
    开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题，上面的五种实现方式中已经说过了。
    可能的开发混淆：使用 singleton 对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用 new 关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
    对象的生存期：Singleton 不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于 .NET Framework 的语言），只有 Singleton 类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除
    对象实例，但这样会导致 Singleton 类中出现悬浮引用。
    适用性
    当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
    当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
    代码示例：
    双重锁机制
    namespace Singleton
    　　{
    　　public class Singleton
    　　{
    　　//定义一个私有的静态全局变量来保存该类的唯一实例
    　　private static Singleton singleton;
    //定义一个只读静态对象
    　　//且这个对象是在程序运行时创建的
    　　private static readonly object syncObject = new object();
    /// <summary>
    　　/// 构造函数必须是私有的
    　　/// 这样在外部便无法使用 new 来创建该类的实例
    　　/// </summary>
    　　private Singleton()
    　　{}
    /// <summary>
    　　/// 定义一个全局访问点
    　　/// 设置为静态方法
    　　/// 则在类的外部便无需实例化就可以调用该方法
    　　/// </summary>
    　　/// <returns></returns>
    　　public static Singleton GetInstance()
    　　{
    　　//这里可以保证只实例化一次
    　　//即在第一次调用时实例化
    　　//以后调用便不会再实例化
    //第一重 singleton == null
    　　if (singleton == null)
    　　{
    　　lock (syncObject)
    　　{
    　　//第二重 singleton == null
    　　if (singleton == null)
    　　{
    　　singleton = new Singleton();
    　　}
    　　}
    　　}
    　　return singleton;
    　　}
    　　}
    　　}
    Javascript
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    var Singleton=(function(){
    var instantiated;
    function init(){
    /*这里定义单例代码*/
    return{
    publicMethod:function(){
    console.log('helloworld');
    },
    publicProperty:'test'
    };
    }
    return{
    getInstance:function(){
    if(!instantiated){
    instantiated=init();
    }
    return instantiated;
    }
    };
    })();
    /*调用公有的方法来获取实例:*/
    Singleton.getInstance().publicMethod();
    PHP
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class test {
        private static $_instance;//保存类实例的私有静态成员变量
        //定义一个私有的构造函数，确保单例类不能通过new关键字实例化，只能被其自身实例化
        private final function __construct() {
            echo 'test __construct';
        }
        //定义私有的__clone()方法，确保单例类不能被复制或克隆
        private function __clone() {}
        public static function getInstance() {
            //检测类是否被实例化
            if ( ! (self::$_instance instanceof self) ) {
                self::$_instance = new test();
            }
            return self::$_instance;
        }
    }
    //调用单例类
    test::getInstance();
    C++
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    class CSingleton /* 懒汉式 */
    { 
    public:
        static CSingleton * GetInstance()
        {       
            if(m_pInstance == NULL) //判断是否第一次调用
                m_pInstance = new CSingleton;
            return m_pInstance;
        }
            void RelaseInstance()
            {
                delete this;
            }
    private:
            CSingleton() //构造函数是私有的
            {
            }
            CSingleton(const CSingleton& that)//拷贝构造函数也应是私有的
            {
             
            }
            ~CSingleton()
            {
                m_pInstance = NULL;
            }
            static CSingleton *m_pInstance;         
    };
    OC
    +(SingalClass*)shareInstance
    {
    //利用GCD创建一个单例模式
    //第一个参数predicate，该参数是检查后面第二个参数所代表的代码块是否被调用的谓词，第二个参数则是在整个应用程序中只会被调用一次的代码块。dispach_once函数中的代码块只会被执行一次，而且还是线程安全的。
    static dispatch_once_t once;
    dispatch_once(&once, ^{
    single=[SingalClass alloc];
    });
    return single;
    }
    Swift (据OC改写)
    class var defaultSingle : SingalClass {
    struct Static {
    static var onceToken : dispatch_once_t = 0
    static var single:SingalClass? = nil
    }
    dispatch_once(&Static.onceToken) {
    // 保证只执行一次 为了线程安全
    if(Static.single == nil) {
    // 第一次执行肯定是空 所以执行判断体 第二次以后就不会执行判断了
    Static.single = SingalClass() // 给结构体里面的single创建对象 使其不为空
    }
    }
    return Static.single!
    }
    Swift (1.2及以后)
    class SwiftySingleton {
    static let shared = SwiftySingleton() // “懒实例化”的全局变量会被自动放在dispatch_once块中 [4] 
    private init(){}
    }
    参考资料
  • 相关阅读:
    k8s之docker被屏蔽后下载方法
    代码合并工具Beyond Compare的使用技巧
    （转）设计模式——观察者模式
    notepad问题汇总
    个人构建问题
    内部git常用总结
    （转）动态规划算法—买卖股票的最佳时机系列
    （转）java中引用传递和值传递
    互联网面试题
    （转）UML类图与类的关系详解
  • 原文地址：https://www.cnblogs.com/rsapaper/p/9714196.html
Copyright © 2020-2023  润新知