.NET垃圾回收器是否回收曾被静态引用的实例？缓存实现疑问

我实现了SampleClass实例的缓存逻辑，该类初始化耗时较长，缓存上限由CacheCapacity控制，避免重复创建实例。由于ActiveSamples_是静态字段，被它引用的缓存实例不会被GC回收，这是预期行为。我原本认为，当通过ClearCache()或ShrinkCacheTo()将ActiveSamples_设为null或替换为不包含这些实例的新列表（且无其他引用）时，这些实例会成为垃圾被GC回收。但同事在排查内存泄漏时看到相关文章指出，曾被静态对象引用的实例永远无法被托管代码回收，现产生以下疑问：

• 静态字段的原引用实例永久脱离GC管辖，必须手动释放？
• 一旦静态字段对对象的引用失效，GC会在合适时机自动回收？

若选项1正确，该如何释放这些实例？

实现代码 #

public class SampleClass
{
    #region Statics
    public static int CacheCapacity
    {
        get => CacheCapacity_;
        set
        {
            int val = value < 0 ? 0 : value;
            if(ActiveSamples_ != null)
            {
                if(val == 0)
                {
                    ClearCache();
                    CacheCapacity_ = 0;
                    return;
                }
                if (val < ActiveSamples_.Count)
                {
                    ShrinkCacheTo((int)(0.8D * val));
                }
            }
            
            CacheCapacity_ = val;
        }
    }
    static int CacheCapacity_;
    protected static List<SampleClass> ActiveSamples
    {
        get
        {
            if(ActiveSamples_ == null)
                ActiveSamples_ = new List<SampleClass>();
            return ActiveSamples; // 此处存在递归调用问题，应返回ActiveSamples_
        }
    }
    protected static List<SampleClass> ActiveSamples_;

    public static bool AddToCache(SampleClass instance)
    {
        if(CacheCapacity == 0)
            return false;
        if (ActiveSamples.Count >= CacheCapacity)
            ShrinkCacheTo((int)(0.8D * CacheCapacity));
        ActiveSamples.Add(instance);
        return true;
    }

    public static void ClearCache()
    {
        ActiveSamples_ = null;
    }

    protected static void ShrinkCacheTo(int size)
    {
        if (ActiveSamples_ == null)
            return;
        if (ActiveSamples_.Count <= size)
            return;
        List<SampleClass> tmp = new List<SampleClass>(size);
        for (int i = ActiveSamples_.Count-size; i < ActiveSamples_.Count; i++)
        {
            tmp.Add(ActiveSamples_[i]);
        }
        ActiveSamples_ = tmp;
    }
    #endregion

    #region Constructors and Instance getters

    public SampleClass(string instanceID)
    {
        InstanceID = instanceID;
        // time-consuming initialisation ...
        AddToCache(this);
    }
    public static SampleClass GetOrCreateInstance(string instanceID)
    {
        var result = ActiveSamples.Find(x => x?.InstanceID == instanceID);
        if (result == null)
            result = new SampleClass(instanceID);
        return result;
    }
    #endregion

    #region Instance members
    public string InstanceID { get; protected set; }
    public bool IsCached => ActiveSamples.Find(x => x?.InstanceID == InstanceID) == this;
    #endregion

}

解答 #

1. 选项2完全正确：.NET的GC回收机制只判断对象是否存在可达的引用链——只要对象不再被任何存活的根对象（静态字段、栈上变量、CPU寄存器中的引用等）或由根对象可达的对象引用，GC就会在合适的时机自动回收它，和该对象是否曾经被静态字段引用过没有任何关系。所谓“曾被静态对象引用的实例永远无法回收”是错误的结论。

2. 你的现有实现逻辑本身是符合GC回收规则的：

   • ClearCache()将ActiveSamples_设为null，直接切断了静态字段对所有缓存实例的引用；
   • ShrinkCacheTo()用新的列表替换旧列表，旧列表中被排除的实例会失去静态字段的引用；
     只要这些实例没有被其他地方（比如外部变量、事件订阅、其他集合）持有，GC就会正常回收它们。

3. 针对代码的优化建议：

   • 修复ActiveSamples属性的递归问题：在getter中应该返回ActiveSamples_而非ActiveSamples，否则会导致无限递归调用，引发栈溢出异常；
   • 优化IsCached属性：当前每次调用都执行List.Find()遍历整个集合，性能极低。建议在实例加入缓存时标记一个私有字段（如private bool _isCached），在缓存收缩或清空时更新该字段，IsCached直接返回这个字段的值即可；
   • 提升查找效率：GetOrCreateInstance中用List.Find()查找实例的时间复杂度是O(n)，当缓存量大时性能很差。建议将缓存容器从List<SampleClass>改为Dictionary<string, SampleClass>，利用字典的O(1)查找特性提升性能；
   • 线程安全：当前实现完全没有考虑线程安全，多线程环境下调用会出现竞态条件（比如同时修改缓存、创建实例），如果需要在多线程场景使用，需要添加锁机制（如lock）保护静态字段的访问和修改。

内容的提问来源于stack exchange，提问作者SDG