How to detect nullification of an object from a working thread inside it

Question

I'm working on a ReloadableCollection that reloads once per second on a background thread inside of it. The problem is that when I nullify an instance of the collection, the thread doesn't stop (because it doesn't know that the instance in which it is working has been nullified).

I have tried multiple things, like using a wrapper for the instance, making ThreadWork method static and providing it the instance at startup (start(this)), setting cancel to false in the destructor of the Collection, ... nothing worked.

An example of the problem can be seen in the code bellow.

My collection class:

class Collection
{
    private const int INTERVAL=1000;

    Thread thread;

    public Collection()
    {
        thread=new Thread(ThreadWork);
        thread.Start();
    }

    private void ThreadWork()
    {
        while(true){ // how to detect when the instance is nullified?
            Reload();
            Thread.Sleep(INTERVAL);
        }
    }

    private void Reload()
    {
        // reload the items if there are any changes
    }
}

Example usage:

void Main()
{
    Collection myCollection=new Collection();

    // ...
    // here, it is reloading, like it should be
    // ...

    myCollection=null;

    // ...
    // here, it should not be reloading anymore, but the thread is still running and therefore "reloading"
}

score 3 · Accepted Answer · answered Jun 03 '16 at 01:04

3

Write an explicit 'Stop' method. Don't trigger behavior by setting variables or fields to null.

What happens here?

Collection myCollection = new Collection();
var myOtherCollection = myCollection;
myCollection = null; //Should it stop here?
myOtherCollection = null; //And now? Both are null.

Collection myCollection = new Collection();
MyMethod(myCollection);
myCollection = null; //And here? What if MyMethod adds the collection to a list, or keeps track of it?

void Test()
{
    Collection myCollection = new Collection();
} //Should it stop reloading when we exit the method?

Simply tell the collection to stop reloading when you're done with it. You'll avoid far more headaches, I promise.

private volatile bool _stopping;
private void ThreadWork()
{
    while (!_stopping)
    {
        Reload();
        Thread.Sleep(INTERVAL);
    }
}

public void Stop()
{
    _stopping = true;
}

answered Jun 03 '16 at 01:04

Rob

26,989
16
82
98

1

Or indeed, make it implement IDisposable, since that's the .NET idiom for a class that can be put into a no-longer-in-use state. – Jon Hanna Jun 03 '16 at 01:08
@JonHanna Yep, that works too. Though the principle remains: we need to *explicitly* say when we're done with it – Rob Jun 03 '16 at 01:09
The advantage of `IDisposable` here is that it flags that to the user, as well as allowing the convenient `using` mechanism. – Jon Hanna Jun 03 '16 at 09:13
Thank you for the explanation, I implemented `IDisposable` and solved the problem. – GregorMohorko Jun 07 '16 at 10:33

How to detect nullification of an object from a working thread inside it

1 Answers1