Question

我正在使用.NET 2.0，如果线程超时，则finally块似乎没有被执行。例如，如果我看到消息“Child Thread Timed Out ...”，我将看不到消息“Finally block started ...”。这意味着可能无法正确清理数据库对象（Oracle.DataAccess）。有没有办法在子线程内部强制清理，还是应该将清理移动到主线程并将数据库对象传递给子线程？

   private void runThread(string strSP, object objThreadParameter)
    {
        try
        {
            bool blnThreadCompletedOK = true;

            Thread threadHelper = new Thread(getData);
            threadHelper.Start(objThreadParameter);

            // Wait for called thread.  
            blnThreadCompletedOK = threadHelper.Join(THREAD_TIMEOUT);
            if (blnThreadCompletedOK)
            {
                // Thread has completed and should have stopped running.
                // i.e. the thread has processed normally or an exception has been copied to the objExceptionThread object.
                if (objExceptionThread != null)
                {
                    throw objExceptionThread;
                }
            }
            else
            {
                System.Diagnostics.EventLog.WriteEntry("Main thread", "Child Thread Timed Out...", System.Diagnostics.EventLogEntryType.Warning);

                // Main thread has timed out waiting for the child thread.  Likely the child thread is still running.
                if (threadHelper.IsAlive)
                {
                    threadHelper.Abort();  // This will trigger the exception handling in the child thread and cause the finally
                                           // block to be executed.
                }
                throw (new Exception("The call to " + strSP + "() timed out as it exceeded " + (THREAD_TIMEOUT / 1000).ToString() + " seconds"));
            }
        }
        catch (Exception exc)
        {
            throw new PivotalApplicationException(exc.Message, exc, mrsysSystem);
        }
    }


    private void getData(object objThreadParameter)
    {
        OracleCommand oraCmd = null;
        OracleConnection oraConn = null;
        OracleDataReader dr = null;

        try
        {              
            // Initialization.
            int intMAX_RETRIES = 20;       // Maximum number of retries.
            int intRETRY_DROP_POOL = 5;    // At some point, if connections are still failing, try clearing the pool.

            // Other initialization stuff...

            // Now execute the SP.
            for (int i = 1; i <= intMAX_RETRIES; i++)
            {
                try
                {
                    try
                    {
                        // Setup Oracle connection and initialize Oracle command object.
                        getOracleConnection(out oraConn, connString);
                    }
                    catch (Exception exc)
                    {
                        throw new Exception("Error in getData() setting up connection - " + exc.Message);
                    }

                    try
                    {
                        oraCmd = new OracleCommand(strSP, oraConn);
                        setupCommand (out oraCmd);
                    }
                    catch (Exception exc)
                    {
                        throw new Exception("Error in getData() setting up parameters - " + exc.Message);
                    }

                    try
                    {
                        dr = oraCmd.ExecuteReader();
                        break; // Success, so, leave the for loop.
                    }
                    catch (Exception exc)
                    {
                        throw new Exception("Error in getData() executing command.\n\n" + strParametersMsg + " \n\n" + exc.Message);
                    }
                }
                catch (Exception excInner)
                {

                    if (i >= intMAX_RETRIES)
                    {
                        throw new Exception(excInner.Message);
                    }
                    else
                    {
                        // Cleanup oraCmd, oraConn, oraDr...
                    }
                }
            }

            try
            {
                // Process results...
            }
            catch (Exception exc)
            {
                throw new Exception("Error in getData() processing results - " + exc.Message);
            }

            // Now set the variables that are shared between the Main thread and this thread...

        }
        catch (Exception exc)
        {
            logMessage(exc.Source + " " + exc.Message);
            objExceptionThread = exc;  // Initialize exception in Main Thread...
        }
        finally
        {
            System.Diagnostics.EventLog.WriteEntry("Child Thread", "Finally block started...", System.Diagnostics.EventLogEntryType.Warning);

            // With .NET 2.0 and later, the finally block should always be executed correctly for a Thread.Abort()
            if (!(dr == null))
            {
                dr.Dispose();
            }
            if (!(oraCmd == null))
            {
                oraCmd.Dispose();
            }
            if (!(oraConn == null))
            {
                oraConn.Close();
                oraConn.Dispose();
            }

            System.Diagnostics.EventLog.WriteEntry("Child Thread", "Finally block completed...", System.Diagnostics.EventLogEntryType.Warning);
        }
    }

Answer 1

如果该线程没有任何重要性，您应该只中止一个线程。在其他情况下，我建议设置某种通知（即在线程上设置一个布尔属性），使您的线程正常关闭。根据{{3}}说，finally块应该在.NET 2.0中执行：

当调用Abort方法来销毁线程时，公共语言运行库会抛出ThreadAbortException。 ThreadAbortException是一个可以捕获的特殊异常，但它会在catch块的末尾自动再次引发。引发此异常时，运行时将在结束线程之前执行所有finally块。

我最好的猜测是，在线程的finally块有机会执行之前，主线程正在退出。在中止线程后尝试输入Thread.Sleep以查看是否会改变行为。

编辑：我用.NET 2.0编写了一个简单的例子，它产生了以下输出，表明finally块已被执行。

活着和踢

<强>异常

<强>最后

class ThreadTest
{
    public ThreadTest() { }

    public void test()
    {
        try
        {
            while (true)
            {
                Console.WriteLine("Alive and kicking");
                Thread.Sleep(2000);
            }
        }

        catch (Exception ex)
        {
            Console.WriteLine("Exception");
        }

        finally
        {
            Console.WriteLine("Finally");

        }
    }
}
class Program
{
    static void Main(string[] args)
    {
        ThreadTest myThreadTest = new ThreadTest();
        Thread myThread = new Thread(new ThreadStart(myThreadTest.test));
        myThread.Start();
        Thread.Sleep(5000);
        bool status = myThread.Join(1000);
        if (myThread.IsAlive)
        {
            myThread.Abort();
        }
        Thread.Sleep(5000);
    }
}

Answer 2

您只能在托管代码中中断线程。如果它在本机代码中，则运行时会调度在本机代码返回时引发的ThreadAbortException。之后会执行finally个块。在本机函数返回并且托管执行恢复之前，finally块将不会运行。

如果您的问题是本机代码挂起，则finally块无法运行。

Answer 3

谢谢 - 问题似乎确实是时间问题。如果我重复检查threadHelper.IsAlive属性并保持主线程运行，则finally块会执行。所以，我认为代码挂在dr = oraCmd.ExecuteReader（）; Thread.Join（）返回，尝试Abort（） - 但当时不能，然后主线程结束，所以子线程也被杀死。我认为这确实留下了一个开放的联系。

ODP.NET应该是托管数据提供程序（http://wiki.oracle.com/page/Oracle+Data+Provider+for+.Net），它还具有命令超时属性。

“CommandTimeout指定在以异常终止执行之前允许执行命令的秒数”。

我将进一步调查为什么CommandTimeout似乎没有被尊重，如果仍然失败，我可以尝试使用似乎拥有所有书籍的人来结束应用程序域。

http://www.albahari.com/threading/part4.aspx#_Aborting_Threads

感谢您的帮助！

C＃ - Thread.Join（毫秒）和finally块

3 个答案: