连接池 – 一个进程 – 多个线程

Question

我对连接池的理解是；如果connectionstring完全相同，那么我们重用该连接，而不是建立新的连接。

我的问题是，我正在为并行处理创建许多线程。在这个“虚拟”程序中，我创建了500个线程，并让线程池函数处理这些线程。

步骤是：

> < li>

每个线程在SQL中创建一个更新表。(说明更新的时间戳)

然后线程Hibernate1到10秒（随机）。

最后，线程在 SQL 中进行另一次更新（说明结束时间的时间戳）

然后线程退出

class Program
{
    static void Main(string[] args)
    {
        int numberOfThreads = 150;

        ThreadPool.SetMinThreads(numberOfThreads, numberOfThreads);
        ThreadPool.SetMaxThreads(numberOfThreads, numberOfThreads);

        List<Int64> chunkList = new List<Int64>();

        int maxNumberOfChunks = 500;
        for (int i = 1; i < maxNumberOfChunks; i++)
        {
            chunkList.Add(i);
        }

        foreach (Int64 chunk_id in chunkList)
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadWorker), new arguments { chunk_id = chunk_id });
        }
        Console.ReadLine();

    }
    static void ThreadWorker(Object stateInfo)
    {
        arguments arguments = (arguments)stateInfo;

        Console.WriteLine("Chunk # : {0} is set to START", arguments.chunk_id);
        UpdateSQLdb(arguments.chunk_id, DateTime.Now, null, null, "START", null, null);

        Random random = new Random();
        int mseconds = random.Next(1, 10) * 1000;
        System.Threading.Thread.Sleep(mseconds);
        Console.WriteLine("Chunk # : {0} is sleeping for {1} sec.", arguments.chunk_id, mseconds);

        Console.WriteLine("Chunk # : {0} ist set to END", arguments.chunk_id);
        UpdateSQLdb(arguments.chunk_id, null, DateTime.Now, null, "END", null, null);
    }
    struct arguments
    {
        public Int64 chunk_id;
    }

    static void UpdateSQLdb(Int64 CHUNK_ID, DateTime? START_TS = null, DateTime? END_TS = null, Enum CHUNK_STATUS = null, string error_messages = null, byte? NEW_CALCULATION_ATTEMPTS = null, byte? NEW_POSTPROCESS_ATTEMPTS = null)
    {
        using (SqlConnection conn = new SqlConnection("Data Source=C55S01;Initial Catalog=MCS_BATCH;Integrated Security=SSPI;Asynchronous Processing=True")) //Timeout=60;Max Pool Size=200;Pooling=True;
        {
            int result = -1;
            conn.Open(); //<-- Each time I open a connection. It creates a new instead of reusing one from the ConnectionPool

            try
            {
                using (SqlCommand cmd = new SqlCommand("TEST.UpdateSQL", conn))
                {
                    cmd.CommandTimeout = 300; 
                    cmd.CommandType = System.Data.CommandType.StoredProcedure;

                    cmd.Parameters.Add("@CHUNK_ID", SqlDbType.BigInt, 15).Value = CHUNK_ID;
                    cmd.Parameters.Add("@START_TS", SqlDbType.DateTime2, 7).Value = START_TS;
                    cmd.Parameters.Add("@END_TS", SqlDbType.DateTime2, 7).Value = END_TS;
                    cmd.Parameters.Add("@ERR_MESSAGE", SqlDbType.VarChar).Value = error_messages;
                    cmd.Parameters.Add("@ReturnValue", System.Data.SqlDbType.Int, 4).Direction = System.Data.ParameterDirection.ReturnValue;

                    try
                    {
                        result = cmd.ExecuteNonQuery();

                        int return_value = (int)cmd.Parameters["@ReturnValue"].Value;
                        if (return_value != 0)
                        {
                            Console.WriteLine("1. Error in running TEST.UpdateSQL, return value is : {0}", cmd.Parameters["@ReturnValue"].Value);
                        }
                    }
                    catch (SqlException ex)
                    {
                        UpdateSQLdb(CHUNK_ID, null, DateTime.Now, null, ex.Message.ToString(), null, null);
                        Console.WriteLine("2. Error executing TEST.UpdateSQL : {0}", ex);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("3.Error in TEST.UpdateSQL : {0}", ex);
                throw;
            }
            if (conn.State == ConnectionState.Open)
            {
                Console.WriteLine("Closing connection....");
                conn.Close();
            }
            conn.Dispose();
        }
    }
}

}

我的问题是我得到一个系统。无效操作异常未处理 （超时已过期。从池中获取连接之前经过的超时期限。这可能是因为所有池连接都在使用中，并且已达到最大池大小。

我监控了SQL server上的连接数，它很快达到100个连接(这是池中默认的最大连接数)

如果尝试将这些参数添加到连接字符串:Timeout=60 "最大池大小= 200；Pooling = True

但是这只是将问题推迟到以后的阶段，因为连接池将达到200，超时将在某个点达到。

问：为什么一遍又一遍地创建连接，而不是重用连接池中的连接？

非常感谢任何暗示、提示或建议。

Answer 1

它正在做你要求它做的事情。它使用了池中的连接，但你给了它太多的工作。如果你有500个线程和200个连接，每个线程不能有一个连接。您可能应该拥有和线程一样多的连接。

如果还有更多工作要做（所有 500 个线程都处于繁忙状态），则必须向使用者返回错误或以其他方式限制应用程序中的输入。