您现在的位置：程式碼之家 >> 編程語言 > >> .NET 網頁程式設計 >> C# >> 關於C#

專案核心算法：C# 通用資源池實現與最佳實踐

編輯：關於C#

前言

在高併發、資源昂貴（資料庫連線、Socket、大型物件、硬體句柄）的系統中，資源池模式是提升吞吐量、降低延遲、防止資源耗盡的關鍵基礎設施。本文呈現一個生產級、執行緒安全、支援泛型的 ResourcePool<T> 實現，涵蓋單例模式、資源生命週期管理、最大容量控制與溢出淘汰、IDisposable 模式正確實現等核心要素。

一、設計目標與介面契約

1. IResourceProvider<T>：資源工廠介面


public interface IResourceProvider<T> where T : class, IDisposable
{
    /// 建立新資源實例
    T Request();

    /// 銷毀資源實例（歸還池時超過上限、或池銷毀時調用）
    void Dispose(T resource);
}

2. ResourceTag<T>：資源標記（內部類）


internal class ResourceTag<T>
{
    public T Resource { get; set; }
    public bool InUse { get; set; }
    public ResourceTag(T resource, bool inUse) { Resource = resource; InUse = inUse; }
}

二、 ResourcePool<T> 核心實現


public class ResourcePool<T> : IDisposable where T : class, IDisposable
{
    #region 單例模式（雙重檢查鎖定）
    private static ResourcePool<T> _instance;
    private static readonly object _singletonLock = new object();

    public static ResourcePool<T> Instance(IResourceProvider<T> provider, int maxResource)
    {
        if (_instance == null)
        {
            lock (_singletonLock)
            {
                if (_instance == null)
                    _instance = new ResourcePool<T>(provider, maxResource);
            }
        }
        return _instance;
    }
    #endregion

    private readonly IResourceProvider<T> _provider;
    private readonly int _maxResource;
    private readonly Dictionary<long, ResourceTag<T>> _resources = new Dictionary<long, ResourceTag<T>>();
    private readonly object _acquireLock = new object();
    private readonly object _releaseLock = new object();
    private bool _disposed;

    private ResourcePool(IResourceProvider<T> provider, int maxResource)
    {
        _provider = provider ?? throw new ArgumentNullException(nameof(provider));
        _maxResource = maxResource > 0 ? maxResource : throw new ArgumentOutOfRangeException(nameof(maxResource));
    }

    public int ResourceCount => _resources.Count;

    #region 核心：取得資源
    public T GetResource(out long resourceId)
    {
        return AcquireResource(out resourceId);
    }

    private T AcquireResource(out long resourceId)
    {
        lock (_acquireLock)
        {
            // 1. 尋找閒置資源
            foreach (var kvp in _resources)
            {
                if (!kvp.Value.InUse)
                {
                    kvp.Value.InUse = true;
                    resourceId = kvp.Key;
                    return kvp.Value.Resource;
                }
            }

            // 2. 建立新資源
            T newResource = _provider.Request();
            if (newResource == null)
            {
                resourceId = -1;
                return null;
            }

            var tag = new ResourceTag<T>(newResource, true);
            long newId = GenerateResourceId();
            _resources.Add(newId, tag);
            resourceId = newId;
            return newResource;
        }
    }

    private long GenerateResourceId() => DateTime.UtcNow.Ticks; // 簡單唯一 ID 生成策略
    #endregion

    #region 核心：歸還資源
    public void ReturnResource(ref T resource, long resourceId)
    {
        if (!_resources.ContainsKey(resourceId))
            throw new InvalidOperationException("嘗試歸還非法資源 ID。");

        ReleaseResource(ref resource, resourceId);
    }

