Re: Do I need a finalizer when I have started alternate threads?
I'll try again to explain a bit better. I'll include some snippets to help
describe.
public class EventTracing : IDisposable
{
private ManualResetEvent _shutdown = new ManualResetEvent(false);
private ManualResetEvent _changedEvent = new ManualResetEvent(false);
private Thread _watcher = null;
private void Watcher()
{
try
{
WaitHandle waits = new WaitHandle[] {this._shutdown,
this._changedEvent};
while (true)
{
int wait = WaitHandle.WaitAny(waits);
if (wait == 0)
break;
<do some stuff>
}
}
catch(Exception)
{
}
}
public void Dispose()
{
if (this._watcher != null)
{
this._shutdown.Set();
this._watcher.Join();
}
}
}
So there is a little bit of the code. I didn't know about the IsBackground
property so maybe for me the solution is to just set IsBackground = true and
I'm done. However, let's assume I haven't set that property and the consumer
of my EventTracing class has some faulty code which does not call my
Dispose() method. Then I have a foreground thread which is keeping the
application from terminating. I'm wondering whether there is a way to
resolve this by adding a finalizer.
The part I mentioned about writing a finalizer and then thinking that it
might not be valid because objects may have already been collected is this:
The .NET Thread class is somehow associated with a running thread, but the
Thread class is itself not the actual OS thread that's running. Since I
don't hand out references to this Thread instance my EventTracing class is
the only one which has a reference to it. If I added a finalizer to my
EventTracing class then when that finalizer gets called there must be no
reference to this instance of EventTracing and thus to the Thread instance,
which means the Thread instance may have already been collected, correct?
Though I see the Thread class inherits from CriticalFinalizerObject and thus
implements a finalizer. Not sure what it does in its finalizer as the code
is hidden from reflector.
--
Thanks,
Nick
nicknospamdu@community.nospam
remove "nospam" change community. to msn.com
"Peter Duniho" wrote:
On Tue, 16 Jun 2009 11:40:01 -0700, nickdu <nicknospamdu@community.nospam>
wrote:
Based on your second part my guess is that I didn't phrase the question
properly. I don't want to execute any specific code when a thread exits.
And I do have code to properly cleanup the thread, terminating it nicely
by
setting an event and waiting for the thread to exit (Thread.Join()).
However, this logic to cleanup the thread is in my class's Dispose()
method.
What if the consumer of my class decides not to call Dispose()? It's
this
case that I was trying to protect with a finalizer.
The finalizer will only be executed if your object becomes unreachable
(and is not guaranteed to execute even in that case, though if you wait
long enough usually it would be).
As I was writing the finalizer it became evident that the objects I was
attempting to manipulate might have been collected already. Though as I
mentioned before, threads that I created within my application
(foreground I
suppose since I didn't set the background flag) kept my application
alive.
Does this mean that a thread object being GC'd doesn't shutdown the
thread if
the thread object is associated with a running thread?
The question doesn't make much sense to me. First, whether an object is
collected or not has no bearing on whether a thread continues to execute,
unless you have something explicit that would do that. Second, if there
is a thread executing and somewhere via the data structures in use by that
thread the object remains reachable, it won't be collected anyway.
I don't know what you mean by "thread object is associated with a running
thread", but assuming it means that the code executing in the thread has a
way to access the object, then by definition the object isn't unreachable,
and so won't be collected.
Code that I was writing for the Dispose() method:
private void Dispose(bool disposing)
{
if (this._watcher != null)
{
this._shutdown.Set();
this._watcher.Join();
}
if (disposing == true)
GC.SuppressFinalize();
}
As I was writing this I said to myself that this._watcher and
this._shutdown
might have already been collected if this is being called from my
finalizer.
Hard to say without a concise-but-complete code example. But it seems
unlikely to me. After all, if the thread that would actually use the
"_shutdown" object, it must still be reachable and thus would not be
collected. Likewise the "_watcher" object (which appears to be a Thread
instance)...if the Thread is still executing, then by definition the
object is still reachable and won't be collected.
Pete