线程中止会留下僵尸事务和断开的SqlConnection

本文关键字:事务 断开 SqlConnection 僵尸 线程 | 更新日期: 2023-09-27 17:58:12

我觉得这种行为不应该发生。这是一个场景:

  1. 启动一个长时间运行的sql事务。

  2. 运行sql命令的线程被中止(不是通过我们的代码!)

  3. 当线程返回到托管状态时代码,SqlConnection的状态为"已关闭"-但交易仍然在sql服务器上打开。

  4. SQLConnection可以重新打开,您可以尝试在上调用回滚交易,但它没有

问题只是线程中止时事务没有正确清理。这是.Net 1.1、2.0和2.0 SP1的问题。我们正在运行.Net 3.5 SP1。

下面是一个示例程序来说明这个问题。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Threading;
namespace ConsoleApplication1
{
    class Run
    {
        static Thread transactionThread;
        public class ConnectionHolder : IDisposable
        {
            public void Dispose()
            {
            }
            public void executeLongTransaction()
            {
                Console.WriteLine("Starting a long running transaction.");
                using (SqlConnection _con = new SqlConnection("Data Source=<YourServer>;Initial Catalog=<YourDB>;Integrated Security=True;Persist Security Info=False;Max Pool Size=200;MultipleActiveResultSets=True;Connect Timeout=30;Application Name=ConsoleApplication1.vshost"))
                {
                    try
                    {
                        SqlTransaction trans = null;
                        trans = _con.BeginTransaction();
                        SqlCommand cmd = new SqlCommand("update <YourTable> set Name = 'XXX' where ID = @0; waitfor delay '00:00:05'", _con, trans);
                        cmd.Parameters.Add(new SqlParameter("0", 340));
                        cmd.ExecuteNonQuery();
                        cmd.Transaction.Commit();
                        Console.WriteLine("Finished the long running transaction.");
                    }
                    catch (ThreadAbortException tae)
                    {
                        Console.WriteLine("Thread - caught ThreadAbortException in executeLongTransaction - resetting.");
                        Console.WriteLine("Exception message: {0}", tae.Message);
                    }
                }
            }
        }
        static void killTransactionThread()
        {
            Thread.Sleep(2 * 1000);
            // We're not doing this anywhere in our real code.  This is for simulation
            // purposes only!
            transactionThread.Abort();
            Console.WriteLine("Killing the transaction thread...");
        }
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            using (var connectionHolder = new ConnectionHolder())
            {
                transactionThread = new Thread(connectionHolder.executeLongTransaction);
                transactionThread.Start();
                new Thread(killTransactionThread).Start();
                transactionThread.Join();
                Console.WriteLine("The transaction thread has died.  Please run 'select * from sysprocesses where open_tran > 0' now while this window remains open. 'n'n");
                Console.Read();
            }
        }
    }
}

有一个针对.Net 2.0 SP1的Microsoft修补程序本应解决此问题,但我们显然有更新的DLL(.Net 3.5 SP1)与此修补程序中列出的版本号不匹配。

有人能解释这种行为吗?为什么ThreadAbort仍然没有正确清理sql事务?.Net 3.5 SP1是否不包括此修补程序,或者此行为在技术上是否正确?

线程中止会留下僵尸事务和断开的SqlConnection

由于您将SqlConnection与池一起使用,因此您的代码永远无法控制关闭连接。池是。在服务器端,当连接真正关闭(套接字关闭)时,挂起的事务将回滚,但使用池,服务器端永远不会看到连接关闭。如果连接关闭(通过套接字/管道/LPC层的物理断开连接或通过sp_reset_connection调用),则服务器无法中止挂起的事务。因此,这实际上可以归结为连接没有得到正确的释放/重置。我不明白为什么你试图通过显式线程中止驳回来使代码复杂化,并试图重新打开一个已关闭的事务(这将永远不起作用)。您应该简单地将SqlConnection封装在using(...)块中,即使在线程中止时,隐含的finally和connection Dispose也将运行。

我的建议是保持简单,放弃花哨的线程中止处理,代之以简单的"使用"块(using(connection) {using(transaction) {code; commit () }}

当然,我假设您不会将事务上下文传播到服务器中的不同范围(您不使用sp_getbindtoken和friends,也不注册分布式事务)。

这个小程序显示Thread.Artrt正确地关闭了一个连接,事务被回滚:

using System;
using System.Data.SqlClient;
using testThreadAbort.Properties;
using System.Threading;
using System.Diagnostics;
namespace testThreadAbort
{
    class Program
    {
        static AutoResetEvent evReady = new AutoResetEvent(false);
        static long xactId = 0;
        static void ThreadFunc()
        {
            using (SqlConnection conn = new SqlConnection(Settings.Default.conn))
            {
                conn.Open();
                using (SqlTransaction trn = conn.BeginTransaction())
                {
                    // Retrieve our XACTID
                    //
                    SqlCommand cmd = new SqlCommand("select transaction_id from sys.dm_tran_current_transaction", conn, trn);
                    xactId = (long) cmd.ExecuteScalar();
                    Console.Out.WriteLine("XactID: {0}", xactId);
                    cmd = new SqlCommand(@"
insert into test (a) values (1); 
waitfor delay '00:01:00'", conn, trn);
                    // Signal readyness and wait...
                    //
                    evReady.Set();
                    cmd.ExecuteNonQuery();
                    trn.Commit();
                }
            }
        }
        static void Main(string[] args)
        {
            try
            {
                using (SqlConnection conn = new SqlConnection(Settings.Default.conn))
                {
                    conn.Open();
                    SqlCommand cmd = new SqlCommand(@"
if  object_id('test') is not null
begin
    drop table test;
end
create table test (a int);", conn);
                    cmd.ExecuteNonQuery();
                }

                Thread thread = new Thread(new ThreadStart(ThreadFunc));
                thread.Start();
                evReady.WaitOne();
                Thread.Sleep(TimeSpan.FromSeconds(5));
                Console.Out.WriteLine("Aborting...");
                thread.Abort();
                thread.Join();
                Console.Out.WriteLine("Aborted");
                Debug.Assert(0 != xactId);
                using (SqlConnection conn = new SqlConnection(Settings.Default.conn))
                {
                    conn.Open();
                    // checked if xactId is still active
                    //
                    SqlCommand cmd = new SqlCommand("select count(*) from  sys.dm_tran_active_transactions where transaction_id = @xactId", conn);
                    cmd.Parameters.AddWithValue("@xactId", xactId);
                    object count = cmd.ExecuteScalar();
                    Console.WriteLine("Active transactions with xactId {0}: {1}", xactId, count);
                    // Check count of rows in test (would block on row lock)
                    //
                    cmd = new SqlCommand("select count(*) from  test", conn);
                    count = cmd.ExecuteScalar();
                    Console.WriteLine("Count of rows in text: {0}", count);
                }
            }
            catch (Exception e)
            {
                Console.Error.Write(e);
            }
        }
    }
}

这是Microsoft MARS实现中的一个错误。在连接字符串中禁用MARS会使问题消失。

如果您需要MARS,并且愿意让您的应用程序依赖于另一家公司的内部实现,请熟悉http://dotnet.sys-con.com/node/39040,分解.NET Reflector,并查看连接和池类。在发生故障之前,您必须存储DbConnectionInternal属性的副本。稍后,使用反射将引用传递到内部池类中的释放方法。这将阻止您的连接延迟4:00-7:40分钟。

当然,还有其他方法可以强制将连接从池中取出并进行处理。不过,如果没有微软的修补程序,反思似乎是必要的。ADO.NET API中的公共方法似乎没有帮助。