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

我对连接池的理解是；如果连接字符串完全相同，则我们重用该连接而不是建立新连接。

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

步骤是：

1. 每个线程都会用 SQL 创建一个更新表。 （注明更新的时间戳）

2. 然后线程休眠 1 到 10 秒（随机）。

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

4. 然后线程退出

   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();
           }
       }
   }
   

   }

我的问题是我得到了System.InvalidOperationException 未处理 （超时已过期。从池中获取连接之前超时时间已过。发生这种情况的原因可能是所有池连接都在使用中并且已达到最大池大小。）

我监控了SQL服务器上的连接数，它很快就达到了100个连接（这是池中默认的最大连接数）

如果尝试将这些参数添加到连接字符串中：超时=60"最大池大小=200;池化=True;

但这只会将问题推迟到稍后阶段，因为连接池将达到 200 并且在某个时刻会达到超时。

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

任何提示、技巧或建议都将受到高度赞赏。

它正在完全按照您的要求进行操作。它正在使用池中的连接，但您给了它太多的工作。如果您有 500 个线程和 200 个连接，则每个线程不能有连接。您可能应该拥有与线程一样多的连接。

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