C# - Thread.Join(Milliseconds) 和 finally 块

Question

我正在使用 .NET 2.0，如果线程超时，finally 块似乎不会被执行。例如，如果我看到消息“子线程超时...”，我将看不到消息“终于块开始...”。这意味着可能没有正确清理数据库对象 (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

只有在线程不再重要时，您才应该中止线程。在其他情况下，我建议设置某种通知（即在线程上设置布尔属性），以使您的线程正常关闭。话虽如此，根据documentation，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

感谢您的帮助！