java缓存系统

程序员小董

已于 2023-09-13 16:34:43 修改

阅读量1.4k

点赞数

分类专栏： javase 文章标签： java 缓存系统 future callable

于 2015-08-06 10:44:38 首次发布

本文链接：https://blog.csdn.net/dlf123321/article/details/47312907

版权

javase 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

第一版

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);
    }
}

基于LinkedHashMap的LRU缓存

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

    private final int maxElements;

    public MaxSizeLruCacheDemo(int maxSize) {
        super(maxSize, 0.75F, true);
        maxElements = maxSize;
    }

    protected boolean removeEldestEntry(java.util.Map.Entry eldest) {
        // 超出容量
        return size() > maxElements;
    }
}

class MaxSizeLruCacheDemoTest {

    @Test
    public void test(){
        MaxSizeLruCacheDemo<Integer,Integer> maxSizeLruCacheDemo = new MaxSizeLruCacheDemo<>(5);
        maxSizeLruCacheDemo.put(1,1);
        maxSizeLruCacheDemo.put(2,2);
        maxSizeLruCacheDemo.put(3,3);
        maxSizeLruCacheDemo.put(4,4);
        maxSizeLruCacheDemo.put(5,5);
        System.out.println(maxSizeLruCacheDemo);

        maxSizeLruCacheDemo.put(6,6);
        System.out.println(maxSizeLruCacheDemo);


        maxSizeLruCacheDemo.get(2);
        System.out.println(maxSizeLruCacheDemo);
        maxSizeLruCacheDemo.put(7,7);
        System.out.println(maxSizeLruCacheDemo);

    }
}