BlogJava-yuyee-随笔分类-缓存http://www.blogjava.net/yuyee/category/46806.htmlzh-cnTue, 09 Nov 2010 10:02:23 GMTTue, 09 Nov 2010 10:02:23 GMT60linkedhashmap看看http://www.blogjava.net/yuyee/archive/2010/11/08/337579.html羔羊羔羊Mon, 08 Nov 2010 15:14:00 GMThttp://www.blogjava.net/yuyee/archive/2010/11/08/337579.htmlhashmap的构造函数中调用init()方法，而linkedhashmap中重写了init(),将head元素初始化
   void init() {
        header = new Entry<K,V>(-1, null, null, null);
        header.before = header.after = header;
    }

private final boolean accessOrder这个属性表示是否要根据访问顺序改变线性结构
在linkedhashmap中改写了hashmap的get()方法，增加了 e.recordAccess(this)，这个方法主要是根据accessOrder的值判断是否需要实现LRU，
 void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            if (lm.accessOrder) {
                lm.modCount++;
                remove();
                addBefore(lm.header);
            }
        }

addBefore这个方法是把刚访问的元素放到head的前面
 private void addBefore(Entry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }
put方法继承自hashmap,hashmap预留了 e.recordAccess(this)这个方法：
     public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

并通过重写 addEntry(hash, key, value, i)这个方法，实现LRU中的删除动作：
    void addEntry(int hash, K key, V value, int bucketIndex) {
        createEntry(hash, key, value, bucketIndex);

        // Remove eldest entry if instructed, else grow capacity if appropriate
        Entry<K,V> eldest = header.after;//找到最老的元素，这个在addBefore里确定，初次赋值是当只有一个head时候，你插入一个元素
        if (removeEldestEntry(eldest)) {//这个是受保护的方法，需要自己制定删除策略，比如size() > 最大容量,可自己实现，默认为false,也就是不开启
            removeEntryForKey(eldest.key);
        } else {
            if (size >= threshold)
                resize(2 * table.length);
        }
    }
自己重写这个方法，指定删除策略：
 protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
因此，可用linkedhashmap 构建一个基于LRU算法的缓存。


package com.google.study.cache;

import java.util.LinkedHashMap;
import java.util.concurrent.locks.ReentrantLock;

public class SimpleCache<K, V> extends LinkedHashMap<K, V> {

private int maxCapacity;
private ReentrantLock lock = new ReentrantLock();

public SimpleCache(int maxCapacity, float load_factory) {
super(maxCapacity, load_factory, true);
this.maxCapacity = maxCapacity;
}

public int getMaxCapacity() {
return maxCapacity;
}

public void setMaxCapacity(int maxCapacity) {
this.maxCapacity = maxCapacity;
}

@Override
protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
// TODO Auto-generated method stub
return super.removeEldestEntry(eldest);
}

public V get(Object key) {
lock.lock();
try {
return super.get(key);
} finally {
lock.unlock();
}

}

public V put(K k, V v) {
lock.lock();
try {
return super.put(k, v);
} finally {
lock.unlock();
}
}

@Override
public void clear() {
lock.lock();
try {
super.clear();
} finally {
lock.unlock();
}
}

@Override
public int size() {

lock.lock();
try {
return super.size();
} finally {
lock.unlock();
}
}

}





羔羊 2010-11-08 23:14 发表评论
]]>缓存的基本特性http://www.blogjava.net/yuyee/archive/2010/11/02/336820.html羔羊羔羊Tue, 02 Nov 2010 08:30:00 GMThttp://www.blogjava.net/yuyee/archive/2010/11/02/336820.html1.时间记录，进入Cache的时间
2.timeout过期时间，cache里面数据多久过期
3.eviction policy 清楚策略，最不经常访问的数据，最久没访问到的数据
4.命中率:Cache的数据被选中的比率
5.分级Cache，支持 Region分级，比如ehcache
6.分布式，分布在不同的计算机上
7.锁，事务，数据同步

各个Cluster之间的Cache同步有多种实现方法。比如JMS,RMI 
Cache中一般有get,put,remove,clear
对于Cluster的Cache来说，读(get)肯定是local的，只需要从本地内存中获取，而Remove/clear，需要和其他计算机同步，put可以是local的，因为如果读不到，可以从数据库中读
remote put:一台计算机把数据放到自己的Cache中，这个数据需要传播到Cluster其他计算机上，这样其他Cluster可以同步，但是如果数据大，传播的代价就大了
local put:只放到本地计算机的Cache里，不需要同步到其他Cluster，从Cache得不到的数据可以在数据库里读取


过期数据：在hibernate等orm工具中，有一个原则，就是不要把没有commit的数据放到缓存中，防止脏读，而且remove之后必须通知其他Cluster,保证大部分时间内，给用户的数据不是过期的数据
ORM Cache中，一般分2种Cache,一种是类缓存，一种是查询缓存，类缓存是以ID对应Entity对象，而查询缓存是用来存放一条查询语句对应的结果集，然后再到类缓存里找响应的实体。
类缓存：一类Entity一个Region
查询缓存:hibernate在一个地方维护每个表的最后更新时间，其实也就是放在上面org.hibernate.cache. UpdateTimestampsCache所指定的缓存配置里面，当通过hibernate更新的时候，hibernate会知道这次更新影响了哪些表。然后它更新这些表的最后更新时间。每个缓存都有一个生成时间和这个缓存所查询的表，当hibernate查询一个缓存是否存在的时候，如果缓存存在，它还要取出缓存的生成时间和这个缓存所查询的表，然后去查找这些表的最后更新时间，如果有一个表在生成时间后更新过了，那么这个缓存是无效的。 可以看出，只要更新过一个表，那么凡是涉及到这个表的查询缓存就失效了，因此查询缓存的命中率可能会比较低。

7


羔羊 2010-11-02 16:30 发表评论
]]>