Notify when thread is complete, without locking calling thread

Question

I am working on a legacy application that is built on top of NET 3.5. This is a constraint that I can\'t change. I need to execute a second thread to run a long running tas

Answer 1

Try to use ManualRestEvent to signal of thread complete.

Answer 2

Maybe using conditional variables and mutex, or some functions like wait(), signal(), maybe timed wait() to not block main thread infinitely.

In C# this will be:

   void Notify()
{
    lock (syncPrimitive)
    {
        Monitor.Pulse(syncPrimitive);
    }
}

void RunLoop()
{

    for (;;)
    {
        // do work here...

        lock (syncPrimitive)
        {
            Monitor.Wait(syncPrimitive);
        }
    }
}

more on that here: Condition Variables C#/.NET

It is the concept of Monitor object in C#, you also have version that enables to set timeout

public static bool Wait(
   object obj,
   TimeSpan timeout
)

more on that here: https://msdn.microsoft.com/en-us/library/system.threading.monitor_methods(v=vs.110).aspx

Answer 3

1. A very simple thread of execution with completion callback
2. This does not need to run in a mono behavior and is simply used for convenience

using System;
using System.Collections.Generic;
using System.Threading;
using UnityEngine;

public class ThreadTest : MonoBehaviour
{
    private List<int> numbers = null;

    private void Start()
    {
        Debug.Log("1. Call thread task");

        StartMyLongRunningTask();

        Debug.Log("2. Do something else");
    }

    private void StartMyLongRunningTask()
    {
        numbers = new List<int>();

        ThreadStart starter = myLongRunningTask;

        starter += () =>
        {
            myLongRunningTaskDone();
        };

        Thread _thread = new Thread(starter) { IsBackground = true };
        _thread.Start();
    }

    private void myLongRunningTaskDone()
    {
        Debug.Log("3. Task callback result");

        foreach (int num in numbers)
            Debug.Log(num);
    }


    private void myLongRunningTask()
    {
        for (int i = 0; i < 10; i++)
        {
            numbers.Add(i);

            Thread.Sleep(1000);
        }
    }
}

Answer 4

You can use a combination of custom event and the use of BeginInvoke:

public event EventHandler MyLongRunningTaskEvent;

private void StartMyLongRunningTask() {
    MyLongRunningTaskEvent += myLongRunningTaskIsDone;
    Thread _thread = new Thread(myLongRunningTask) { IsBackground = true };
    _thread.Start();
    label.Text = "Running...";
}

private void myLongRunningTaskIsDone(object sender, EventArgs arg)
{
    label.Text = "Done!";
}

private void myLongRunningTask()
{
    try 
    { 
        // Do my long task...
    } 
    finally
    {
        this.BeginInvoke(Foo, this, EventArgs.Empty);
    }
}

I checked, it's work under .NET 3.5

Answer 5

You could use the Observer Pattern, take a look here:

http://www.dofactory.com/Patterns/PatternObserver.aspx

The observer pattern will allow you, to notify other objects which were previously defined as observer.

Answer 6

I absolutely understand your requirements, but you've missed one crucial thing: do you really need to wait for the end of that thread synchronously? Or maybe you just need to execute the "finalizer" after thread's end is detected?

In the latter case, simply wrap the call to myLongRunningTask into another method:

void surrogateThreadRoutine() {
    // try{ ..

    mytask();

    // finally { ..
    ..all 'finalization'.. or i.e. raising some Event that you'll handle elsewhere
}

and use it as the thread's routine. That way, you'll know that the finalization will occur at the thread's and, just after the end of the actual job.

However, of course, if you're with some UI or other schedulers, the "finalization" will now run on yours thread, not on the "normal threads" of your UI or comms framework. You will need to ensure that all resources are external to your thread-task are properly guarded or synchronized, or else you'll probably clash with other application threads.

For instance, in WinForms, before you touch any UI things from the finalizer, you will need the Control.InvokeRequired (surely=true) and Control.BeginInvoke/Invoke to bounce the context back to the UI thread.

For instance, in WPF, before you touch any UI things from the finalizer, you will need the Dispatcher.BeginInvoke..

Or, if the clash could occur with any threads you control, simple proper lock() could be enough. etc.