java - 需要全局清理的昂贵资源的线程安全缓存

Question

情况:

• 需要一个昂贵的创建和非线程安全的外部资源的缓存
• 资源需要明确清理
• 不能 Hook 每个线程的终止，但可以 Hook 应用程序的终止
• 该代码也在 Servlet 容器中运行，因此无法直接使用导致来自系统类加载器(例如 ThreadLocal)的强引用的缓存(参见下面的编辑)。

因此，要使用 ThreadLocal，它只能保存对资源的 WeakReference，并且必须保留一个单独的强引用集合。代码很快变得非常复杂并造成内存泄漏(因为强引用在线程死亡后永远不会被删除)。

ConcurrentHashMap 似乎很适合，但它也存在内存泄漏问题。

还有哪些其他选择？一个同步的 WeakHashMap??

(希望该解决方案也可以使用给定的 Supplier 自动初始化，就像 ThreadLocal.withInitial() 一样)

---

编辑:

只是为了证明类加载器泄漏是一回事。创建一个最小的 WAR 项目:

public class Test {
    public static ThreadLocal<Test> test = ThreadLocal.withInitial(Test::new);
}

索引.jsp:

<%= Test.test.get() %>

访问该页面并关闭 Tomcat，您将获得:

Aug 21, 2015 5:56:11 PM org.apache.catalina.loader.WebappClassLoaderBase checkThreadLocalMapForLeaks
SEVERE: The web application [test] created a ThreadLocal with key of type [java.lang.ThreadLocal.SuppliedThreadLocal] (value [java.lang.ThreadLocal$SuppliedThreadLocal@54e69987]) and a value of type [test.Test] (value [test.Test@2a98020a]) but failed to remove it when the web application was stopped. Threads are going to be renewed over time to try and avoid a probable memory leak.

Answer 1

这似乎是典型的“弱键，引用键的强值”问题。如果将值设置为弱值，即使键可达也可以收集它，如果设置为强值，则键也是强可达的。如果没有 JVM 的直接支持，这是无法解决的。

值得庆幸的是，有一个类提供了这个功能(尽管它的文档中没有强调):

java.lang.ClassValue :

Lazily associate a computed value with (potentially) every type. For example, if a dynamic language needs to construct a message dispatch table for each class encountered at a message send call site, it can use a ClassValue to cache information needed to perform the message send quickly, for each class encountered.

虽然本文档没有说明值可以引用 Class 键，但它的预期用例是为类保存分派(dispatch)表，这意味着值具有反向引用是很典型的.

让我们用一个小的测试类来演示它:

public class ClassValueTest extends ClassValue<Method> {
    @Override
    protected Method computeValue(Class<?> type) {
        System.out.println("computeValue");
        return Arrays.stream(type.getDeclaredMethods())
            .filter(m->Modifier.isPublic(m.getModifiers()))
            .findFirst().orElse(null);
    }
    public static void main(String... arg) throws Throwable {
        // create a collectible class:
        MethodHandles.Lookup l=MethodHandles.lookup();
        MethodType noArg = MethodType.methodType(void.class);
        MethodHandle println = l.findVirtual(
            PrintStream.class, "println", MethodType.methodType(void.class, String.class));
        Runnable r=(Runnable)LambdaMetafactory.metafactory(l, "run",
            println.type().changeReturnType(Runnable.class), noArg, println, noArg)
           .getTarget().invokeExact(System.out, "hello world");
        r.run();
        WeakReference<Class<?>> ref=new WeakReference<>(r.getClass());
        ClassValueTest test=new ClassValueTest();
        // compute and get
        System.out.println(test.get(r.getClass()));
        // verify that the value is cached, should not compute
        System.out.println(test.get(r.getClass()));
        // allow freeing
        r=null;
        System.gc();
        if(ref.get()==null) System.out.println("collected");
        // ensure that it is not our cache instance that has been collected
        System.out.println(test.get(String.class));
    }
}

在我的机器上打印:

hello world
computeValue
public void ClassValueTest$$Lambda$1/789451787.run()
public void ClassValueTest$$Lambda$1/789451787.run()
collected
computeValue
public boolean java.lang.String.equals(java.lang.Object)

解释一下，这个测试创建了一个匿名类，就像lambda表达式产生的一样，可以被垃圾回收。然后它使用 ClassValueTest 实例来缓存该 Class 的 Method 对象。由于 Method 实例引用了它们的声明类，因此我们在此处遇到了值引用其键的情况。

仍然，在不再使用该类之后，它会被收集，这意味着关联的值也已被收集。因此它不受键值反向引用的影响。

使用另一个类的最后一个测试只是确保我们不是急切垃圾收集的受害者 described here因为我们仍在使用缓存实例本身。

---

此类将单个值与一个类相关联，而不是每个线程一个值，但应该可以将 ClassValue 与 ThreadLocal 结合起来以获得所需的结果。