public LRUCache() 
{
             
        super();
}

Constructs an LRU Cache.

 public LRUCache(int capacity) 
{
        this();
        maxEntries = capacity;
}

Constructors a LRU Cache of the specified capacity.

Parameters:

capacity - The maximum cache capacity.

 protected  void itemPut(Object key) 
{
        // Since this entry was just accessed, move it to the back of the list.
    	synchronized (list) { // A further fix for CACHE-44
    		list.remove(key);
            list.add(key);
        }
}

An object was put in the cache. This implementation adds/moves the key to the end of the list.

 protected  void itemRemoved(Object key) 
{
        list.remove(key);
}

Remove specified key since that object has been removed from the cache.

 protected  void itemRetrieved(Object key) 
{
        // Prevent list operations during remove
        while (removeInProgress) {
            try {
                Thread.sleep(5);
            } catch (InterruptedException ie) {
            }
        }
        // We need to synchronize here because AbstractConcurrentReadCache
        // doesn't prevent multiple threads from calling this method simultaneously.
        synchronized (list) {
            list.remove(key);
            list.add(key);
        }
}

An item was retrieved from the list. The LRU implementation moves the retrieved item's key to the front of the list.

 protected Object removeItem() 
{
        Object toRemove = null;
        removeInProgress = true;
        try {
        	while (toRemove == null) {
                try {
                    toRemove = removeFirst();
                } catch (Exception e) {
                    // List is empty.
                    // this is theorically possible if we have more than the size concurrent
                    // thread in getItem. Remove completed but add not done yet.
                    // We simply wait for add to complete.
                    do {
                        try {
                            Thread.sleep(5);
                        } catch (InterruptedException ie) {
                        }
                    } while (list.isEmpty());
                }
        	}
        } finally {
            removeInProgress = false;
        }
        return toRemove;
}

An item needs to be removed from the cache. The LRU implementation removes the first element in the list (ie, the item that was least-recently accessed).