如何在 C# 中刷新单例

Question

我有从 DB 获取的单例，因此负载很昂贵。 它是延迟加载的。

我想创建一个方法来刷新该单例并在需要时填充它。

数据是数据库并且非常昂贵，所以我只想刷新一次，以防我有并发调用。 （也就是说，如果我收到 500 次刷新调用，我只想重新开始刷新一次）

public static PageData Instance
    {
        get
        {
            if (m_Instance == null)
            {
                lock (instanceLock)
                {
                    if (m_Instance == null)
                    {
                        m_Instance = new PageData();
                    }
                }
            }
            return m_Instance;
        }
    }


public void ReSync()
        {                         
            lock (instanceLock)
            {
                /* Setting to null to force the Instance to re-build */
                m_Instance = null;
                PageData pData = Instance;
            }
        }

谢谢

Answer 1

这有点不正确，你的

if (m_Instance == null)

应该真的在锁的内侧。

抱歉，没发现。

如果您已经在刷新，没有任何内置功能可以让其他客户端静默放弃呼叫。我认为超时会产生异常。也许维护一个陈旧的 DateTime，您可以检查它以避免对排队的调用者进行刷新。

Answer 2

据我了解，这应该可行。

这是我的代码：

private static instanceLock = new object();
private static _refreshing = true;

public static PageData Instance
    {
        get
        {
            if (_refreshing)
            {
                lock (instanceLock)
                {
                    if (_refreshing)
                    {
                        m_Instance = new PageData();
                        _refreshing = false; //now allow next refreshes.
                    }
                }
            }
            return m_Instance;
        }
    }


public void ReSync()
        {
            if (!_refreshing)                         
                lock (instanceLock)
                {
                    if (!_refreshing)
                    {
                        _refreshing = true; //don't allow refresh until singleton is called.
                    }
                }
        }

Answer 3

除了 double-checked locking 被破坏（更正，显然是 it does work 但我仍然觉得它不是特别漂亮），如果你对 m_Instance 有写访问权，为什么不把它设置为 new PageData() 那里然后在 ReSync ?

Answer 4

如果您包含一个“lastRefreshed”成员，您在刷新时也检查并锁定该成员怎么样。那么如果最后一次刷新发生在 X 时间内，就不会再次发生？

Answer 5

据我了解，您希望并发调用 Resync 方法？如果您在来自客户的 500 个请求中只调用一次，这真的不应该发生。尽管如此，也许最好不要只锁定instanceLock，因为那样单例无论如何都会被重新实例化多次，只是不会在“同一”时间。

public void ReSync()
{
  if (!m_IsResyncing)
  {
    lock (m_resyncLock)
    {
      if (!m_IsResyncing)
      {
        m_IsResyncing = true;
        Thread.Sleep(100); // sleep for 100ms to accumulate other locks
        // reinitialize here
        m_IsResyncing = false;
      }
    }
  }
}

Answer 6

如果你希望它符合 ECMA 内存模型，我想实现应该是这样的（假设 m_Instance 不是易失性的）：

public static PageData Instance
{
    get
    {
        PageData instance = Thread.VolatileRead(ref m_Instance);
        if (instance == null)
        {
            lock (instanceLock)
            {
                instance = Thread.VolatileRead(ref m_Instance);
                if (instance == null)
                {
                    instance = new PageData();
                    Thread.VolatileWrite(ref m_Instance, instance);
                }
            }
        }

        return instance;
    }
}

public void ReSync()
{
    /* Setting to null to force the Instance to re-build */
    Thread.VolatileWrite(ref m_Instance, null);
    PageData pData = Instance;
}

如果您将m_Instance 定义为易失性，则只有一个主要区别。在进行空检查之前，需要将m_Instance 读取到局部变量，因为ReSync() 方法可能会将共享变量设置为空。我还从ReSync() 中删除了锁，因为它并不是真正需要的。初始化新实例的竞赛是安全的。

Answer 7

我可能需要更好地了解并发性是如何产生的。您的描述似乎适合 System.Cashing 命名空间的范围。您告诉对象应该将其信息存储一段时间（那里有一些选项可用）。

如果下一个请求与上一个兑现的请求相同（您自己定义“相同”的标准），则调用者将获得缓存的副本。实际上，这意味着没有新的数据库连接。只是一个内存请求。如果有效的缓存条件已经过去，即 30 分钟），则下一个请求将针对数据库（再持续一段时间）。

需要内存，但速度极快，建议在重复使用数据的场景中使用。