import java.util.List;

import java.util.Queue;

import java.util.Timer;

import java.util.TimerTask;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentLinkedQueue;

    private static final org.apache.juli.logging.Log log = org.apache.juli.logging.LogFactory.getLog(org.apache.tomcat.util.threads.ThreadPoolExecutor.class);

    private final AtomicInteger hungCount = new AtomicInteger(0);

    private static long THREAD_MONITOR_THRESHOLD_IN_SECONDS = 10 * 60; //Default 10 min.

    private static long THREAD_MONITOR_INTERVAL_IN_SECONDS = 120; //Default 120 seconds

    //Don't keep references to any actual running Thread objects, except in this Map (which is automatically cleaned in afterExecute() ).

    //That way, Threads can be GC'ed, eventhough the Monitor still thinks they are hung (caused by a long monitor interval).

    private ConcurrentHashMap<Runnable, MonitoredThread> activeThreads = null;

    private Queue<CompletedHungThread> completedHungThreadsQueue = null;

    private Timer timer = null;

    //This is only modified in the static initializer. If modified elsewhere,

    //it should be changed to volatile or Atomic

    private static boolean monitoringEnabled = true; //Default?

    static {

        //Get properties (if configured), and check for sensible values

        Integer thresholdTmp = Integer.getInteger("org.apache.catalina.threadmonitor.threshold"); //In seconds

        if (thresholdTmp != null) {

            int threshold = thresholdTmp.intValue();

            if (threshold >= 60) { //SO_TIMEOUT is 20 sec in Tomcat, the threshold must at least be larger than that

                THREAD_MONITOR_THRESHOLD_IN_SECONDS = threshold;

            }

        }

        Integer intervalTmp = Integer.getInteger("org.apache.catalina.threadmonitor.interval"); //In seconds

        if (intervalTmp != null) {

            int interval = intervalTmp.intValue();

            if (interval >= 60 && interval <= 600) {

                THREAD_MONITOR_INTERVAL_IN_SECONDS = interval;

            } else if (interval <= 0) {

                monitoringEnabled = false;

            }

        }

    }

        createThreadPoolMonitor(corePoolSize);

        createThreadPoolMonitor(corePoolSize);

        createThreadPoolMonitor(corePoolSize);

        createThreadPoolMonitor(corePoolSize);

    private void createThreadPoolMonitor(int corePoolSize) {

        if (monitoringEnabled) {

            activeThreads = new ConcurrentHashMap<Runnable, MonitoredThread>(corePoolSize * 2); //TODO is initialSize ok?

            completedHungThreadsQueue = new ConcurrentLinkedQueue<CompletedHungThread>();

            timer = new Timer("ThreadPool monitor timer", true); //daemon

            MonitorTask monitorTask = new MonitorTask();

            timer.schedule(monitorTask, THREAD_MONITOR_INTERVAL_IN_SECONDS * 1000, THREAD_MONITOR_INTERVAL_IN_SECONDS * 1000); //delay, period

            log.debug("Monitoring threads with threshold = " + THREAD_MONITOR_THRESHOLD_IN_SECONDS + " sec, interval = " + THREAD_MONITOR_INTERVAL_IN_SECONDS + " sec");

        }

    }

    protected void beforeExecute(Thread thread, Runnable r) {

        super.beforeExecute(thread, r);

        if (monitoringEnabled) {

            //Save the thread/runnable

            //Keeping a reference to the thread object here does not prevent GC'ing,

            //as the reference is removed from the Map in afterExecute()

            activeThreads.put(r, new MonitoredThread(thread));

        }

    }

    /*

     * This method is invoked by the thread that executed the task

     */

    @Override

        super.afterExecute(r,t);

        if (monitoringEnabled) {

            MonitoredThread mt = activeThreads.remove(r);

            if (mt.isMarkedAsHung()) {

                completedHungThreadsQueue.add(new CompletedHungThread(mt.getThread().getName(), mt.getActiveTimeInMillis()));

        }

    }

    class MonitoredThread {

        //We need a reference to the thread to get a stack trace from the TimerTask

        private Thread thread;

        private long start = System.currentTimeMillis();

        private volatile boolean isHung = false;

        public MonitoredThread(Thread thread) {

            this.thread = thread;

        }

        public Thread getThread() {

            return this.thread;

        }

        public long getActiveTimeInMillis() {

            return System.currentTimeMillis() - start;

        }

        public void markAsHung() {

            this.isHung = true;

        }

        public boolean isMarkedAsHung() {

            return this.isHung;

        }

    }

    class CompletedHungThread {

        private String name;

        private long totalActiveTime;

        public CompletedHungThread(String name, long totalActiveTime) {

            this.name = name;

            this.totalActiveTime = totalActiveTime;

        }

        public String getName() {

            return this.name;

        }

        public long getTotalActiveTime() {

            return this.totalActiveTime;

        }

    }

    class MonitorTask extends TimerTask {

        public MonitorTask() {

        }

        @Override

        public void run() {

            //Check monitored threads

            for (MonitoredThread mt : activeThreads.values()) {

                long activeTime = mt.getActiveTimeInMillis();

                if (!mt.isMarkedAsHung() && activeTime >= THREAD_MONITOR_THRESHOLD_IN_SECONDS * 1000) {

                    int numHungThreads = hungCount.incrementAndGet();

                    mt.markAsHung();

                    notifyHungThreadDetected(mt.getThread().getName(), mt.getThread().getStackTrace(), activeTime, numHungThreads);

                }

            }

            //Check if any threads previously reported as hung, have finished.

            CompletedHungThread cht = completedHungThreadsQueue.poll();

            while (cht != null) {

                int numHungThreads = hungCount.decrementAndGet();

                notifyHungThreadCompleted(cht.getName(), cht.getTotalActiveTime(), numHungThreads);

                cht = completedHungThreadsQueue.poll();

            }

        }

    }

    //The following methods could be implemented using a Listener instead:

    //HungThreadListener

    //"onHungThreadDetected"

    //"onHungThreadCompleted"

    private void notifyHungThreadDetected(String threadName, StackTraceElement[] trace, long activeTime, int numHungThreads) {

        //TODO Add JMX notification ?

        String header = "Thread \"" + threadName + "\" has been active for " + activeTime + " milliseconds and may be hung. There is/are " + numHungThreads + " thread(s) in total in this thread pool that may be hung.";

        header += "\n" + getStackTraceAsString(trace);

        log.warn(header);

    }

    private void notifyHungThreadCompleted(String threadName, long activeTime, int numHungThreads) {

        //TODO Add JMX notification ?

        String msg = "Thread \"" + threadName + "\" was previously reported to be hung but has completed. It was active for approximately " + activeTime + " milliseconds. There is/are " + numHungThreads + " thread(s) in total in the server that still may be hung.";

        log.warn(msg); //Since the "hung thread notification" is warn, this should also be warn

    }

    //TODO Utility method, should be moved to utility class

    public static String getStackTraceAsString(StackTraceElement[] trace) {

        StringBuilder buf = new StringBuilder();

        for (int i = 0; i < trace.length; i++) {

            buf.append("\tat ").append(trace[i]).append("\n");

        }

        return buf.toString();

    }

    public void shutdownMonitorTimer(){

        if(timer != null){

            timer.cancel();

        }

    }

    @Override

    public void shutdown(){

        super.shutdown();

        shutdownMonitorTimer();

    }

    @Override

    public List<Runnable> shutdownNow(){

        List<Runnable> runnables = super.shutdownNow();

        shutdownMonitorTimer();

        return runnables;

    }