多线程应用程序中的单例类，锁定建议

Question

我有在多个线程中共享的单例类。为了防止多重访问问题，我在访问类的一个或另一个属性时使用 Lock 方法。问题是是否可以改进代码并将 Lock 方法放入单例类中，而不是每次在代码中访问类属性时都将其放入？

/* Class code*/
   public class ServerStatus
    {


        private static ServerStatus _instance;
        public static ServerStatus Instance
        {
            get { return _instance ?? (_instance = new ServerStatus()); }
            set { _instance = value; }
        }

        ServerStatus()
        {
            PistonCount = 0;
            PistonQueue = new List<string>();
            ErrorList = new List<string>();
        }




        public int PistonCount { get; set; }

        public List<string> PistonQueue { get; set; }

        public List<string> ErrorList { get; set; }
    }



 /*Code for accessing class properties*/
private static readonly object Locker = new object();    
/*Skip*/

lock (Locker)
{
 ServerStatus.Instance.PistonQueue.Add(e.FullPath);
}
    /*Skip*/

lock (Locker)
{
    ServerStatus.Instance.PistonCount++;
}

Answer 1

ServerStatus 应该维护自己的同步，而不是此类的外部客户端。话虽这么说，您需要重构 ServerStatus 并创建一些线程安全（带锁定）的方法：

删除这些属性： public List;活塞队列 { 得到;放; } 因为即使您可以锁定这些属性，您也无法控制客户端在获取实际的 PistonQueue 后执行的操作。

...并替换为以下方法（抱歉伪代码，我今天懒得去思考）：

public PistonQueueAdd(string fullPath)
{
    lock(_serverStatusSyncRoot)
    {
        // ...
    }
}

Answer 2

如果您感兴趣的话，这是我使用的单例线程安全模式：

    public class DataAccess
{
    #region Singleton

    private static readonly object m_SyncRoot = new Object();

    private static volatile DataAccess m_SingleInstance;

    public static DataAccess Instance
    {
        get
        {
            if (m_SingleInstance == null)
            {
                lock (m_SyncRoot)
                {
                    if (m_SingleInstance == null)
                        m_SingleInstance = new DataAccess();
                }
            }

            return m_SingleInstance;
        }
    }

    private DataAccess()
    {
    }

    #endregion
}

Answer 3

恕我直言，这是单例中线程安全锁定的最终解决方案。来自它（列表中的第五个）：

public sealed class Singleton
{
    private Singleton()
    {
    }

    public static Singleton Instance { get { return Nested.instance; } }

    private class Nested
    {
        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static Nested()
        {
        }

        internal static readonly Singleton instance = new Singleton();
    }
}

Answer 4

这是相当常见的。与每个属性访问上的外部锁相比，在 getter/setter 中锁定/解锁更安全（您不能忘记这样做），也更方便（该锁不必在您使用该属性的任何地方都可以直接访问） 。

平均值，
马丁