Question

The code that I want to write is like this:

void MethodOnThreadA() {     for (;;)     {         // Do stuff         if (ErrorConditionMet)             ThrowOnThread(threadB, new MyException(...));     } }  void MethodOnThreadB() {     try     {         for (;;)         {             // Do stuff         }     }     catch (MyException ex)     {         // Do the right thing for this exception.     } } 

I know I can have thread B periodically check, in thread safe way, to see if a flag has been set by thread A, but that makes the code more complicated. Is there a better mechanism that I can use?

Here is a more fleshed out example of periodically checking:

Dictionary<Thread, Exception> exceptionDictionary = new Dictionary<Thread, Exception>();  void ThrowOnThread(Thread thread, Exception ex) {     // the exception passed in is going to be handed off to another thread,     // so it needs to be thread safe.     lock (exceptionDictionary)     {         exceptionDictionary[thread] = ex;     } }  void ExceptionCheck() {     lock (exceptionDictionary)     {         Exception ex;         if (exceptionDictionary.TryGetValue(Thread.CurrentThread, out ex))             throw ex;     } }  void MethodOnThreadA() {     for (;;)     {         // Do stuff         if (ErrorConditionMet)             ThrowOnThread(threadB, new MyException(...));     } }  void MethodOnThreadB() {     try     {         for (;;)         {             // Do stuff             ExceptionCheck();         }     }     catch (MyException ex)     {         // Do the right thing for this exception.     } } 

Answer 1

This is NOT a good idea

This article talks about ruby’s timeout library. which throws exceptions across threads.

It explains how doing such a thing is fundamentally broken. It’s not just broken in ruby, it’s broken anywhere that throws exceptions across threads.

In a nutshell, what can (and does) happen is this:

ThreadA:

At some random time, throw an exception on thread B: 

ThreadB:

try {     //do stuff } finally {     CloseResourceOne();     // ThreadA's exception gets thrown NOW, in the middle      // of our finally block and resource two NEVER gets closed.     // Obviously this is BAD, and the only way to stop is to NOT throw     // exceptions across threads     CloseResourceTwo(); } 

Your ‘periodic checking’ example is fine, as you’re not actually throwing exceptions across threads.
You’re just setting a flag which says ‘throw an exception the next time you look at this flag’, which is fine as it doesn’t suffer from the ‘can be thrown in the middle of your catch or finally block’ problem.
However, if you’re going to do that, you may as well just be setting an ‘exitnow’ flag, and using that and save yourself the hassle of creating the exception object. A volatile bool will work just fine for that.