java 自己写的内存堵塞队列

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

/**

 * 缓存

 * @author llk

 *

 */

public class MiniCache {

private static MiniCache miniCache;

private static final int CACHE_DEFAULT_CAPACITY = 1000;

private static final int QUEUE_DEFAULT_CAPACITY = 1000;

private static Map<String,BlockingQueue> cache;

private MiniCache() {

super();

}

/**

 * 获得MiniCache单例

 * @return

 */

synchronized public static MiniCache getInstance (){

if (miniCache == null) {

miniCache = new MiniCache();

cache = Collections.synchronizedMap(new HashMap<String,BlockingQueue>(CACHE_DEFAULT_CAPACITY));

}

return miniCache;

}

/**

 * 获取对象

 * @param key

 * @return

 */

public Object get(String key){

if (cache.containsKey(key)) {

if(cache.get(key).size() == 1){

Object o = cache.get(key).poll();

cache.remove(key);

return o;

}

return cache.get(key).poll();

}

return null;

}

/**

 * 获取对象，但不做移除操作

 * @param key

 * @return

 */

public Object getNoRemove(String key){

if(cache.containsKey(key)){

return cache.get(key).peek();

}

return null;

}

/**

 * 添加对象

 * @param key

 * @param value

 */

public void set(String key, Object value) {

if (cache.containsKey(key)) {

cache.get(key).add(value);

System.out.println(cache.get(key).size());

} else {

BlockingQueue list = new ArrayBlockingQueue(QUEUE_DEFAULT_CAPACITY);

list.add(value);

cache.put(key, list);

}

}

/**

 * 返回缓存区当前容量

 * @param key

 * @return

 */

public int size(String key){

if(cache.containsKey(key)){

return cache.get(key).size();

}

return 0;

}

}