Terminating threads

Question

Hi,
I have developed a simple program to test executor service and executors for thread pool creation and management. The program executes fine until I call the shudown() method. The Executor is shutdown but the threads still remain alive (verified by calling Shutdown() -> isShutdown() -> isTerminated())
I have supplied the code along with this message:
import java.util.concurrent.*;
public class PerfTrack {
     public static void main(String args[]){
          final int CAPACITY = 5;
          final ExecutorService threadPool;
          Tasks hasTasks = new Tasks();
          ArrayBlockingQueue taskQueue = new ArrayBlockingQueue(CAPACITY, true);
          threadPool = Executors.newFixedThreadPool(10);
          threadPool.execute(new Scheduler(taskQueue));
          while(hasTasks.getTasks())
               threadPool.execute(new Handler(taskQueue, hasTasks));
          threadPool.shutdown();
          System.out.println("hello");
          System.out.println(threadPool.isShutdown());
          System.out.println(threadPool.isTerminated());
class Tasks{
     private boolean hasTasks;
     public Tasks(){
          hasTasks = true;
     public synchronized boolean getTasks(){
          return hasTasks;
     public synchronized void setTasks(){
          hasTasks = false;
class Scheduler implements Runnable{
     private ArrayBlockingQueue taskQueue;
     public Scheduler(ArrayBlockingQueue taskQueue){
          this.taskQueue = taskQueue;
     private void createTasks(){
          for(int i = 1; i <= 20; i++){
               try{
                    taskQueue.put(new Integer(i));
                    if(i == 20){
                         taskQueue.put(new Integer(0));
               catch(InterruptedException intEx){
                    // Do nothing
     public void run(){
          createTasks();
class Handler implements Runnable{
     private ArrayBlockingQueue taskQueue;
     private Integer queueItem;
     volatile Tasks hasTasks;
     public Handler(ArrayBlockingQueue taskQueue, Tasks hasTasks){
          this.taskQueue = taskQueue;
          this.hasTasks = hasTasks;
     private synchronized void getItems(){
          try{
               queueItem = (Integer)taskQueue.take();
               if(queueItem.intValue() == 0){
                    hasTasks.setTasks();
               else
                    System.out.println("The number is:\t" + queueItem.intValue());
          catch(InterruptedException intEx){
     public void run(){
          getItems();
}Your help is greatily appreciated,
Thanks

Answer 1

Java does not provide any mechanism for safely forcing a thread to stop what it is doing.[1] Instead, it provides interruption, a cooperative mechanism that lets one thread ask another to stop what it is doing.
The deprecated Thread.stop and suspend methods were an attempt to provide such a mechanism, but were quickly realized to be seriously flawed and should be avoided. See http://java.sun.com/j2se/1.5.0/docs/guide/misc/threadPrimitiveDeprecation.html for an explanation of the problems with these methods.
public class PrimeGenerator implements Runnable {
     private final List<BigInteger> primes
             = new ArrayList<BigInteger>();
     private  volatile boolean cancelled;
     public void run() {
         BigInteger p = BigInteger.ONE;
         while (!cancelled ) {
             p = p.nextProbablePrime();
             synchronized (this) {
                 primes.add(p);
     public void cancel() { cancelled = true;  }
     public synchronized List<BigInteger> get() {
         return new ArrayList<BigInteger>(primes);
}&spades;