场景：请使用Java 8实现缓存服务。
该服务可以提供中等级别的缓存同时访问。
要实施的访问操作包括：
1. get（key） - 此操作将获取列表中键的值。如果密钥不存在，则返回-1。
2. set（key，value） - 如果密钥不存在，此操作将在列表中插入新的键/值，否则不执行任何操作。
3.缓存的大小可通过属性文件进行配置
要求：1.实现具有最近最少使用（LRU）策略的通用基于内存的缓存作为列表
2.实现访问操作的并发性。
主要代码实现：
package dpnice.cache;
import dpnice.common.GlobalConstants;
import dpnice.util.ConfigurationUtils;
import org.apache.log4j.Logger;
import java.util.concurrent.*;
/**
* 维护两种淘汰策略(FIFO LRU)的高速缓存
*
* @author DPn!ce date 2018 07 12 上午 10:19
*/
public class FastCache<K, V> {
private final static Logger log = Logger.getLogger(FastCache.class);
/**
* 最大缓存大小
* 单位 byte
*/
private Long cacheSize;
/**
* 初始化内存大小
*/
private Long initCacheSize;
/**
* FIFO并发缓存容器
*/
private ConcurrentHashMap<Object, CacheNode> nodesFIFO;
/**
* FIFO并发缓存容器大小
*/
private int nodesFIFOCacheSize = 10000;
/**
* FIFO链表头
*/
private CacheNode firstFIFO;
/**
* FIFO链表尾
*/
private CacheNode lastFIFO;
/**
* LRU并发缓存容器
*/
private ConcurrentHashMap<Object, CacheNode> nodesLRU;
/**
* LRU链表头
*/
private CacheNode firstLRU;
/**
* LRU链表尾
*/
private CacheNode lastLRU;
public FastCache() {
setCacheSize();
initCacheSize = getCurrentSize();
nodesLRU = new ConcurrentHashMap<>();
nodesFIFO = new ConcurrentHashMap<>(nodesFIFOCacheSize);
}
/**
* 添加缓存
*
* @param key 键
* @param value 对应值
*/
public synchronized void put(K key, V value) {
CacheNode cacheNode = null;
try {
cacheNode = getCacheNode(key);
} catch (ExecutionException | InterruptedException e) {
e.printStackTrace();
}
if (cacheNode == null) {
//FIFO缓存容器是否已经超过大小
if (nodesFIFO.size() > nodesFIFOCacheSize) {
if (firstFIFO != null) {
//先进先出
nodesFIFO.remove(firstFIFO.getKey());
firstFIFO.getNext().setFront(null);
firstFIFO = firstFIFO.getNext();
}
}
cacheNode = new CacheNode();
cacheNode.setKey(key);
cacheNode.setValue(value);
nodesFIFO.put(key, cacheNode);
if (lastFIFO != null) {
lastFIFO.setNext(cacheNode);
cacheNode.setFront(lastFIFO);
}
lastFIFO = cacheNode;
if (firstFIFO == null) {
firstFIFO = lastFIFO;
}
}
//不等于空说明找到node 不进行操作
}
/**
* 获取缓存中对象
*
* @param key 键
* @return 对应Object
*/
public Object get(K key) {
CacheNode cacheNode = null;
try {
cacheNode = getCacheNode(key);
} catch (ExecutionException | InterruptedException e) {
e.printStackTrace();
}
return cacheNode == null ? -1 : cacheNode.getValue();
}
/**
* 获取缓存中对象
*
* @param key 键
* @return 对应CacheNode
*/
private CacheNode getCacheNode(K key) throws ExecutionException, InterruptedException {
CompletableFuture<CacheNode> cacheNodeCompletableFuture = CompletableFuture.supplyAsync(
() -> {
if (firstLRU != null && firstLRU.getKey() == key) {
return firstLRU;
//本身就在第一个 不需要做移动
} else {
CacheNode node = nodesLRU.get(key);
if (node != null) {
//移动到第一个
moveToHead(node);
return node;
} else {
CacheNode node1 = nodesFIFO.get(key);
if (node1 != null) {
//从fifo队列删除 及fifo容器中删除
removeFIFO(node1);
//并添加到lru顶部 及lru链表顶部
putNodesLRU(node1);
return node1;
} else {
return null;
}
}
}
});
return cacheNodeCompletableFuture.get();
}
/**
* 表示这个节点最近被使用 -> 移动到链表头
*
* @param nodeLRU 存放在LRU缓存容器中的node
*/
private void moveToHead(CacheNode nodeLRU) {
if (nodeLRU.getFront() != null) {
//将nodeLRU的前一个的下一个指向nodeLRU的下一个
nodeLRU.getFront().setNext(nodeLRU.getNext());
}
if (nodeLRU.getNext() != null) {
//将nodeLRU的下一个的前一个指向nodeLRU前一个
nodeLRU.getNext().setFront(nodeLRU.getFront());
}
if (lastLRU == nodeLRU) {
//将尾部替换为lastLRU的上一个
lastLRU = nodeLRU.getFront();
}
if (firstLRU != null) {
nodeLRU.setNext(firstLRU);
firstLRU.setFront(nodeLRU);
}
firstLRU = nodeLRU;
//说明为链表头
nodeLRU.setFront(null);
if (lastLRU == null) {
lastLRU = firstLRU;
nodeLRU.setNext(null);
}
}
/**
* 从FIFO链表删除某一个node
*
* @param nodeFIFO 在FIFO中的node
*/
private void removeFIFO(CacheNode nodeFIFO) {
//从fifo容器中删除
nodesFIFO.remove(nodeFIFO.getKey());
if (lastFIFO == nodeFIFO) {
if (lastFIFO.getFront() != null) {
lastFIFO.getFront().setNext(null);
lastFIFO = lastFIFO.getFront();
} else {
firstFIFO = null;
}
lastFIFO = nodeFIFO.getFront();
} else {
CacheNode index = lastFIFO.getFront();
while (index != null) {
if (index == nodeFIFO) {
if (index.getFront() != null) {
index.getFront().setNext(index.getNext());
} else {
firstFIFO = index.getNext();
}
index.getNext().setFront(index.getFront());
break;
}
//改变下标
index = index.getFront();
}
}
}
/**
* 第二次使用存入lru容器
*
* @param newNode 新的缓存node 从FIFO队列里拿出的node
*/
private void putNodesLRU(CacheNode newNode) {
newNode.setFront(null);
newNode.setNext(null);
if (firstLRU != null) {
firstLRU.setFront(newNode);
newNode.setNext(firstLRU);
}
firstLRU = newNode;
//判断当前内存是否超过
if (getCurrentSize() - initCacheSize > cacheSize) {
if (lastLRU != null) {
nodesLRU.remove(lastLRU.getKey());
if (lastLRU.getFront() != null) {
lastLRU.getFront().setNext(null);
} else {
//第一个也是最后一个
firstLRU = null;
}
lastLRU = lastLRU.getFront();
}
}
nodesLRU.put(newNode.getKey(), newNode);
}
/**
* 获得当前可用内存
*
* @return 可用内存
*/
private Long getCurrentSize() {
return Runtime.getRuntime().freeMemory();
}
private void setCacheSize() {
//从配置文件中获取
String cacheUnit = ConfigurationUtils.getString(GlobalConstants.MEMORY_CACHE_UNIT);
Long cacheSize = Long.valueOf(ConfigurationUtils.getInteger(GlobalConstants.MEMORY_CACHE_SIZE));
switch (cacheUnit) {
case "gb":
this.cacheSize = cacheSize * 1024 * 1024 * 1024;
break;
case "mb":
this.cacheSize = cacheSize * 1024 * 1024;
break;
case "kb":
this.cacheSize = cacheSize * 1024;
break;
case "GB":
this.cacheSize = cacheSize * 1024 * 1024 * 1024;
break;
case "MB":
this.cacheSize = cacheSize * 1024 * 1024;
break;
case "KB":
this.cacheSize = cacheSize * 1024;
break;
default:
log.error("缓存大小单位 " + cacheUnit + " 未识别，请使用kb mb gb");
break;
}
}
public void printLRUSortASC() {
int count = 0;
CacheNode next = firstLRU;
while (next != null) {
count++;
System.out.println("LRU 第 " + count + " 个 key:" + next.getKey() + " value:" + next.getValue());
next = next.getNext();
}
}
public void printFIFOSortASC() {
int count = 0;
CacheNode next = firstFIFO;
while (next != null) {
count++;
System.out.println("FIFO 第 " + count + " 个 key:" + next.getKey() + " value:" + next.getValue());
next = next.getNext();
}
}
}测试代码：
package dpnice.cache;
import org.junit.Test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import static org.junit.Assert.*;
/**
* @author DPn!ce date 2018 07 13 下午 2:25
*/
public class FastCacheTest {
private FastCache<String, String> fastCache = new FastCache<>();
@Test
public void put() throws Exception {
fastCache.put("id1", "message:缓存的消息1");
fastCache.put("id1", "message:缓存的消息1");
fastCache.put("id2", "message:缓存的消息2");
fastCache.put("id3", "message:缓存的消息3");
fastCache.put("id4", "message:缓存的消息4");
fastCache.put("id1", "message:缓存的消息1");
fastCache.put("id2", "message:缓存的消息2");
fastCache.put("id3", "message:缓存的消息3");
fastCache.put("id4", "message:缓存的消息4");
fastCache.put("id2", "message:缓存的消息2");
fastCache.put("id2", "message:缓存的消息2");
// Thread.sleep(2000L);
System.out.println("id2 ->" + fastCache.get("id2"));
System.out.println("id4 ->" + fastCache.get("id4"));
System.out.println("id1 ->" + fastCache.get("id1"));
System.out.println("id3 ->" + fastCache.get("id3"));
fastCache.printLRUSortASC();
}
@Test
public void get() throws Exception {
System.out.println(fastCache.get("id2"));
System.out.println(fastCache.get("id4"));
System.out.println(fastCache.get("id1"));
System.out.println(fastCache.get("id3"));
}
@Test
public void put2() throws Exception {
for (int i = 1; i < 5; i++) {
fastCache.put("id" + i, "message:缓存的消息" + i);
}
//初始顺序： 4-3-2-1
fastCache.printFIFOSortASC();
//最近访问的在最顶部
System.out.println(fastCache.get("id1"));
System.out.println(fastCache.get("id3"));
//预期顺序： LRU:3-1 FIFO:2-4
fastCache.printLRUSortASC();
fastCache.printFIFOSortASC();
}
@Test
public void multithreadingTest() throws Exception {
for (int i = 0; i < 10000; i++) {
fastCache.put("id" + i, "message:缓存的消息" + i);
}
ExecutorService executor = Executors.newFixedThreadPool(10);
// fastCache.printFIFOSortASC();
//最近访问的在最顶部
for (int i = 0; i < 1000000; i++) {
executor.submit(() -> {
Double v = Math.random() * 10000;
String o = fastCache.get("id" + v.intValue()) + "";
// System.out.println(o);
});
}
// fastCache.printLRUSortASC();
// fastCache.printFIFOSortASC();
}
}随机获取100W缓存结果：
