Question

I have an object in C# on which I need to execute a method on a regular basis. I would like this method to be executed only when other people are using my object, as soon as people stop using my object I would like this background operation to stop.

So here is a simple example is this (which is broken):

class Fish
{
    public Fish()
    {
        Thread t = new Thread(new ThreadStart(BackgroundWork));     
        t.IsBackground = true;
        t.Start();
    }

    public void BackgroundWork()
    {
        while(true)
        {
            this.Swim(); 
            Thread.Sleep(1000); 
        }
    }


    public void Swim()
    {
         Console.WriteLine("The fish is Swimming"); 
    }
}

The problem is that if I new a Fish object anywhere, it never gets garbage collected, cause there is a background thread referencing it. Here is an illustrated version of broken code.

public void DoStuff()
{ 
   Fish f = new Fish();
}
// after existing from this method my Fish object keeps on swimming. 

I know that the Fish object should be disposable and I should clean up the thread on dispose, but I have no control over my callers and can not ensure dispose is called.

How do I work around this problem and ensure the background threads are automatically disposed even if Dispose is not called explicitly?

Answer 1

Here is my proposed solution to this problem:

class Fish : IDisposable 
{
    class Swimmer
    {
        Thread t; 
        WeakReference fishRef;
        public ManualResetEvent terminate = new ManualResetEvent(false);

        public Swimmer(Fish3 fish)
        {
            this.fishRef = new WeakReference(fish);
            t = new Thread(new ThreadStart(BackgroundWork));    
            t.IsBackground = true;
            t.Start();
        } 

        public void BackgroundWork()
        {
            bool done = false;
            while(!done)
            {
                done = Swim(); 
                if (!done) 
                {
                    done = terminate.WaitOne(1000, false);
                } 
            }
        }

        // this is pulled out into a helper method to ensure 
        // the Fish object is referenced for the minimal amount of time
        private bool Swim()
        {
            bool done;

            Fish fish = Fish; 
            if (fish != null)
            {
                fish.Swim(); 
                done = false;
            }
            else 
            {
                done = true;
            }
            return done;
        }

        public Fish Fish
        {
            get { return fishRef.Target as Fish3; }
        }
    }

    Swimmer swimmer;

    public Fish()
    {
            swimmer = new Swimmer(this);
    }

    public void Swim()
    {
        Console.WriteLine("The third fish is Swimming"); 
    }

    volatile bool disposed = false;

    public void Dispose()
    {
        if (!disposed)
        {
            swimmer.terminate.Set();
            disposed = true;
            GC.SuppressFinalize(this);
        }       
    }

    ~Fish() 
    {
        if(!disposed)
        {
            Dispose();
        }
    }
}