ThreadPool.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;

import static java.lang.Thread.sleep;

class PoolRunnable implements Runnable {

    ArrayBlockingQueue<Runnable> blockingQueue;
    Thread thread = null;
    boolean isStop;
    public PoolRunnable( ArrayBlockingQueue<Runnable> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }
    @Override
    public void run() {
        thread = Thread.currentThread();
        while(!isStop) {
            try {
                Runnable rb = blockingQueue.take();
                rb.run();
            } catch (InterruptedException e) {
                System.out.println("interrupted exception in poolthread " + Thread.currentThread().getName());
                e.printStackTrace();
            }
        }
    }

    public synchronized  void stop() {
        this.isStop = true;
        //System.out.print(Thread.currentThread().getName());
        thread.interrupt();
    }
}


public class ThreadPool {
    ArrayBlockingQueue<Runnable> blockingQueue;
    ArrayList<PoolRunnable> poolList = new ArrayList<PoolRunnable>();
    HashMap<Long,Thread> producerThreadMap = new HashMap<Long,Thread>();
    private boolean isStopped = false;
    int capacity;
    public ThreadPool(int capacity, int threads) {
        this.capacity = capacity;
        blockingQueue = new ArrayBlockingQueue<Runnable>(capacity);
        for(int i = 0; i < threads;i++) {
            PoolRunnable runnable = new PoolRunnable(blockingQueue);
            poolList.add(runnable);
            String threadName = "Thread " +Integer.toString(i);
            Thread t = new Thread(runnable, threadName);
            t.start();
        }
     }

     public void execute(Runnable runnable) {
        if(this.isStopped) {
            //throw new IllegalStateException("ThreadPool is stopped");
            return;
        }
            new Thread(() -> {
                try {
                    producerThreadMap.put(Thread.currentThread().getId(),Thread.currentThread());
                    blockingQueue.put(runnable);
                } catch (InterruptedException e) {
                    System.out.println("interrupted exception " + Thread.currentThread().getName());
                   // e.printStackTrace();
                }
               // producerThreadMap.remove(Thread.currentThread().getId());
            }).start();
     }

     public synchronized  void stop() {
        for(int i = 0; i < poolList.size();i++) {
             poolList.get(i).stop();
        }
        System.out.print("size " + producerThreadMap.size());
        for(Map.Entry<Long,Thread> entry: producerThreadMap.entrySet()) {
            Thread t = entry.getValue();
            System.out.println("thread name  "+ t.getName());
            if(t != null) {
                t.interrupt();
            }
        }
     }

     public static void main(String[] args)  {
        ThreadPool pool = new ThreadPool(10,10);
        for(int i = 0; i < 100; i++) {
            int finalI = i;
            int finalI1 = i;
            pool.execute(() -> {
                try {
                    sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("arpit " + Integer.toString(finalI1) );
            });
            //System.out.println("execution completed");
            if( i== 60) {
                pool.stop();
            }
        }
        pool.stop();
     }
}