Why does Thread class not support IDisposable?

On Dec 7, 2:19 pm, Creativ <GongXinr...@gm ail.comwrote:

Why does Thread class not support IDisposable?

Why should it? What would Thread.Dispose actually do?

It's creating quite some problem. Namely, it can exhaust the resource and you
have not control over it.

I've done a fair amount of threading and never got into a situation
where I want to dispose of a thread. Now terminating a thread in a
graceful manner is a different matter - but that's up to the
collaboration between the threads. If you need to "hard" reset a
thread, Abort is your friend - but you should only really do that if
you're tearing down the process (or at least the AppDomain) as it
leaves things in an indeterminate state.

Jon

The scenario I can think of is you create a thread to run some task.
After some runs, quite some threads will be created. After doing that
for a long time, you will have problem in creating Thread and run it
since the CloseHandle will be called in the Finalizer.

On Dec 7, 2:37 pm, Creativ <GongXinr...@gm ail.comwrote:

The scenario I can think of is you create a thread to run some task.
After some runs, quite some threads will be created. After doing that
for a long time, you will have problem in creating Thread and run it
since the CloseHandle will be called in the Finalizer.

If you've got that many actual threads, you've got bigger problems
anyway. Have you actually run into this as a problem? Have you seen
anyone else running into this as a problem?

Jon

Yes, I did. Some one created a lot of thread to run some calculation.
Finally he get an error from the numeric library, "Reached Thread
Limit".
I adviced him to use ThreadPool.
But idealy, Thread should support IDisposable since it's a limited
resource.

On Dec 7, 3:17 pm, Creativ <GongXinr...@gm ail.comwrote:

Yes, I did. Some one created a lot of thread to run some calculation.
Finally he get an error from the numeric library, "Reached Thread
Limit".

But did you isolate the problem to finalization rather than it
physically trying to run too many threads?

I adviced him to use ThreadPool.
But idealy, Thread should support IDisposable since it's a limited
resource.

But it's not something that *can* be manually released. There's the
handle, but that's it - and I suspect that's not what you were seeing
in the above situation.

As I said before, if you're creating that many threads you will run
into issues regardless.

Jon

As I said before, if you're creating that many threads you will run

into issues regardless.

The problem is as following. Since the Finalize() can be really
delayed, the program will hold a lot of thread handle when those
theads are ready. Implementing a Dispose which call CloseHandle() will
solve this problem.

Changing to ThreadPool, you won't get that kind problem.

On Dec 7, 3:32 pm, Creativ <GongXinr...@gm ail.comwrote:

As I said before, if you're creating that many threads you will run
into issues regardless.

The problem is as following. Since the Finalize() can be really
delayed, the program will hold a lot of thread handle when those
theads are ready. Implementing a Dispose which call CloseHandle() will
solve this problem.

Only if you know exactly when to call it - which you typically don't.

There are typically many, many, *many* times more handles available
than you sensibly want to create threads - in other words, if you're
creating enough threads to run into this as a problem, then you're
doing something wrong anyway.

It's like exceptions: there's a slight performance hit, but if you're
throwing enough to see a *significant* issue, then you're almost
certainly misusing exceptions in the first place.

Jon

"Creativ" <Go*********@gm ail.comwrote:

Yes, I did. Some one created a lot of thread to run some calculation.
Finally he get an error from the numeric library, "Reached Thread
Limit".

I've gotta agree with Jon on this one. It's not a limitation in Windows
Threading, or the implementation of .Net thread constructs. The problem here
is the algorithm being used is deeply flawed.

I adviced him to use ThreadPool.
But idealy, Thread should support IDisposable since it's a limited
resource.

Threads are special. There's no way an external source can Dispose a thread.
It just isn't something that makes logical sense given the design of threads
in Windows.

An external source can set a flag, "Please Exit when you can", and the
thread can choose to honor that flag. Such a construct is common.

--
Chris Mullins