2

我们正在使用内存数据库Exasol，它确实提供了一个 Ado.Net 提供程序，但它似乎缺少一些重要的功能，例如ConnectionPooling，因此每个连接都是根据请求创建和销毁的，这会影响我们的性能，因为我们正在连接到上的托管数据库AWS。我创建了一个简单的ConnectionPool，有能力的Resize，请建议这是否可以达到目的，或者我需要做更多的事情。

请注意，我不是在寻找代码审查，而是对我在当前实现中可能缺少的内容进行批判性分析，如果有可用的实现（Nuget，Git），我可以重用。目前我正在根据大小调整大小，如何根据时间实现相同的大小，在一定的空闲时间里，应该从队列中清除少量资源，从而减小大小。

重要细节：

  1. 在ConcurrentQueue内部用于从多个客户端对资源的线程安全访问
  2. 如果池为空，则用于AutoResetEvent等待并发出信号

  3. 用于TPL调整大小操作，而不停止调用代码，我的理解是即使在客户端调用返回时这项工作，因为它在Threadpool thread

    class ExasolConnectionPool
{
    /// <summary>
    /// Thread safe queue for storing the connection objects
    /// </summary>
    private ConcurrentQueue<EXAConnection> ExasolConnectionQueue { get; set; }

    /// <summary>
    /// Number of connections on the Connection pool
    /// </summary>
    private int _connectionCount;

    /// <summary>
    /// Max Pool Size
    /// </summary>
    private int MaxPoolSize { get; set; }

    /// <summary>
    /// Min Pool Size
    /// </summary>
    private int MinPoolSize { get; set; }

    /// <summary>
    /// Increase in Pool Size
    /// </summary>
    private int IncreasePoolSize { get; set; }

    /// <summary>
    /// Decrease in Pool Size
    /// </summary>
    private int DecreasePoolSize { get; set; }

    /// <summary>
    /// Connection string for the Connection pool connections
    /// </summary>
    private string ConnectionString { get; set; }

    /// <summary>
    /// Auto Reset event for the connection pool
    /// </summary>
    private AutoResetEvent ExasolConnectionPoolAre { get; set; }

    /// <summary>
    /// Connection pool specific Lock object
    /// </summary>
    private readonly object lockObject;

    /// <summary>
    /// Connection pool constructor
    /// </summary>
    /// <param name="connectionString"></param>
    /// <param name="poolSize"></param>
    public ExasolConnectionPool(string connectionString, int poolSize = 10)
    {
        // Set the Connection String
        ConnectionString = connectionString;

        // Intialize the Connection Queue
        ExasolConnectionQueue = new ConcurrentQueue<EXAConnection>();

        // Enqueue initial set of connections
        for (int counter = 0; counter < poolSize; counter++)
        {
            var exaConnection = new EXAConnection {ConnectionString = ConnectionString};

            ExasolConnectionQueue.Enqueue(exaConnection);
        }

        // Initialize Lock object 
        lockObject = new object();

        // Set the Connection queue count
        _connectionCount = poolSize;

        // Max pool size
        MaxPoolSize = poolSize;

        // Min Pool Size
        MinPoolSize = 2;

        IncreasePoolSize = 5;

        DecreasePoolSize = 3;

        ExasolConnectionPoolAre = new AutoResetEvent(false);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    public EXAConnection GetConnection()
    {
        // Return ExaConnection object
        EXAConnection returnConnection;

        // Try Dequeue the connection object from the Concurrent Queue
        var validExasolConnection = ExasolConnectionQueue.TryDequeue(out returnConnection);

        // If No Valid connection is available, then wait using AutoReset signaling mechanism
        while (!validExasolConnection)
        {
            ExasolConnectionPoolAre.WaitOne();

            validExasolConnection = ExasolConnectionQueue.TryDequeue(out returnConnection);
        }

        // Thread safe connection count update
        Interlocked.Decrement(ref _connectionCount);

        Task.Factory.StartNew(() =>
        {
            lock (lockObject)
            {
                if (_connectionCount > MinPoolSize) return;

                for (var counter = 0; counter < IncreasePoolSize; counter++)
                {
                    var exaConnection = new EXAConnection {ConnectionString = ConnectionString};

                    ExasolConnectionQueue.Enqueue(exaConnection);

                    Interlocked.Increment(ref _connectionCount);
                }
            }
        });

        return (returnConnection);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="returnedConnection"></param>
    public void ReturnConnection(EXAConnection returnedConnection)
    {
        ExasolConnectionQueue.Enqueue(returnedConnection);

        Interlocked.Increment(ref _connectionCount);

        ExasolConnectionPoolAre.Set();

        Task.Factory.StartNew(() =>
        {
            lock (lockObject)
            {
                if (_connectionCount < MaxPoolSize * 1.5) return;

                for (var counter = 0; counter < DecreasePoolSize; counter++)
                {
                    EXAConnection exaConnection;

                    if (ExasolConnectionQueue.TryDequeue(out exaConnection))
                    {
                        exaConnection.Dispose();

                        exaConnection = null;

                        Interlocked.Decrement(ref _connectionCount);
                    }
                }
            }
        });
    }
}
4

1 回答 1

1

您的游泳池的实施很好。我不知道有任何 NuGet 实现那么小并且对于您的情况并不过分复杂。我只是想添加一些您可以自己调查的建议。

  1. StartNew是 Stephen Cleary 的危险文章是关于您用于调整逻辑大小的方法的精彩文章。最重要的部分是：

    线程“A”将在当前正在TaskScheduler执行的任何东西上运行！

    因此，您的代码有时可能会使用UI线程上下文并降低应用程序的性能。如果对您来说没问题（例如对于 ASP.NET 应用程序），那很好，但如果不是，我建议您改用该Task.Run方法。您还可以查看关于TPL最佳实践的 Stephen 的博客。

  2. 一般来说，调整大小的逻辑是通过简单的方式完成的，将大小加倍，所以如果你达到了极限，大小就会变成原来的两倍，反之亦然。我认为为用户提供管理此常量的能力可能会导致一些奇怪的错误，例如负池大小等。

    所以你应该做你的属性设置器private，对于我来说，删除有关调整大小的属性。也许将来您可以为您的应用程序收集平均池大小的统计信息，并将该参数用作默认值。

于 2016-09-08T17:23:03.473 回答