Java源码阅读------WeakCache

描述

根据名字就知道这是一个缓存类，具体点是一个键值对存储的缓存类，至于weak的含义是因为这里的键与值都是弱引用，除此之外，这里所说的缓存是一个二级缓存。第一层是弱引用，第二层是强引用。

实现

二级缓存

1 2	private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map = new ConcurrentHashMap<>(); private final ConcurrentMap<Supplier<V>, Boolean> reverseMap = new ConcurrentHashMap<>();

这里的map就是一个二级缓存的实现机制，Object（最左边的）就是key（键），第二个Object为subKey（子键），最后的Supplier< V >接口为值，实际是一个包裹最终是由其中的get方法来获取值。这种设计保证了key为null时也可用。reverseMap用于标注每个Supplier< V >的可用情况，用于缓存的过期处理。

构造方法

这里的K，P，V分别是键、参数、值，传入的参数是两个BiFunction接口，主要使用的是其中的apply方法，定义如下：

1	R apply(T t, U u);

通过传入的两个参数来获取值，使用这一接口实现了两个简单的工厂，subKeyFactory，valueFactory，这两个工厂分别实现了通过K与P来获取subKey（子键）和通过K，P来获取value值。

public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) {
	this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
	this.valueFactory = Objects.requireNonNull(valueFactory);
}

这样我们就可以通过subKeyFactory ，valueFactory 获取对应的子键与值。

CacheValue

静态内部类，实际上就是用于存储一个值的对象。
先看看WeakCache中的Value接口继承自Supplier接口，实际上是为了实现get方法

private interface Value<V> extends Supplier<V> {}

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

构造方法

private final int hash;
CacheValue(V value) {
	super(value);
    this.hash = System.identityHashCode(value); // compare by identity
}

实现了传入的Value的实例保存，同时通过System.identityHashCode(value);函数获取了该Value的HashCode。

hashCode与identityHashCode

在Object类中的hashCode可以获取相应对象的hashCode，而这个identityHashCode也是可以获取对象的hashCode，那么两这有什么不同吗？从源码看两者都是本地方法（native），实际上获取时的结果是与hashCode无异的，但是这里的hashCode指的是原有的Object中的hashCode的方法，如果进行了重写就可能会有不同了，所以为了得到原有的Object中的hashCode的值，identityHashCode会比较方便。

hashCode

重写的hashCode方法，直接返回hash值。

@Override
public int hashCode() {
	return hash;
}

equals

重写的equals方法，用于判别传入的obj与弱引用中的value是否相同，这里的get()方法就是返回之前传入的弱引用的value。

@Override
public boolean equals(Object obj) {
	V value;
    return obj == this || obj instanceof Value &&
            (value = get()) != null &&  value == ((Value<?>) obj).get(); 
}

LookupValue

静态内部类，为了便于对CacheValue中的值进行判断，建立了LookupValue，也实现了Value接口，是CacheValue运算时的替代，实现方式也很相似。

private final V value;//存储实际的值

      LookupValue(V value) {//构造方法
          this.value = value;
      }

      @Override
      public V get() {//Value接口中的get方法，返回value的值
          return value;
      }

      @Override
      public int hashCode() {
          return System.identityHashCode(value); //一样的hashCode计算
      }

      @Override
      public boolean equals(Object obj) {
          return obj == this ||
                 obj instanceof Value &&
                 this.value == ((Value<?>) obj).get();  // 类似的equals重写
      }

CacheKey

静态内部类，CacheKey直接继承了使用引用队列的弱引用，来存储键值。

构造方法

实现的过程与CacheValue中的类似，只不过这里使用引用队列。

private final int hash;

private CacheKey(K key, ReferenceQueue<K> refQueue) {
	super(key, refQueue);
    this.hash = System.identityHashCode(key); 
}

但是这里有一点注意，这里的构造方法是private的也就是说无法从外界直接调用，那么是如何构建出实例对象的呢？

valueOf

这是一个静态方法，传入的是要保存的key与对应的请求队列。

1
2
3

static <K> Object valueOf(K key, ReferenceQueue<K> refQueue) {
	return key == null ? NULL_KEY : new CacheKey<>(key, refQueue);
}

这里的NULL_KEY是一个标识用于标注key为空的情况。

1	private static final Object NULL_KEY = new Object();

hashCode与equals

这里重写了hashCode与equals方法，基本的实现与CacheValue相同，不再赘述。

@Override
public int hashCode() {
	return hash;
}

@Override
public boolean equals(Object obj) {
	K key;
    return obj == this || obj != null &&
           obj.getClass() == this.getClass() && (key = this.get()) != null &&
           key == ((CacheKey<K>) obj).get();
}

这里的get方法是引用Reference中定义的与之后描述的get方法不同。

expungeFrom

通过这个方法可以将含有这个键值的相关缓存清除。

void expungeFrom(ConcurrentMap<?, ? extends ConcurrentMap<?, ?>> map, ConcurrentMap<?, Boolean> reverseMap) {
	ConcurrentMap<?, ?> valuesMap = map.remove(this);//直接从二级缓存中清除，并获取第二级的缓存map
    if (valuesMap != null) {//遍历第二级缓存并在reverseMap中清除
    	for (Object cacheValue : valuesMap.values()) {
        	reverseMap.remove(cacheValue);
        }
    }
}

Factory

二级缓存的构建过程是通过这个静态内部类实现的，实现了Supplier接口。

构造方法

