剑指架构师系列-Struts2的缓存

Posted 2020-10-06

 

Struts2的缓存中最重要的两个类就是ReferenceMap与ReferenceCache。下面来解释下ReferenceCache中的get()方法。

public V get(final Object key) {
		V value = super.get(key);
		return (value == null) ? internalCreate((K) key) : value;
}

通过key来获取value操作首先调用了super.get(key)方法，也就是调用了ReferenceMap中变量delegate的get()方法，这个变量的定义如下：

transient ConcurrentMap<Object, Object> delegate;  

支持并发的容量，所以不会有线程的问题。但是这个value值很可能为null，为什么呢？

（1）这个值本来就没有，当然为null

（2）key或value值存储的类型为软引用或弱引用，当JVM内存吃紧或回收内存时很可能让key/value对中的某个值为null，如果某个值为null，这个key/value对就会失效，会被Deman线程清理出ConcurrentMap容器中。　　

如果为空，那么就走internalCreate()函数：

V internalCreate(K key) {
		try {
			FutureTask<V> futureTask = new FutureTask<V>(new CallableCreate(key));   // 1

			// use a reference so we get the same equality semantics.
			Object keyReference = referenceKey(key);   // 2
			// 有就返回futureTask,没有就返回null
			Future<V> future = futures.putIfAbsent(keyReference, futureTask); // 3
			if (future == null) {
				// winning thread.
				try {
					if (localFuture.get() != null) {  // 4
						// 不允许在同一个缓存内嵌套创建
						throw new IllegalStateException("Nested creations within the same cache are not allowed.");
					}
					
					localFuture.set(futureTask); // 5
					
					futureTask.run();            // 6
					V value = futureTask.get();  // 7
					putStrategy().execute(this, keyReference,referenceValue(keyReference, value));  // 8
					return value;
				} finally {
					localFuture.remove();    // 9
					futures.remove(keyReference); // 10
				}
			} else {
				// wait for winning thread.
				return future.get();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		} 
	}

　　

（1）首先创建一个FutureTask对象，我们随后介绍。

（2）对key进行了一次封装引用（强引用、弱引用或者软引用），为什么要封装呢？主要还是想对弱引用与软引用的值进行比较。有机会我们再展开讨论这个问题。

（3）putIfAbsent()方法是个原子操作，也就是不存在就放入。futures变量定义如下：

transient ConcurrentMap<Object, Future<V>> futures = new ConcurrentHashMap<Object, Future<V>>();

当future为空时，进入了步骤4

（4）这里有个localFuture变量，定义如下：

transient ThreadLocal<Future<V>> localFuture = new ThreadLocal<Future<V>>();

这是个ThredLocal变量，本来就是线程安全的，但是localFuture.get()不为null时表示了嵌套创建的异常，这是什么原因呢？大家看第5步时为localFuture设置了值，而9处又移除了这个值。如果不为空，那说明线程设置了值在运行9之前的代码时又重新进入了这个if判断中。

 

到底是什么操作让这个线程又重要进入了if判断中呢？接着往下看。

（6）这里运行了FutureTask任务，也就是CallableCreate类的call()方法，然后线程在7处阻塞等待结果。另外一个线程运行call()方法来生成结果。

class CallableCreate implements Callable<V> {
		K key;
		public CallableCreate(K key) {
			this.key = key;
		}
		public V call() {
			// try one more time (a previous future could have come and gone.)
			// 这里又对值进行了一次判定  从缓存中查找值
			V value = internalGet(key);  
			if (value != null) {
				return value;
			}
			// create value.
			value = create(key); // 自定义加载数据的方式
			if (value == null) {
				throw new NullPointerException("create(K) returned null for: " + key);
			}
			return value;
		}
	}

在call()方法中再次调用了intrnalGet(key)来判断缓存中是否有这个值，我们记得在之前的线程中也做过这个判断，就是调用get()方法中的super.get()方法的时候。为什么还要重新判断一下呢？

 

现在假设有C线程在A线程执行if判断语句中的代码时也用相同的key调用了get()方法，但是A线程已经得到B线程的结果，执行完了10处理的代码，而这里的C线程恰好已经走过了get()方法中的super.get()方法，

导致没有获取到结果，在走if判断后调用了futureTask来重新获取结果，这时的call()方法中的internalGet()判断可就起作用了，直接取出B线程运行好的被A线程放入Map中。

 

还有一种情况，如果C线程在A线程还没有运行得到结果（在7处阻塞着呢）那么就会走else中的代码，因为A线程已经将futureTask放到Map中了。C线程也被要求阻塞等待B线程的结果。

 

如果缓存中没有则只能调用create()方法创建了，在ReferenceCache类中create()方法定义如下：

	protected abstract V create(K key);

这是一个抽像方法，Struts2中有一个具体的使用来看一下：

final Map<Class<?>, List<Injector>> injectors = new ReferenceCache<Class<?>, List<Injector>>() {
		
		protected List<Injector> create(Class<?> key) {
			List<Injector> injectors = new ArrayList<Injector>();
			addInjectors(key, injectors);
			return injectors;
		}
		
};

可以看到覆写了create()方法，所以call()方法就会调用上面的create()方法来创建值。　

 

现在来想想4处的嵌套创建代码，如果这里的create()调用了get()方法，并且传入相同的key值，会出现什么结果呢？