无法回帖啊，，再关于线程误用导致内存泄露的问题

public void execute(Runnable command) throws InterruptedException {
    for (;;) {
      synchronized(this) { 
        if (!shutdown_) {
          int size = poolSize_;

          // Ensure minimum number of threads
          if (size < minimumPoolSize_) {
            addThread(command);
            return;
          }
          
          // Try to give to existing thread
          if (handOff_.offer(command, 0)) { 
            return;
          }
          
          // If cannot handoff and still under maximum, create new thread
          if (size < maximumPoolSize_) {
            addThread(command);
            return;
          }
        }
      }

      // Cannot hand off and cannot create -- ask for help
      if (getBlockedExecutionHandler().blockedAction(command)) {
        return;
      }
    }
  }

protected void addThread(Runnable command) {
    Worker worker = new Worker(command);
    Thread thread = getThreadFactory().newThread(worker);
    threads_.put(worker, thread);
    ++poolSize_;
    thread.start();
  }

protected synchronized void workerDone(Worker w) {
        threads_.remove(w);
        logger.info("Thread removed from thread pool.");
        if (--poolSize_ == 0 && shutdown_) {
            //disable new threads
            maximumPoolSize_ = minimumPoolSize_ = 0;
            //notify awaitTerminationAfterShutdown
            notifyAll();
        }
        // Create a replacement if needed
        if (poolSize_ == 0 || poolSize_ < minimumPoolSize_) {
            try {
                Runnable r = (Runnable) (handOff_.poll(0));
                //just consume task if shut down
                if (!shutdown_) {
                    //add unconditionally and keep the minimum pool size.
                    addThread(r);
                }
            } catch (InterruptedException ie) {
                return;
            }
        }
    }

public class ThreadDemo {
    public static void main(String[] args){
        ThreadOne one = new ThreadOne("ThreadOne");
        ThreadTwo two = new ThreadTwo();
        Thread.currentThread().getThreadGroup().list();
        one.run();
        two.run();
        try {
            //目的是保证one.run()和two.run()都已经执行了。
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Thread.currentThread().getThreadGroup().list();
        one.start();
        new Thread(two, "ThreadTwo").start();
        try {
            //目的是保证one.start()和new Thread(two, "ThreadTwo").start()都已经执行了。
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Thread.currentThread().getThreadGroup().list();
    }
}

class ThreadOne extends Thread {
    public ThreadOne(String name) {
        super(name);
    }

    public void run() {
        System.out.println("This is Thread one.");
    }
}

class ThreadTwo implements Runnable {
    public void run() {
        System.out.println("This is Thread two.");
    }
}

public class ThreadGc {
	public static class LargeThread extends Thread {
		long[] data;
		public LargeThread(int size) {
			data = new long[size];
		}
		
		public void run() {
			// do nothing
		}
	}
	
	public static void main(String[] args) {
		for (int i = 0; i < 1000000; i++) {
			new LargeThread(1000000);
		}
	}
}