thread notifying another thead of an exception

Question

ThreadA spawns ThreadB.

ThreadB throws an exception.

How can ThreadA know 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");
        }
    }
}

Appears to be a duplicate of [this one](http://stackoverflow.com/questions/2810468/c-exception-handling-on-background-threads-using-thread-pool) — Sanjeevakumar Hiremath, Mar 14 '11 at 19:59
Not sure if its duplicate. Will be good to see some example code. — palm snow, Mar 14 '11 at 20:09
We'll need more specifics (code showing exactly how you're spawning the threads would be helpful) - there's no shortage of questions and answers relating to handling exceptions in threaded code here. — 48klocs, Mar 14 '11 at 20:14
added simplified version of code to give you some idea what i am trying to do. — palm snow, Mar 14 '11 at 20:52

score 0 · Accepted Answer · answered Mar 14 '11 at 21:07

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 clean this up, surely depending on what you want to do specifically.

score 0 · Answer 2 · answered Mar 14 '11 at 21:35

As long as your thread is sleeping it cannot be interrupted by an exception caused by another thread. If you can control how your thread is doing something else he should be waiting in an alertable mode where the does e.g. wait for a threadExceptionEvent. If you do not have control how your thread is waiting the best thing you can do is to check in the times between your thread did something for e.g. a bool exception flag and throw this one.

The following code shows how you can wait for several WaitHandles at once and react depending on the fired event appropriately.

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
    }
}

Yours, Alois Kraus

thread notifying another thead of an exception

2 Answers2

Linked