TimerManager.java

package org.objectweb.jonas_timer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import org.objectweb.util.monolog.api.BasicLevel;

class Clock extends Thread {

    private TimerManager tmgr;

    public Clock(TimerManager tmgr) {
        super("JonasClock");
        TraceTimer.logger.log(BasicLevel.DEBUG, "Clock constructor");
        this.tmgr = tmgr;
    }

    public void run() {
        tmgr.clock();
    }
}

class Batch extends Thread {

    private TimerManager tmgr;

    public Batch(TimerManager tmgr) {
        super("JonasBatch");
        TraceTimer.logger.log(BasicLevel.DEBUG, "Batch constructor");
        this.tmgr = tmgr;
    }

    public void run() {
        tmgr.batch();
    }
}

public class TimerManager {

    // threads managing the service.
    private static Batch batchThread;
    private static Clock clockThread;

    private final static long PERIOD_MAX = 30000; // 30 sec
    private final static long PERIOD_MIN = 100; // 1/10 sec
    private long period;
    private long minremtime = PERIOD_MAX;

    // lists
    private ArrayList timerList = new ArrayList();
    private ArrayList expiredList = new ArrayList();

    private static TimerManager unique = null;
    private static boolean shuttingdown = false;

    private TimerManager() {
        // launch threads for timers
        batchThread = new Batch(this);
        batchThread.start();
        clockThread = new Clock(this);
        clockThread.start();
    }

    public static TimerManager getInstance() {
        if (unique == null)
            unique = new TimerManager();
        return unique;
    }

    public static void stop(boolean force) {
        TraceTimer.logger.log(BasicLevel.DEBUG,"Stop TimerManager");
        TimerManager tmgr = getInstance();
        shuttingdown = true;
        while (clockThread.isAlive() || batchThread.isAlive()) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                break;
            }
        }
        TraceTimer.logger.log(BasicLevel.DEBUG,"TimerManager has stopped");
    }

    public static void stop() {
        stop(true);
    }


    public void clock() {
        synchronized(timerList) {
            while (true) {
                // compute time to sleep
                if (shuttingdown) {
                    period = 1;
                } else {
                    period = PERIOD_MAX;
                    if (minremtime < period) {
                        period = minremtime < PERIOD_MIN ? PERIOD_MIN : minremtime;
                    }
                }
                // must sleep a little less than period
                try {
                    timerList.wait(period);
                } catch (InterruptedException e) {
                    TraceTimer.logger.log(BasicLevel.ERROR, "Timer interrupted");
                }
                int found = 0;
                boolean empty = true;
                minremtime = PERIOD_MAX;
                for (Iterator i = timerList.iterator(); i.hasNext(); ) {
                    TimerEvent t = (TimerEvent) i.next();
                    if (!t.isStopped()) {
                        empty = false;
                    }
                    long remtime = t.update();
                    if (remtime <= 0) {
                        if (t.valid()) {
                            expiredList.add(t);
                            found++;
                            if (t.ispermanent() && !shuttingdown) {
                                remtime = t.restart();
                                if (remtime < minremtime) {
                                    minremtime = remtime;
                                }
                            } else {
                                i.remove();
                            }
                        } else {
                            i.remove();
                        }
                    } else {
                        if (remtime < minremtime) {
                            minremtime = remtime;
                        }
                    }
                    // Be sure there is no more ref on bean in this local variable.
                    t = null;
                }
                if (found > 0) {
                    timerList.notifyAll();
                } else {
                    if (empty) {
                        if (shuttingdown) {
                            break;
                        }
                    }
                }
            }
            timerList.notifyAll();
        }
    }

    public void batch() {

        while (!(shuttingdown && timerList.isEmpty() && expiredList.isEmpty())) {
            TimerEvent t;
            synchronized(timerList) {
                while (expiredList.isEmpty()) {
                    if (shuttingdown) {
                        TraceTimer.logger.log(BasicLevel.WARN, "TimerManager shutting down");
                        return;
                    }
                    try {
                        timerList.wait();
                    } catch (Exception e) {
                        TraceTimer.logger.log(BasicLevel.ERROR, "Exception in Batch: ",e);
                    }
                }
                t = (TimerEvent) expiredList.remove(0);
            }
            // Do not keep the lock during the processing of the timer
            try {
                t.process();
            } catch (Exception e) {
                // An exception in a timer process should not stop this thread.
                TraceTimer.logger.log(BasicLevel.WARN, "Ignoring exception: " + e);
                e.printStackTrace();
            }
        }
        TraceTimer.logger.log(BasicLevel.WARN, "TimerManager stopped");
    }

    public TimerEvent addTimer(TimerEventListener tel, long timeout, Object arg, boolean permanent) {
        return addTimerMs(tel, timeout * 1000, arg, permanent);
    }

    public TimerEvent addTimerMs(TimerEventListener tel, long timeout, Object arg, boolean permanent) {
        TimerEvent te = new TimerEvent(tel, timeout, arg, permanent);
        synchronized(timerList) {
            timerList.add(te);
            if (timeout < minremtime) {
                minremtime = timeout;
            }
            timerList.notifyAll();
        }
        return te;
    }

    public void removeTimer(TimerEvent te) {
        synchronized(timerList) {
            timerList.remove(timerList.indexOf(te));
        }
    }
}

---