Question

i have main thread (MainThread) on which I create new thred (lets call it NewThread). In NewThread I call a method that want to invoke some method for MainThread.

The problem is that when I call NewThread.Join() from MainThread, Invoke method from NewThread cant be accomplished/terminate (and whole application freeze for ever…) because MainThread is waiting for NewThread to terminate…

sth like vicious circle… Any ideas how to solve it? I need to have possibility to terminate/abort NewThread from MainThread and be shure NewThread no longer exist.

I hope I was specific enough.

Main thread:

void method()
    {
        if(currentthread!=null)
        {
            currentthread.Join();
            currentthread=null;
        }

        sth...

        Backgroundworker worker = new Backgroundworker();
        worker.DoWork += delegate (...)
            {
                currentthread=Thread.CurrentThread;
                Func();
            }
            ....
}

NewThread:

delegate void FuncDel();
void Func()
{

    if(MainThread.InvokeRequired)
{
    FuncDel funcD = new FuncDel();
    MainThread.InvokeRequired(funcD);
          return;
} 
 ....
}

Answer 1

Well, the obvious answer is that your main thread should never Join() your worker thread if there’s a chance the worker thread is going to try to Invoke() something on the main thread.

If you are only using Join() to wait for a shutdown on the main thread, you should first do something like a Thread.Abort(), or better yet, use a thread synchronization object like a Mutex or a shared variable, to indicate to the worker thread that it needs to abort. Once you have signaled the worker thread to abort, then allow your main thread to Join() it; your worker thread should always check to see if it has been aborted before trying to Invoke a method on the main thread.

If you’re using Join() for some other reason, you should again look into the thread synchronization objects like a Mutex. These allow your threads to wait for each other to send them signals — your worker thread could “wake up” your main thread before it needs to Invoke(), to ensure your main thread is getting CPU time to do it’s work.