private final K key;//键
      private final P parameter;//参数
      private final Object subKey;//子键
      private final ConcurrentMap<Object, Supplier<V>> valuesMap;//二级缓存

      Factory(K key, P parameter, Object subKey, ConcurrentMap<Object, Supplier<V>> valuesMap) {
          this.key = key;
          this.parameter = parameter;
          this.subKey = subKey;
          this.valuesMap = valuesMap;
      }

简单的数据准备工作。

get

这就是构建的具体过程了，实现了Supplier中的get方法,通过同步synchronized来保持线程安全

@Override
      public synchronized V get() { // serialize access
          // 这里有一个检查，为啥检查先买个关子，到之后WeakCatch的get方法再做细究
          Supplier<V> supplier = valuesMap.get(subKey);
          if (supplier != this) {
              return null;
          }
          V value = null;
          try {
              value = Objects.requireNonNull(valueFactory.apply(key, parameter));
              //通过key与parameter处理出value
          } finally {
              if (value == null) { // 失败的处理
                  valuesMap.remove(subKey, this);//移除相应的subKey对应的缓存
              }
          }
          // 检查value是否完成建立
          assert value != null;

          // 包裹一下value建立一个cacheValue
          CacheValue<V> cacheValue = new CacheValue<>(value);
          // 将subKey中的二级缓存中原本的Factory换成包装过的cacheValue，至于为啥一开始二级缓存中会将Factory放进去我们也将其放到WeakCatch的get方法中解释
          if (valuesMap.replace(subKey, this, cacheValue)) {
              // 加入reverseMap中标记Value可用
              reverseMap.put(cacheValue, Boolean.TRUE);
          } else {//出错时的异常处理
              throw new AssertionError("Should not reach here");
          }
          //处理成功后将value返回
          return value;
      }

expungeStaleEntries

由于二级缓存中的Key使用了弱引用，所以在实际使用时gc的不定期处理会导致部分的缓存失效，通过这个函数就可以实现对失效缓存的清除。

private final ReferenceQueue<K> refQueue = new ReferenceQueue<>();
private void expungeStaleEntries() {
       CacheKey<K> cacheKey;
       while ((cacheKey = (CacheKey<K>)refQueue.poll()) != null) {
           cacheKey.expungeFrom(map, reverseMap);
       }
   }

refQueue是弱引用中的引用队列，在创建CacheKey时传入。（建议了解弱引用后继续）。
当gc处理了部分CacheKey时，refQueue中会有CacheKey的引用，取出来后在调用expungeFrom方法来清除过期的缓存。

size

同样的在获取可用的缓存数量时也使用了expungeStaleEntries来先清除过期的缓存。

public int size() {
       expungeStaleEntries();
       return reverseMap.size();
   }

containsValue

判断缓存中是否包含对应的value。

public boolean containsValue(V value) {
       Objects.requireNonNull(value);//对值进行判空
       expungeStaleEntries();//清除过期缓存
       return reverseMap.containsKey(new LookupValue<>(value));//使用LookupValue代替CacheValue使用，简化操作。
   }

get

压轴的高潮来了，这是整个类的灵魂所在，缓存中Value的值是由这个函数来获取的。

public V get(K key, P parameter) {
	//参数判空
       Objects.requireNonNull(parameter);
	//清除过期缓存
       expungeStaleEntries();
	//根据key生成相应的cacheKey 
       Object cacheKey = CacheKey.valueOf(key, refQueue);

       // 获取二级缓存
       ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
       if (valuesMap == null) {//如果没有对应的二级缓存
           ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());//这里的putIfAbsent与put不同，put会直接替代，putIfAbsent是先判断是否含有值，如果有就返回对应值，如果没有就放入新值并返回null
           //如果之前含有值就使用之前的。
           if (oldValuesMap != null) {
               valuesMap = oldValuesMap;
           }
       }
       // 通过subKeyFactory的apply方法创建subKey
       Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
       // 通过subKey获取相应的值
       Supplier<V> supplier = valuesMap.get(subKey);
       Factory factory = null;

       while (true) {
       	//缓存中有值且不为null就用get方法取出判空返回
           if (supplier != null) {
               // 根据之前的Factory中的操作，我们知道这里的supplier可能是Factory或CacheValue<V>类型
               V value = supplier.get();
               if (value != null) {
                   return value;
               }
           }
           //缓存没有成功取到或是没有缓存时，使用Factory进行加载。
           if (factory == null) {
           	//创建factory
               factory = new Factory(key, parameter, subKey, valuesMap);
           }
		//不含缓存或取值为空的处理
           if (supplier == null) {
               supplier = valuesMap.putIfAbsent(subKey, factory);
               if (supplier == null) {
                   //缓存加入成功，将最终的返回值设为factory在下一次循环时返回
                   supplier = factory;
               }
           } else {//之前含有缓存
               if (valuesMap.replace(subKey, supplier, factory)) {//用新的factory进行替换
                   //成功替换后就将返回值设为factory在下一次循环时返回
                   supplier = factory;
               } else {//替换失败则将其原来的值取出
                   supplier = valuesMap.get(subKey);
               }
           }
       }
   }

说到这里还有一个问题没有解决就是循环轮询的目的是啥，由于在实际使用时可能有多个线程对缓存中的值进行操作，所以使用轮询来不断的进行判断以获取最新的值，这里的get方法可以与factory中的get方法比较来看，就很好理解为啥在factory的get方法中要对取到的supplier进行判断了。

小结

WeakCache是实现Proxy类的关键一环，其中二级缓存的设计思想很有研究的价值，特别是一些内部类的设计与使用，都可以给我们之后的编码带来启发。