What do you think of this Design for Multiple Threads

Question

Hi Java Experts ;
I'm curious to know what you think about this design for a multhreaded app i'm working on.
I have a controller thread that (a.) creates threads and (b.) keeps a reference to threads that it creates (by sticking them in a hashtable along with the generated Id for that thread).
When a created thread completes its job, it decrements the thread counter and removes its reference from the hashtable before it finishes its run method.
Now here's the interesting part in my controller thread i'm creating new threads on the fly with this infinite loop
     public void run(){
          while(true){
               try{
                    Thread.sleep(500);
               }catch(InterruptedException e){
               if(threadCounter<maxThreadCount && moreJobsToDo.size()>0){
                    createDomainThread();
          }//end while
what do you think about this pattern ? My goal is to maintain about 200+ created threads running at all times with this pattern.

Answer 1

jeff kesslerman's book says about threads
"5.2.3 Threads
The impact that threads have on RAM footprint isn't a problem for most programs, but running threads do need space to store their stack state, and the system- specific data structures do consume memory.
Because runtime implementations vary widely in how threads are handled, you might encounter situations where the impact threads have on footprint is significant. For example, some ports of the JRE create a heavyweight OS process for each running thread. In an application that uses many threads, this means that thread costs, rather than class or object costs, can become the dominant factor in the program's memory consumption.
You shouldn't avoid using threads-they're necessary in many cases, and generally don't have a large impact on footprint. However, you should be aware that the impact can be very different across runtimes. This is one of the reasons it's a good idea to measure performance characteristics under your program's different target environments. "
Question #1: how does garbage collection go about clearing the stack state, and the system- specific data structures that consume memory.
Question #2: in my situation, each worker thread's activity is not as brief as a simple server request. Each thread does a lot work and does a lot of network connections. on average I would say 100 http request - each of which can be easily blocked or delayed significantly. Therefore each worker thread may operate for between 2 - 10 minutes.
Do you think thread pooling is useful in this situation ?
stev