package com.zuidaima.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 
 * 内存缓存工具类
 * @author luoy
 *
 * @param <K>
 * @param <V>
 */
public class MemoryCacheUtil<K, V> {

	// 缓存
		private Map<K, V> cache = new HashMap<K, V>();
		
		private final ReentrantReadWriteLock RL = new ReentrantReadWriteLock();
		private final Lock R = RL.readLock();
	    private final Lock W = RL.writeLock();

	    /**
	     * 根据key获取缓存信息
	     * 
	     * @param key
	     * 
	     * @return
	     */
	    public V get(K key){
	    	R.lock();
	    	try{
	    		return cache.get(key);
	    	} finally {
	    		R.unlock();
	    	}
	    }
	    
	    /**
	     * 设置缓存
	     * 
	     * @param key
	     * @param value
	     */
	    public void put(K key, V value){
	    	W.lock();
	    	
	    	try{
	    		cache.put(key, value);
	    	} finally {
	    		W.unlock();
	    	}
	    }
	    
	    /**
	     * 根据key移除缓存
	     * 
	     * @param key
	     */
	    public void remove(K key){
	    	W.lock();
	    	
	    	try{
	    		cache.remove(key);
	    	} finally {
	    		W.unlock();
	    	}
	    }
	    
	    /**
	     * 移除所有缓存
	     */
	    public void removeAll(){
	    	W.lock();
	    	
	    	try{
	    		cache.clear();
	    	} finally {
	    		W.unlock();
	    	}
	    }
	    
	    /**
	     * 获得缓存内容，克隆数据，不同的内存块
	     * 
	     * @return
	     */
	    public Map<K, V> getCache(){
	    	W.lock();
	    	
	    	try{
	    		return new HashMap<K, V>(cache);
	    	} finally {
	    		W.unlock();
	    	}
	    }
}