    private void ReleaseResource(ref T resource, long resourceId)
    {
        T toDispose = null;
        lock (_releaseLock)
        {
            var tag = _resources[resourceId];
            tag.InUse = false;
            _resources.Remove(resourceId); // 當前 ID 失效，防止重複歸還
            resource = null;               // 強制呼叫端引用失效

            // 容量控制：若池中資源數達上限，銷毀剛歸還的資源；否則重新放入池中（新 ID）
            if (_resources.Count >= _maxResource)
            {
                toDispose = tag.Resource;
            }
            else
            {
                _resources.Add(GenerateResourceId(), tag);
            }
        }

        // 鎖外銷毀，避免長時間持有鎖
        if (toDispose != null)
            _provider.Dispose(toDispose);
    }
    #endregion

    #region IDisposable 標準模式
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;

        if (disposing)
        {
            // 釋放所有托管資源
            foreach (var kvp in _resources)
            {
                try { kvp.Value.Resource?.Dispose(); } catch { /* 忽略銷毀異常 */ }
            }
            _resources.Clear();

            // 釋放同步物件引用
            _provider = null; // 注意：介面不可為 null，此處僅示意，實際應謹慎處理
        }

        _disposed = true;
    }

    ~ResourcePool() => Dispose(false);
    #endregion
}

三、使用範例：SqlConnection 池化


// 1. 實作 Provider
public class SqlConnectionProvider : IResourceProvider<SqlConnection>
{
    private readonly string _connStr;
    public SqlConnectionProvider(string connStr) => _connStr = connStr;

    public SqlConnection Request()
    {
        var conn = new SqlConnection(_connStr);
        conn.Open(); // 池要求資源取得時即為可用狀態
        return conn;
    }

    public void Dispose(SqlConnection conn) => conn?.Dispose();
}

// 2. 單元測試 / 使用示範
[TestFixture]
public class ResourcePoolTests
{
    [Test]
    public void TestPoolBasic()
    {
        var pool = ResourcePool<SqlConnection>.Instance(new SqlConnectionProvider("connStr"), 10);

        long id;
        SqlConnection conn = pool.GetResource(out id);
        Assert.IsNotNull(conn);

        // 使用 conn 執行命令...

        pool.ReturnResource(ref conn, id);
        Assert.IsNull(conn); // 歸還後引用被清空
    }

    [Test]
    public void TestPoolConcurrency()
    {
        var pool = ResourcePool<SqlConnection>.Instance(new SqlConnectionProvider("connStr"), 5);
        const int threads = 20;
        var tasks = new Task[threads];

        for (int i = 0; i < threads; i++)
        {
            tasks[i] = Task.Run(() =>
            {
                long id;
                var c = pool.GetResource(out id);
                if (c != null)
                {
                    Thread.Sleep(10); // 模擬工作
                    pool.ReturnResource(ref c, id);
                }
            });
        }
        Task.WaitAll(tasks);
        Assert.AreEqual(5, pool.ResourceCount); // 最大不超過上限
    }
}

四、關鍵設計決策解析

決策點	方案	理由
單例模式	雙重檢查鎖定 + 靜態 Instance 方法	確保進程內單一池實例，避免重複建立連線池；支援延遲初始化與參數化建構。
執行緒安全	取得/歸還分別獨立鎖 + 細粒度鎖範圍	讀寫分離鎖降低爭用；銷毀操作移出鎖外避免死鎖風險。
資源 ID 機制	Ticks 長整數 + 歸還時移除舊 ID 重新分配	防止 ID 重複使用攻擊；歸還後原引用失效，強制呼叫端重新申請。
容量控制策略	歸還時若達上限則銷毀，否則放回池	簡單有效的「最近最少使用」近似策略；避免無限增長導致記憶體壓力。
IDisposable 模式	標準 Dispose(bool) + 終結器 + GC.SuppressFinalize	確保托管/非托管資源確定性釋放，防止最終化器阻塞。
Provider 分離	IResourceProvider 介面	解耦資源建構邏輯（連線字串、Socket 參數等），池本身純粹管理生命週期。