1

我正在使用 .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);
        }
    }
4

3 回答 3

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);
    }
}
于 2010-10-30T00:05:24.100 回答
1

您只能在托管代码中中断线程。如果它在本机代码中，则运行时安排ThreadAbortException在本机代码返回时抛出。然后finally块将执行。finally 块将不会运行，直到本机函数返回并且托管执行恢复。

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

于 2010-10-30T00:28:33.300 回答
0

谢谢 - 问题似乎是时间问题之一。如果我反复检查 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

谢谢您的帮助！

于 2010-10-30T03:40:47.520 回答