oscache作为本地缓存框架,存储模型依然是通用的缓存键值对模型。oscache使用HashTable存放数据,我们看下源码:
GeneralCacheAdministrator:
/**
* Get an object from the cache
*
* @param key The key entered by the user.
* @param refreshPeriod How long the object can stay in cache in seconds. To
* allow the entry to stay in the cache indefinitely, supply a value of
* {@link CacheEntry#INDEFINITE_EXPIRY}
* @return The object from cache
* @throws NeedsRefreshException when no cache entry could be found with the
* supplied key, or when an entry was found but is considered out of date. If
* the cache entry is a new entry that is currently being constructed this method
* will block until the new entry becomes available. Similarly, it will block if
* a stale entry is currently being rebuilt by another thread and cache blocking is
* enabled (<code>cache.blocking=true</code>).
*/
public Object getFromCache(String key, int refreshPeriod) throws NeedsRefreshException {
return getCache().getFromCache(key, refreshPeriod);
}
Cache:
/**
* Retrieve an object from the cache specifying its key.
*
* @param key Key of the object in the cache.
* @param refreshPeriod How long before the object needs refresh. To
* allow the object to stay in the cache indefinitely, supply a value
* of {@link CacheEntry#INDEFINITE_EXPIRY}.
* @param cronExpiry A cron expression that specifies fixed date(s)
* and/or time(s) that this cache entry should
* expire on.
*
* @return The object from cache
*
* @throws NeedsRefreshException Thrown when the object either
* doesn't exist, or exists but is stale. When this exception occurs,
* the CacheEntry corresponding to the supplied key will be locked
* and other threads requesting this entry will potentially be blocked
* until the caller repopulates the cache. If the caller choses not
* to repopulate the cache, they <em>must</em> instead call
* {@link #cancelUpdate(String)}.
*/
public Object getFromCache(String key, int refreshPeriod, String cronExpiry) throws NeedsRefreshException {
CacheEntry cacheEntry = this.getCacheEntry(key, null, null);
Object content = cacheEntry.getContent();
CacheMapAccessEventType accessEventType = CacheMapAccessEventType.HIT;
boolean reload = false;
// Check if this entry has expired or has not yet been added to the cache. If
// so, we need to decide whether to block, serve stale content or throw a
// NeedsRefreshException
if (this.isStale(cacheEntry, refreshPeriod, cronExpiry)) {
//Get access to the EntryUpdateState instance and increment the usage count during the potential sleep
EntryUpdateState updateState = getUpdateState(key);
try {
synchronized (updateState) {
if (updateState.isAwaitingUpdate() || updateState.isCancelled()) {
// No one else is currently updating this entry - grab ownership
updateState.startUpdate();
if (cacheEntry.isNew()) {
accessEventType = CacheMapAccessEventType.MISS;
} else {
accessEventType = CacheMapAccessEventType.STALE_HIT;
}
} else if (updateState.isUpdating()) {
// Another thread is already updating the cache. We block if this
// is a new entry, or blocking mode is enabled. Either putInCache()
// or cancelUpdate() can cause this thread to resume.
if (cacheEntry.isNew() || blocking) {
do {
try {
updateState.wait();
} catch (InterruptedException e) {
}
} while (updateState.isUpdating());
if (updateState.isCancelled()) {
// The updating thread cancelled the update, let this one have a go.
// This increments the usage count for this EntryUpdateState instance
updateState.startUpdate();
if (cacheEntry.isNew()) {
accessEventType = CacheMapAccessEventType.MISS;
} else {
accessEventType = CacheMapAccessEventType.STALE_HIT;
}
} else if (updateState.isComplete()) {
reload = true;
} else {
log.error("Invalid update state for cache entry " + key);
}
}
} else {
reload = true;
}
}
} finally {
//Make sure we release the usage count for this EntryUpdateState since we don't use it anymore. If the current thread started the update, then the counter was
//increased by one in startUpdate()
releaseUpdateState(updateState, key);
}
}
// If reload is true then another thread must have successfully rebuilt the cache entry
if (reload) {
cacheEntry = (CacheEntry) cacheMap.get(key);
if (cacheEntry != null) {
content = cacheEntry.getContent();
} else {
log.error("Could not reload cache entry after waiting for it to be rebuilt");
}
}
dispatchCacheMapAccessEvent(accessEventType, cacheEntry, null);
// If we didn't end up getting a hit then we need to throw a NRE
if (accessEventType != CacheMapAccessEventType.HIT) {
throw new NeedsRefreshException(content);
}
return content;
}
继续进入getCacheEntry方法:
/**
* Get an entry from this cache or create one if it doesn't exist.
*
* @param key The key of the cache entry
* @param policy Object that implements refresh policy logic
* @param origin The origin of request (optional)
* @return CacheEntry for the specified key.
*/
protected CacheEntry getCacheEntry(String key, EntryRefreshPolicy policy, String origin) {
CacheEntry cacheEntry = null;
// Verify that the key is valid
if ((key == null) || (key.length() == 0)) {
throw new IllegalArgumentException("getCacheEntry called with an empty or null key");
}
cacheEntry = (CacheEntry) cacheMap.get(key);
// if the cache entry does not exist, create a new one
if (cacheEntry == null) {
if (log.isDebugEnabled()) {
log.debug("No cache entry exists for key='" + key + "', creating");
}
cacheEntry = new CacheEntry(key, policy);
}
return cacheEntry;
}
跟到这里,终于出现正主cacheMap:
/**
* The actual cache map. This is where the cached objects are held.
*/
private AbstractConcurrentReadCache cacheMap = null;
我们看下这个类AbstractConcurrentReadCache:
/**
* A version of Hashtable that supports mostly-concurrent reading, but exclusive writing.
* Because reads are not limited to periods
* without writes, a concurrent reader policy is weaker than a classic
* reader/writer policy, but is generally faster and allows more
* concurrency. This class is a good choice especially for tables that
* are mainly created by one thread during the start-up phase of a
* program, and from then on, are mainly read (with perhaps occasional
* additions or removals) in many threads. If you also need concurrency
* among writes, consider instead using ConcurrentHashMap.
* <p>
*
* Successful retrievals using get(key) and containsKey(key) usually
* run without locking. Unsuccessful ones (i.e., when the key is not
* present) do involve brief synchronization (locking). Also, the
* size and isEmpty methods are always synchronized.
*
* <p> Because retrieval operations can ordinarily overlap with
* writing operations (i.e., put, remove, and their derivatives),
* retrievals can only be guaranteed to return the results of the most
* recently <em>completed</em> operations holding upon their
* onset. Retrieval operations may or may not return results
* reflecting in-progress writing operations. However, the retrieval
* operations do always return consistent results -- either those
* holding before any single modification or after it, but never a
* nonsense result. For aggregate operations such as putAll and
* clear, concurrent reads may reflect insertion or removal of only
* some entries. In those rare contexts in which you use a hash table
* to synchronize operations across threads (for example, to prevent
* reads until after clears), you should either encase operations
* in synchronized blocks, or instead use java.util.Hashtable.
*
* <p>
*
* This class also supports optional guaranteed
* exclusive reads, simply by surrounding a call within a synchronized
* block, as in <br>
* <code>AbstractConcurrentReadCache t; ... Object v; <br>
* synchronized(t) { v = t.get(k); } </code> <br>
*
* But this is not usually necessary in practice. For
* example, it is generally inefficient to write:
*
* <pre>
* AbstractConcurrentReadCache t; ... // Inefficient version
* Object key; ...
* Object value; ...
* synchronized(t) {
* if (!t.containsKey(key))
* t.put(key, value);
* // other code if not previously present
* }
* else {
* // other code if it was previously present
* }
* }
*</pre>
* Instead, just take advantage of the fact that put returns
* null if the key was not previously present:
* <pre>
* AbstractConcurrentReadCache t; ... // Use this instead
* Object key; ...
* Object value; ...
* Object oldValue = t.put(key, value);
* if (oldValue == null) {
* // other code if not previously present
* }
* else {
* // other code if it was previously present
* }
*</pre>
* <p>
*
* Iterators and Enumerations (i.e., those returned by
* keySet().iterator(), entrySet().iterator(), values().iterator(),
* keys(), and elements()) return elements reflecting the state of the
* hash table at some point at or since the creation of the
* iterator/enumeration. They will return at most one instance of
* each element (via next()/nextElement()), but might or might not
* reflect puts and removes that have been processed since they were
* created. They do <em>not</em> throw ConcurrentModificationException.
* However, these iterators are designed to be used by only one
* thread at a time. Sharing an iterator across multiple threads may
* lead to unpredictable results if the table is being concurrently
* modified. Again, you can ensure interference-free iteration by
* enclosing the iteration in a synchronized block. <p>
*
* This class may be used as a direct replacement for any use of
* java.util.Hashtable that does not depend on readers being blocked
* during updates. Like Hashtable but unlike java.util.HashMap,
* this class does NOT allow <tt>null</tt> to be used as a key or
* value. This class is also typically faster than ConcurrentHashMap
* when there is usually only one thread updating the table, but
* possibly many retrieving values from it.
* <p>
*
* Implementation note: A slightly faster implementation of
* this class will be possible once planned Java Memory Model
* revisions are in place.
*
* <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
**/
public abstract class AbstractConcurrentReadCache extends AbstractMap implements Map, Cloneable, Serializable
类注释说明AbstractConcurrentReadCache是一个HashTable的版本,支持读多写少的应用场景,基本上缓存都是用户读多写少的场景。接下来我们再看下oscache怎么实例化的。还是从GeneralCacheAdministrator入手:
/**
* Create the cache administrator.
*/
public GeneralCacheAdministrator() {
this(null);
}
/**
* Create the cache administrator with the specified properties
*/
public GeneralCacheAdministrator(Properties p) {
super(p);
log.info("Constructed GeneralCacheAdministrator()");
createCache();
}
它的构造函数调用了父类AbstractCacheAdministrator的构造函数:
/**
* Create the AbstractCacheAdministrator.
*
* @param p the configuration properties for this cache.
*/
protected AbstractCacheAdministrator(Properties p) {
loadProps(p);
initCacheParameters();
if (log.isDebugEnabled()) {
log.debug("Constructed AbstractCacheAdministrator()");
}
}
我们看它怎么加载配置文件的:
/**
* Load the properties file from the classpath.
*/
private void loadProps(Properties p) {
config = new Config(p);
}
进入Config类:
/**
* Create an OSCache configuration with the specified properties.
* Note that it is the responsibility of the caller to provide valid
* properties as no error checking is done to ensure that required
* keys are present. If you're unsure of what keys should be present,
* have a look at a sample oscache.properties file.
*
* @param p The properties to use for this configuration. If null,
* then the default properties are loaded from the <code>oscache.properties</code>
* file.
*/
public Config(Properties p) {
if (log.isDebugEnabled()) {
log.debug("OSCache: Config called");
}
if (p == null) {
this.properties = loadProperties(PROPERTIES_FILENAME, "the default configuration");
} else {
this.properties = p;
}
}
千呼万唤始出来,默认配置文件oscache.properties:
/**
* Name of the properties file.
*/
private final static String PROPERTIES_FILENAME = "/oscache.properties";