這是我的代碼的基本框架：
以下是我的代碼：
package com.test;
public class Object1 {
private String s1;
private String s2;
public String getS1() {
return s1;
}
public void setS1(String s1) {
this.s1 = s1;
}
public String getS2() {
return s2;
}
public void setS2(String s2) {
this.s2 = s2;
}
}
package com.test;
public class Object2 {
private int i1;
private int i2;
public int getI1() {
return i1;
}
public void setI1(int i1) {
this.i1 = i1;
}
public int getI2() {
return i2;
}
public void setI2(int i2) {
this.i2 = i2;
}
}
package com.test;
public class Engine {
private Cache cache = new Cache();
private static Engine instance = null;
/**
* single instance mode
*/
private Engine() {
}
public Cache getCache() {
return cache;
}
public static Engine getInstance() {
synchronized (Engine.class) {
if (instance == null) {
instance = new Engine();
}
}
return instance;
}
}
package com.test;
import java.util.concurrent.locks.*;
public class HandleLock {
private String handle;
private ReentrantLock lock;
public HandleLock() {
lock = new ReentrantLock();
}
public String getHandle() {
return handle;
}
public void setHandle(String handle) {
this.handle = handle;
}
public ReentrantLock getLock() {
return lock;
}
public void setLock(ReentrantLock lock) {
this.lock = lock;
}
}
package com.test;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
/**
* Just as the class name indicates, this is a cache.
*
*
*/
public class Cache {
/**
* map1 and map2 are used to store the actual useful information.
* The key of map1 and map2 is CacheInfo.genKey()
*/
private Map<String, Object1> map1 = new HashMap<String, Object1>();
private Map<String, Object2> map2 = new HashMap<String, Object2>();
/**
* store the CacheInfo object in this order: the first is the most recently used,
* and the last is the least recently used. For example, the first is used in 17:03,
* the second is used in 17:01, the third is used in 17:00, and so on.
* So the CacheInfo object in the end are more likely to be removed when the cache is full.
* That the cache is full means the size of the link is larger than cacheSize (the next parameter in this class).
* Every CacheInfo object in link has its information stored in map1 and map2, i.e.
* they are corresponding to each other. And so
* if link.size() is 8, map1.size() and map2.size() are both 8.
*/
private LinkedList<CacheInfo> link = new LinkedList<CacheInfo>();
int cacheSize = 10;
/**
* The key of lockMap is CacheInfo.genKey(), i.e. is the same as map1 and map2.
* Every CacheInfo object in link has its corresponding HandleLock in lockMap and of course every key
* in map1 and map2 has its corresponding HandleLock in lockMap.
*/
private HashMap<String, HandleLock> lockMap = new HashMap<String, HandleLock>();
public Object1 getObject1(String s) {
return map1.get(s);
}
public Object2 getObject2(String s) {
return map2.get(s);
}
public void removeObject1(String s) {
map1.remove(s);
}
public void removeObject2(String s) {
map2.remove(s);
}
public synchronized void removeFromLink(CacheInfo cacheInfo) {
this.link.remove(cacheInfo);
}
public synchronized boolean isExist(CacheInfo cacheInfo) {
return link.contains(cacheInfo);
}
public synchronized boolean needRemove() {
return link.size() >= cacheSize;
}
public synchronized void addToHead(CacheInfo cacheInfo) {
link.addFirst(cacheInfo);
}
public synchronized void adjustToHead(CacheInfo cacheInfo) {
CacheInfo head = link.getFirst();
if (head.equals(cacheInfo) == false) {
link.remove(cacheInfo);
link.addFirst(cacheInfo);
}
}
public synchronized HandleLock getLock(String cacheInfoKey) {
HandleLock lock = lockMap.get(cacheInfoKey);
if (lock == null) {
lock = new HandleLock();
lock.setHandle(cacheInfoKey);
lockMap.put(cacheInfoKey, lock);
}
return lock;
}
/**
* search from the end to get the first unused, i.e. the lock is not locked
* @return
*/
public synchronized CacheInfo getLastUnused() {
for (int i = link.size() - 1; i >= 0; i--) {
CacheInfo cacheInfo = link.get(i);
HandleLock lock = lockMap.get(cacheInfo.genKey());
if (lock.getLock().isLocked() == false) {
return cacheInfo;
}
}
return null;
}
}
package com.test;
/**
*
* check if the information about the current CacheInfo object is in the Cache.
* If not in Cache, load from DB.
* If in Cache, just return.
*
*/
public class CacheHandler {
public static void doCache(CacheInfo cacheInfo) {
Cache cache = Engine.getInstance().getCache();
boolean flag = cache.isExist(cacheInfo);
if (flag) {
cache.adjustToHead(cacheInfo);
return;
}
loadFromDB(cacheInfo);
}
private static void loadFromDB(CacheInfo cacheInfo) {
Cache cache = Engine.getInstance().getCache();
// to check if the cache is full, if is full, circularly remove the unused information from the cache
synchronized (cache) {
boolean needRemove = cache.needRemove();
while (needRemove) {
CacheInfo removeCacheInfo = cache.getLastUnused();
if (removeCacheInfo != null) {
HandleLock removeLock = cache.getLock(removeCacheInfo.genKey());
// lock to make sure the removeCacheInfo is not currently used by some object in Reader
removeLock.getLock().lock();
try {
// remove information about removeCacheInfo in cache
cache.removeFromLink(removeCacheInfo);
cache.removeObject1(removeCacheInfo.genKey());
cache.removeObject2(removeCacheInfo.genKey());
} finally {
removeLock.getLock().unlock();
}
} else {
break;
}
needRemove = cache.needRemove();
}
}
// read from DB about the information of cacheInfo, and put them into cache, omit this code
// if read successfully from DB
cache.addToHead(cacheInfo);
}
}
package com.test;
public class CacheInfo {
private String pkgId;
private String tmplId;
public CacheInfo(String pkgId, String tmplId) {
this.pkgId = pkgId;
this.tmplId = tmplId;
}
public String genKey() {
return pkgId + "_" + tmplId;
}
public String getPkgId() {
return pkgId;
}
public void setPkgId(String pkgId) {
this.pkgId = pkgId;
}
public String getTmplId() {
return tmplId;
}
public void setTmplId(String tmplId) {
this.tmplId = tmplId;
}
}
package com.test;
public class Reader {
public Object1 read(CacheInfo cacheInfo) {
Cache cache = Engine.getInstance().getCache();
HandleLock lock = cache.getLock(cacheInfo.genKey());
// lock so no one will remove the information about this CacheInfo object from Cache in CacheHandler
lock.getLock().lock();
try {
CacheHandler.doCache(cacheInfo);
return cache.getObject1(cacheInfo.genKey());
} finally {
lock.getLock().unlock();
}
}
}
運行我的代碼的方式是跑最后的Reader類中的read函式。但是當多個用戶并發去調這個函式時，由于快取大小有限，會出現回傳值為null的情況。但是我不明白，因為我在read方法中每次獲取前會先lock住，然后在CacheHandler中每次洗掉前也會先lock住，這樣按理不會出現read方法中需要讀取的資料被CacheHandler中洗掉時刪掉，因為它首先就無法lock住。請各位大俠幫我看看，我已經花了兩周了，再搞不定老板要滅了我了。
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/42841.html
標籤：Java相關
下一篇：Java多型的表現形式