Coding challenge: a sliding window map

import java.util.*;

public class SlidingWindowMap
{
    public final static int     s_MaxKeyCount = 500;

    public final static long    s_NumMSIn10Min
                = 10 /*min*/ * 60 /*sec/min*/ * 1000 /*ms/sec*/;

    public final static int     s_NumberOfRequestsIn10Min_OnePerSecond
                = 10 /*min*/ * 60 /*sec/min*/ * 2;  // 2 per second or every 500 ms

    public final static long    s_TimeBetweenRequestsInMs = 500;

    // Input data members
    private Set<String>         m_Keys;
    private Iterator<String>    m_KeysIterator;
    private int             m_MaxCount;
    private long            m_PeriodMs;
    private KeyStyle        m_KeyStyle;

    // Throttled data members
    private long            m_LastTime;

    // Non-throttled data members
    private int         m_CurrentCount;

    enum KeyStyle
    {
        NoThrotle,
        Throtle
    }

    public static void main(String[] args)
    throws Exception
    {
        KeyStyle ks = KeyStyle.Throtle;

        if(args.length == 1)
        {
            String keyStyle = args[0];
            if(keyStyle.equalsIgnoreCase("-throttled"))
            {
                ks = KeyStyle.Throtle;
            }
            else if(keyStyle.equalsIgnoreCase("-nonthrottled"))
            {
                ks = KeyStyle.NoThrotle;
            }
        }

        Set<String> keys = generateKeys();

        SlidingWindowMap m = null;
        m = new SlidingWindowMap(keys, 500, s_NumMSIn10Min, ks);

        long start = System.currentTimeMillis();

        boolean firstNullAchieved = false;
        // Rate is greater than 500 in 10 min. ==> 2 per second. Null's should occur
        for(int i=0; i<s_NumberOfRequestsIn10Min_OnePerSecond; i++)
        {
            String key = m.getNextKey();
            System.out.println(key);

            if(key == null && firstNullAchieved == false)
            {
                long firstNull = System.currentTimeMillis();
                long whenFirstNullAchieved = firstNull - start;
                System.out.println("Time Of First Null = "+whenFirstNullAchieved);
                firstNullAchieved = true;
            }

            Thread.sleep(s_TimeBetweenRequestsInMs);
        }

        long stop = System.currentTimeMillis();

        long total = stop - start;

        System.out.println("Total Time = "+total);
    }

    private static Set<String> generateKeys()
    {
        Set<String> keys = new HashSet<String>();
        for(int i=0; i<s_MaxKeyCount; i++)
        {
            keys.add("Key"+i);
        }
        return keys;
    }

    public SlidingWindowMap(Set<String> keys, int maxCount, long periodMs)
    {
        this.m_Keys         = keys;
        this.m_KeysIterator = keys.iterator();
        this.m_MaxCount     = maxCount;
        this.m_PeriodMs     = periodMs;
    }

    public SlidingWindowMap(Set<String> keys, int maxCount, long periodMs, KeyStyle keyStyle)
    {
        this(keys, maxCount, periodMs);

        this.m_KeyStyle = keyStyle;
    }

    /**
     * @return a key that has been used less than 'maxCount' times during the
     * past 'periodMs' milliseconds or null if no such key exists.
     */
    public String getNextKey()
    {
        String key = null;
        if(this.m_KeyStyle == KeyStyle.NoThrotle)
        {
            key = getNonThrottledNextKey();
        }
        else if(this.m_KeyStyle == KeyStyle.Throtle)
        {
            key = getThrottledNextKey();
        }
        return key;
    }

    /**
     * To allow some keys to be accessible through the entire 10 min period.
         * Return a null for any additional requests over the rate of 0.8333 requests per second.
         * Every 1.2 seconds a valid key can be provided.
     */
    private String getThrottledNextKey()
    {
        String key = null;

        long currentTime = System.currentTimeMillis();
        if(currentTime - this.m_LastTime >= 1200)
        {
            if(this.m_KeysIterator.hasNext())
            {
                key = this.m_KeysIterator.next();
                this.m_LastTime = currentTime;
            }
        }

        return key;
    }

    /**
     * First come first serve, all keys may be used up in the first few minutes, leaving a range of
     * time at the end of the period that no keys are returned to any requests.
     */
    private String getNonThrottledNextKey()
    {
        String key = null;
        if(this.m_CurrentCount != this.m_MaxCount)
        {
            if(this.m_KeysIterator.hasNext())
            {
                key = this.m_KeysIterator.next();
            }
        }
        return key;
    }
}