由于实验室在一个项目中用到了Memcached分布式缓存，自己这段时间也对分布式缓存深入学习了一下，本文就总结一下自己的收获，还是从Memcached是什么谈起吧。

Memcached是什么

Memcached是一款高性能的分布式内存对象缓存系统，使用它可以减少应用系统对数据库的直接访问，减轻了数据库负载，并且提升了应用程序的响应速度。可以将Memcached比作一个巨大的、存储了很多

LRU算法

操作系统的页面置换算法中也包括该算法，这种算法非常适合于缓存系统。它基于一种假设：过去一段时间使用频率最低的数据，将来也会很少使用。下面是我自己实现的一个基于LRU算法的缓存，它实现了基本的缓存功能，不过需要改进的一点是该缓存应该是单例的。

package colin.cache;

/**
 * 
 * @author Colin Wang
 * Created on Apr 18, 2015
 */
public class LRUCache {
    private static final int DEFAULT_MAX_SIZE = 10;
    private Object[] elements;
    private int size;

    public LRUCache(int maxSize) {
        elements = new Object[maxSize];
    }

    public LRUCache() {
        this(DEFAULT_MAX_SIZE);
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public boolean isFull() {
        return size == elements.length;
    }

    /**
     * 返回元素在数组中的位置
     * 
     * @param element
     * @return
     */
    public int indexOf(Object element) {
        for (int i = 0; i < size; i++) {
            if (element.equals(elements[i])) {
                return i;
            }
        }
        return -1;
    }

    public Object push(Object element) {
        int index = -1;
        if (!isFull() && indexOf(element) == -1) {
            // 缓存未满，并且其中不含有待插入的元素
            elements[size++] = element;
        } else if (isFull() && indexOf(element) == -1) {
            // 缓存已满，并且其中不含有待插入的元素
            for (int i = 0; i < size - 1; i++) {
                elements[i] = elements[i + 1];
            }
            elements[size - 1] = element;
        } else {
            index = indexOf(element);
            for (int i = index; i < size - 1; i++) {
                elements[i] = elements[i + 1];
            }
            elements[size - 1] = element;
        }
        return index == -1 ? null : elements[index];
    }

    public void show() {
        for (int i = 0; i < size; i++) {
            System.out.print(elements[i].toString() + " ");
        }
    }
}

static int indexFor(int h, int length) {
    return h & (length-1);
}