Geek asks and answers

Thread notifies another hell of exception

ThreadA spawns ThreadB.

ThreadB throws an exception.

How can ThreadA find out about this exception?

using System;
using System.Threading;
namespace ConsoleApplication1  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            ThreadStart threadDelegate1 = new ThreadStart(MyClass1.DoThis);  
            Thread ThreadA = new Thread(threadDelegate1);  
            ThreadA.Start();  
            Thread.Sleep(100000); // this thread is doing something else here, sleep simulates it

        }  
    }  
    class MyClass1  
    {
        public static void DoThis()
        {
            try
            {
                ThreadStart threadDelegate1 = new ThreadStart(MyClass2.DoThat);
                Thread ThreadB = new Thread(threadDelegate1);
                ThreadB.Start();
                Thread.Sleep(100000); // this thread is doing something else here, sleep simulates it

            }
            catch (Exception e)
            {
                // I want to know if something went wrong with MyClass2.DoThat
            }
        }
    }

    class MyClass2
    {
        public static void DoThat()
        {
            throw new Exception("From DoThat");
        }
    }
}
+3
source share
2 answers

Here is one way: using ManualResetEvent and lambdas:

        try
        {
            Exception exc;
            using (ManualResetEvent resetEvent = new ManualResetEvent(false))
            {
              Thread ThreadB = new Thread(() =>
              {
                try
                {
                    MyClass2.DoThat();
                }
                catch (Exception e)
                {
                    exc = e;
                    resetEvent.Set();
                }
              });
              ThreadB.Start();
              if (resetEvent.WaitOne(10000))
              {
                throw exc;
              }
            }
        }
        catch (Exception e)
        {
            // I want to know if something went wrong with MyClass2.DoThat
        }

You can clear this, of course, depending on what you want to do specifically.

0
source

, - , . , - , , , . ExceptionEvent. , , , , , , bool .

, WaitHandles .

using System;
using System.Threading;

class Program
{
    static AutoResetEvent _ExceptionEvent = new AutoResetEvent(false);
    static WaitHandle _SomeEvent = new AutoResetEvent(false);
    static WaitHandle[] _Waiters = new WaitHandle[] { _ExceptionEvent, _SomeEvent };
    static Exception _LastThrownException = null;

    static int _CatchedExCount = 0;
    static void ThreadA()
    {
        while (true)
        {
            int eventIdx = WaitHandle.WaitAny(_Waiters);
            if (eventIdx == 0) // Exception event
            {
                Exception lastEx = Interlocked.Exchange(ref _LastThrownException, null);
                if (lastEx != null)
                {
                    Console.WriteLine("Thread A got exception {0}", lastEx.Message);
                    _CatchedExCount++;
                    //throw lastEx;
                }
            }
        }

    }

    static void ThreadB()
    {
        while (true)
        { 
            try
            {
                ThreadBWorker();
            }
            catch (Exception ex) 
            {
                // Do not overwrite a pending exception until it was processed
                Exception old = null;
                do
                {
                    old = Interlocked.CompareExchange(ref _LastThrownException, ex, null);
                    if( old != null) // wait a bit to allow processing of existing exception
                    {
                        Thread.Sleep(1);
                    }
                }
                while (old != null);
                _ExceptionEvent.Set();
            }
        }
    }

    static int _exCount = 0;
    static void ThreadBWorker()
    {
        throw new Exception("Thread B Exception " + _exCount++);
    }

    static void Main(string[] args)
    {
        Thread t2 = new Thread(ThreadB);
        t2.Start();  // start producing exception

        Thread t1 = new Thread(ThreadA);
        t1.Start(); // wait for exceptions
    }
}

,  

0

More articles:


All Articles