Servlet Timed Reloading

[Timy McTipperstan]

Not sure this is the correct way of doing this, but I have a servlet that builds a list on startup and makes it available to the application. However one issue my creep up, is if I only restart teh app 3 times a week (automated), then that list gets updated 3 times a week, there that list could change once a day.

Can I use a cron command to re-run that servlet, or is there some better solution.

[Ed B.]

Why not preiodically build it? Maybe using a thread which goes to sleep until the next schedule time or your application creates a thread which builds the list.



Adnan

[Timy McTipperstan]

Can you point me to an example of how that would work?

[James Carman]

I wrote a class for exactly this purpose. It's called TtlReference. Basically, it maintains a reference to an object for a TTL (time to live) amount of time. A separate thread runs in the background to clear references that have expired.

  
import java.util.TreeSet;
 
/**
 * The TtlReference class allows you to create a reference which will expire after a "time to live" (ttl) period.  All
 * TtlReferences will be added to a set, which will be managed by a separate thread.
 *
 * @author James Carman
 * @version 1.0
 */
public class TtlReference implements Comparable
{
    public static final long SECOND = 1000;
    public static final long MINUTE = 60 * SECOND;
    public static final long HOUR = 60 * MINUTE;
    public static final long DAY = 24 * HOUR;
 
//******************************************************************************
// Fields
//******************************************************************************
 
    private static TreeSet references = new TreeSet();
    private Object value;
    private final long expirationTime;
    private final Object monitor;
 
//******************************************************************************
// Static Methods
//******************************************************************************
 
    static
    {
        final Thread t = new Thread( new ReferenceQueueManager() );
        t.setDaemon( true );
        t.start();
    }
 
//******************************************************************************
// Constructors
//******************************************************************************
 
    /**
     * Creates a TtlReference referencing <code>value</code> valid until <code>ttl</code>
     * time (in milliseconds) elapses.
     *
     * @param value   the value of the reference
     * @param ttl     the "time to live" value
     * @param monitor a monitor to synchronize threads trying to use this reference
     */
    public TtlReference( Object value, long ttl, Object monitor )
    {
        this.monitor = monitor;
        this.expirationTime = System.currentTimeMillis() + ttl;
        this.value = value;
        synchronized( references )
        {
            references.add( this );
            references.notify();
        }
    }
 
    /**
     * Creates a TtlReference referencing <code>value</code> valid until <code>ttl</code>
     * time (in milliseconds) elapses.  The TtlReference object itself will be used as a
     * monitor to synchronize threads trying to use this reference.
     *
     * @param value the value of the reference
     * @param ttl   the "time to live" value
     */
    public TtlReference( Object value, long ttl )
    {
        this.monitor = this;
        this.expirationTime = System.currentTimeMillis() + ttl;
        this.value = value;
        synchronized( references )
        {
            references.add( this );
            references.notify();
        }
    }
 
//******************************************************************************
// Getters/Setters
//******************************************************************************
 
    /**
     * Returns the value held by this reference or null if <code>ttl</code> has expired.
     *
     * @return the value held by this reference or null if <code>ttl</code> has expired
     */
    public Object getValue()
    {
        synchronized( monitor )
        {
            if( System.currentTimeMillis() >= expirationTime )
            {
                value = null;
            }
            return value;
        }
    }
 
//******************************************************************************
// Interface Comparable
//******************************************************************************
 
    /**
     * Compares based upon the objects' remaining time to live.
     *
     * @param o another TtlReference
     * @return standard compareTo() method return values
     */
    public int compareTo( Object o )
    {
        long value = getRemainingTtl() - ( ( TtlReference ) o ).getRemainingTtl();
        if( value < 0 )
        {
            return -1;
        }
        if( value > 0 )
        {
            return 1;
        }
        return 0;
    }
 
//******************************************************************************
// Other Methods
//******************************************************************************
 
    private long getRemainingTtl()
    {
        return expirationTime - System.currentTimeMillis();
    }
 
//******************************************************************************
// Inner Classes
//******************************************************************************
 
    private static class ReferenceQueueManager implements Runnable
    {
        public void run()
        {
            // Run forever!
            while( true )
            {
                synchronized( references )
                {
                    try
                    {
                        if( !references.isEmpty() )
                        {
                            final TtlReference ref = ( TtlReference ) references.first();
                            if( ref.getValue() != null )
                            {
                                // Wait until this reference is going to expire...
                                references.wait( ref.getRemainingTtl() );
                            }
                            else
                            {
                                // Remove the reference, as it is no good anymore...
                                references.remove( ref );
                            }
                        }
                        else
                        {
                            // Wait indefinitely until a new reference is created...
                            references.wait();
                        }
                    }
                    catch( InterruptedException e )
                    {
                        // I've been interrupted by someone, so I must be done!
                        return;
                    }
                }
            }
        }
    }
}

[Ben Souther]

If you prefer not to get into threading (James did a nice job (t.setDaemon(true)), a one line cron job can get you the same results.

* 0 * * * wget -q <a href="http://localhost:8080/RefreshServlet" target="_blank" rel="nofollow">http://localhost:8080/RefreshServlet</a> > /dev/null 2>&1 

[Bear Bibeault]

a one line cron job can get you the same results.

That's how I do a lot of timed stuff. But it assumes you are using a real operating system.
[ March 02, 2005: Message edited by: Bear Bibeault ]

[James Carman]

Yes, cron will work fine if you have everything cached for the same duration (unless you want to maintain a bunch of cron commands). My solution is all Java and it works pretty well. There's no need to write a servlet which knows that it has to reload the objects at all. Your logic which accesses the data has to do a "lazy load" though. Actually, the real framework (I removed some code) has the option to place a listener on the reference so that you can auto-refresh the data behind the scenes, reducing the risk of a client having to wait for the refresh.