java缓存系统

第一版

package cache;

import java.util.HashMap;
import java.util.Map;

public class Cache1 {
	private Map<String, Object> map=new HashMap<String, Object>();

	private static Cache1 cache1=new Cache1();
	private Cache1(){

	}
	public static  Cache1 getInstanceCache1(){
		return cache1;
	}

	public void setObject(String key,Object value){
		map.put(key, value);
	}

	public Object getObject(String key){
		Object value=null;
		value=map.get(key);
		if (value==null) {
			value=getFromDB(key); // 从远程数据库获得
			map.put(key, value);
		}
		return value;
	}
	/**
	*仅仅只是模拟
	*/
	private Object getFromDB(String key) {
		return null;
	}
}

所谓的缓存,就是把经常用的数据存储到内存中,下次用的时候能很快的拿到。因而,上面的核心代码其实就是getObject。但是,得承认,上面的代码实在是太过简陋了。上面的测试程序很简单我就不写了。

第二版

之前第一版的缓存只是个实例代码,还算不上工具,因为它并没有对某一个"计算"操作做包装。我知道我说的很模糊,咱们看代码。

package cache;

public interface GetResutl {
	public Object get(Object o);
}

package cache;

public class ComputeSum implements GetResutl {

	@Override
	public Object get(Object o) {
		if (      !(o instanceof Integer)   ){
			throw new IllegalArgumentException (o+"is not Integer");

		}
		int n=(int) o;
		int result=0;
		for (int i = 1; i <= n; i++) {
			result+=i;
		}
		return result;
	}

}

package cache;

public class ComputeMultiply implements GetResutl {

	@Override
	public Object get(Object o) {
		if (      !(o instanceof Integer)   ){
			throw new IllegalArgumentException (o+"is not Integer");

		}
		int n=(int) o;
		int result=1;
		for (int i = 1; i <= n; i++) {
			result*=i;
		}
		return result;
	}

}

第一版的缓存系统,不能缓存某种操作的结果。

看了上面的连加,与连乘。

我们就大概知道新的缓存该是个什么样了。

package cache;

import java.util.HashMap;
import java.util.Map;

public  class Cache2 {
	private Map<String, Object> map=new HashMap<String, Object>();
	private GetResutl getResutl=null;

	public Cache2(GetResutl r){
		this.getResutl=r;
	}

	public void setObject(String key,Object value){
		map.put(key, value);
	}

	public Object getObject(String key){
		Object value=null;
		value=map.get(key);
		if (value==null) {
			value=getResutl.get(key);
			map.put(key, value);
		}
		return value;
	}
}

另外多嘴一句,Cahe2中有一个接口GetResut,之后再调用GetResult的某一个方法,这种设计似乎叫做策略模式。

第三版

如果ComputeMultiply中的get方法的运行需要花很长时间,同时我们也不着急要它计算的结果,第二版的计算是放在一个线程里的,这样效率不高。

我们试试CallAble。

package cache;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ComputeSum implements GetResutl {

	@Override
	public Object get(Object o) {

		final Long n=Long.valueOf((String) o);

		Callable<Long> c=new Callable<Long>() {
			@Override
			public Long call(){
				Long result=0L;
				for (int i = 1; i <= n; i++) {
					result+=i;
				}
				return result;
			}
		};

		return new FutureTask<>(c);
	}
}

连乘的写法与之类似,不再赘述。

再看cache的写法。

</pre><pre name="code" class="java">package cache;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public  class Cache3 {
	private Map<String, FutureTask<Object>> map=new HashMap<String, FutureTask<Object> >();
	private GetResutl getResutl=null;

	public Cache3(GetResutl r){
		this.getResutl=r;
	}

	@SuppressWarnings("unchecked")
	public Object getObject(String key){
		FutureTask<Object> value=null;
		FutureTask<Object> ft=map.get(key);
		if (ft==null) {
			value= (FutureTask<Object>) getResutl.get(key);
			map.put(key, value);
			ft=value;
		}
		ft.run();
		Object result=null;
		try {
			result = ft.get();
		} catch (InterruptedException | ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
	}

我们看看版本三的测试代码

public static void main(String[] args) {
		GetResutl getResutl=new ComputeSum();
		Cache3 c3=new Cache3(getResutl);

		long t1=0;
		long t2=0;

		t1=System.currentTimeMillis();
		System.out.println(c3.getObject(""+1234566));
		t2=System.currentTimeMillis();
		System.out.println(t2-t1 );

		t1=System.currentTimeMillis();
		System.out.println(c3.getObject(""+1234566));
		t2=System.currentTimeMillis();
		System.out.println(t2-t1 );

		t1=System.currentTimeMillis();
		System.out.println(c3.getObject(""+1234567));
		t2=System.currentTimeMillis();
		System.out.println(t2-t1 );

		t1=System.currentTimeMillis();
		System.out.println(c3.getObject(""+1234567));
		t2=System.currentTimeMillis();
		System.out.println(t2-t1 );

		t1=System.currentTimeMillis();
		System.out.println(c3.getObject(""+1234567));
		t2=System.currentTimeMillis();
		System.out.println(t2-t1 );
	}

输出:

762077221461

16

762077221461

0

762078456028

15

762078456028

0

762078456028

0

第四版

java并发编程中提到的一个例子。

import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

interface Computable<K,V>{
    V compute(final K arg);
}

/**
 * 实现简单缓存系统
 * @author mzy
 *
 * @param <K> key
 * @param <V> value
 */
public class FutureCache<K,V> implements Computable<K,V>{
    private final ConcurrentHashMap<K, Future<V>> cache = new ConcurrentHashMap<K ,Future<V>>();
    private final Computable<K, V> c;
    public FutureCache(Computable<K, V> c) {
        this.c = c;
    }

    @Override
    public V compute(final K key) {
        while(true){
            Future<V> future = cache.get(key);
            if(future == null){
                Callable<V> eval = new Callable<V>() {
                    @Override
                    public V call() throws Exception { return c.compute(key); }
                };
                FutureTask<V> ftask = new FutureTask<V>(eval);
                //使用putIfAbsent原子操作避免有上面if(future == null)引起的相同值的缺陷
                future = cache.putIfAbsent(key, ftask);
                if(future == null) { future = ftask; ftask.run(); }
            }
            try {
                return future.get();
            } catch (InterruptedException e) {
                //出现中断异常应该从 cache中移除Future，防止缓存污染
                cache.remove(key,future);
            } catch (ExecutionException e) {
                //执行中的异常应当抛出，获得恰当处理
                throw new RuntimeException(e.getCause());
            }
        }
    }

}

测试程序:
public class Test {
    public static void main(String[] args) {
        final Computable<Integer, Integer> c = new Computable<Integer, Integer>() {
            @Override
            public Integer compute(Integer arg) {
                Integer sum = 0;
                for(Integer i=0;i<arg;i++){
                    sum+=i;
                }
                return sum;
            }
        };
        final Computable<Integer, Integer> cache = new FutureCache<Integer,Integer>(c);
        long start = System.currentTimeMillis();
        cache.compute(10000);
        long stop = System.currentTimeMillis();
        System.out.println(stop-start);
        start = System.currentTimeMillis();
        cache.compute(10000);
        stop = System.currentTimeMillis();
        System.out.println(stop-start);
        start = System.currentTimeMillis();
        cache.compute(10000);
        stop = System.currentTimeMillis();
        System.out.println(stop-start);
        start = System.currentTimeMillis();
        cache.compute(10000);
        stop = System.currentTimeMillis();
        System.out.println(stop-start);
    }
}

参考资料

http://my.oschina.net/ccdvote/blog/131876?p=1