设计模式学习笔记之单例模式

目录

概述

单例模式，也叫单件模式；在核心结构中只包含一个实例，在运行时只会生成一个实例的类。
通过使用单例模式可以保存在系统运行时只产生一个实例，这个实例提供外界的访问方式；使用单例模式可以减少系统资源的开销和对实例个数的管理。
如果希望在运行过程中只产生一个实例刚使用单例模式来定义这个类是一个不错的选择。

定义

单件模式确保一个类只有一个实例，并提供一个全局访问点

实例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Log.MiddleWare.Message
{
    /// <summary>
    /// 文本消息队列处理类
    /// </summary>
    public class MessageQueue
    {
        private Queue<string> _queue = null;
        private static MessageQueue _messageQueue = null;
        private MessageQueue()
        {
        }


        #region 属性
        /// <summary>
        /// 获取消息队列
        /// </summary>
        private Queue<string> GetQueue
        {
            get
            {
                if (_queue == null)
                {
                    _queue = new Queue<string>();
                }
                return _queue;
            }
        }

        /// <summary>
        /// 获取消息队列长度
        /// </summary>
        public long Count
        {
            get { return GetQueue.Count; }
        }
        #endregion

        #region 方法

        /// <summary>
        /// 添加消息
        /// </summary>
        /// <param name="message">需要添加的消息文本</param>
        public void AddMessage(string message)
        {
            GetQueue.Enqueue(message);
        }

        /// <summary>
        /// 获取消息
        /// </summary>
        /// <returns></returns>
        public string GetMessage()
        {
            return GetQueue.Dequeue();
        }

        /// <summary>
        /// 获取类对象
        /// </summary>
        /// <returns></returns>
        public static MessageQueue GetMessageQueue()
        {
            return _messageQueue ?? new MessageQueue();
        }

        #endregion
    }
}

源地址引用：
单件模式实例地址

模式原理

单件模式原理非常简单，可以说是设计模式中简单程度排前几的吧；模式首先将构造函数私有化，防止其它的类进行实例，然后通过提供公共的静态方法来实例化自己，在这个静态方法内进行判断实例化对象是否存在，如果存在则直接使用已存在的对象，如果不存在则实例化对象；

模式写法

单件模式一般的定义格式如下：

写法一：
这样写线程会不安全

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
    }
}

写法二：
线程安全

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

写法三：
双重锁，这个用在多线程还是比较安全的

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
    if (singleton == null) {
        Lock (Singleton.class) {
        if (singleton == null) {
            singleton = new Singleton();
        }
        }
    }
    return singleton;
    }
}