如何清理ThreadLocals

Question

有人有一个如何做到这一点的例子吗？它们是由垃圾收集器处理的吗？我正在使用 Tomcat 6。

Answer 1

javadoc 是这样说的：

“只要线程处于活动状态并且 ThreadLocal 实例可访问，每个线程就持有对其线程局部变量副本的隐式引用；线程消失后，其所有线程局部实例副本都将受到影响到垃圾收集（除非存在对这些副本的其他引用）。

如果您的应用程序或（如果您正在谈论请求线程）容器使用线程池，则意味着线程不会终止（如有必要），您需要自己处理线程局部变量。执行此操作的唯一干净方法是调用 ThreadLocal.remove() 方法

您可能需要清理线程池中线程的线程局部变量有两个原因：

• 防止内存占用（或假设资源）泄漏，或者
• 防止通过线程局部变量意外地将信息从一个请求泄漏到另一个请求，

线程局部内存泄漏通常不应该成为有界线程池的主要问题，因为任何线程局部变量最终都可能被覆盖；线程被重用。但是，如果您错误地一遍又一遍地创建新的 ThreadLocal 实例（而不是使用静态变量来保存单例实例），则线程本地值将获胜不会被覆盖，并且会在每个线程的 threadlocals 映射中累积。这可能会导致严重泄漏。

---

假设您正在讨论在 Web 应用程序处理 HTTP 请求期间创建/使用的线程局部变量，那么避免线程局部泄漏的一种方法是向 Web 应用程序的 ServletContext 注册一个 ServletRequestListener 并实现侦听器的 requestDestroyed 方法来清理当前线程的线程局部变量。

请注意，在这种情况下，您还需要考虑信息从一个请求泄漏到另一个请求的可能性。

Answer 2

下面是一些代码，用于在没有对实际线程局部变量的引用时清除当前线程中的所有线程局部变量。您还可以将其推广到清理其他线程的线程局部变量：

    private void cleanThreadLocals() {
        try {
            // Get a reference to the thread locals table of the current thread
            Thread thread = Thread.currentThread();
            Field threadLocalsField = Thread.class.getDeclaredField("threadLocals");
            threadLocalsField.setAccessible(true);
            Object threadLocalTable = threadLocalsField.get(thread);

            // Get a reference to the array holding the thread local variables inside the
            // ThreadLocalMap of the current thread
            Class threadLocalMapClass = Class.forName("java.lang.ThreadLocal$ThreadLocalMap");
            Field tableField = threadLocalMapClass.getDeclaredField("table");
            tableField.setAccessible(true);
            Object table = tableField.get(threadLocalTable);

            // The key to the ThreadLocalMap is a WeakReference object. The referent field of this object
            // is a reference to the actual ThreadLocal variable
            Field referentField = Reference.class.getDeclaredField("referent");
            referentField.setAccessible(true);

            for (int i=0; i < Array.getLength(table); i++) {
                // Each entry in the table array of ThreadLocalMap is an Entry object
                // representing the thread local reference and its value
                Object entry = Array.get(table, i);
                if (entry != null) {
                    // Get a reference to the thread local object and remove it from the table
                    ThreadLocal threadLocal = (ThreadLocal)referentField.get(entry);
                    threadLocal.remove();
                }
            }
        } catch(Exception e) {
            // We will tolerate an exception here and just log it
            throw new IllegalStateException(e);
        }
    }

Answer 3

没有办法清理 ThreadLocal 值，除非在首先将它们放入其中的线程内（或者当线程被垃圾收集时 - 与工作线程不同）线程）。这意味着当 Servlet 请求完成时（或者在将 AsyncContext 传输到 Servlet 3 中的另一个线程之前），您应该注意清理 ThreadLocal，因为在那之后您可能永远没有机会进入该特定的工作线程，因此，当您的 Web 应用程序在服务器未重新启动的情况下取消部署时，将会泄漏内存。

进行此类清理的好地方是 ServletRequestListener.requestDestroyed()。

如果您使用 Spring，所有必要的连接都已经就位，您可以简单地将内容放入请求范围中，而不必担心清理它们（这会自动发生）：

RequestContextHolder.getRequestAttributes().setAttribute("myAttr", myAttr, RequestAttributes.SCOPE_REQUEST);
. . .
RequestContextHolder.getRequestAttributes().getAttribute("myAttr", RequestAttributes.SCOPE_REQUEST);

Answer 4

再次仔细阅读 Javadoc 文档：

“只要线程处于活动状态并且 ThreadLocal 实例可访问，每个线程都持有对其线程局部变量副本的隐式引用；线程消失后，其线程本地实例的所有副本都将受到垃圾回收（除非存在对这些副本的其他引用）。
”

无需清洁任何东西，泄漏存在的条件是“与”。因此，即使在线程存活于应用程序的 Web 容器中，
只要 webapp 类被卸载（只有在父类加载器中加载的静态类中引用才会阻止这种情况，这与 ThreadLocal 无关，而是具有静态数据的共享 jar 的一般问题），然后 AND 的第二条腿条件不再满足，因此线程本地副本有资格进行垃圾回收。

就实现符合文档而言，线程本地不可能是内存泄漏的原因。

Answer 5

我想为这个问题贡献我的答案，尽管它已经很旧了。我也被同样的问题困扰（gson threadlocal 没有从请求线程中删除），甚至在内存不足时重新启动服务器（这很糟糕！！）。

在设置为开发模式的 Java Web 应用程序的上下文中（服务器设置为每次检测到代码更改时都会弹跳，并且可能也在调试模式下运行），我很快就了解到 threadlocals 可以很棒有时会很痛苦。我对每个请求都使用了线程本地调用。里面的调用。我有时也会使用 gson 来生成我的响应。我会将调用包装在过滤器中的“try”块内，并将其销毁在“finally”块内。

我观察到（我现在没有指标来支持这一点）是，如果我对几个文件进行了更改，并且服务器在我的更改之间不断地跳动，我会不耐烦并重新启动服务器（准确地说是 tomcat）从 IDE 中。最有可能的是，我最终会遇到“内存不足”异常。

我解决这个问题的方法是在我的应用程序中包含 ServletRequestListener 实现，然后我的问题就消失了。我认为发生的情况是，在请求过程中，如果服务器会弹跳几次，我的线程局部变量不会被清除（包括 gson），所以我会收到有关线程局部变量的警告，并在稍后收到两三个警告，服务器会崩溃。随着 ServletResponseListener 显式关闭我的线程局部变量，gson 问题就消失了。

我希望这是有道理的，并让您了解如何克服线程局部问题。始终将它们关闭在使用点周围。在 ServletRequestListener 中，测试每个线程本地包装器，如果它仍然具有对某个对象的有效引用，则在此时销毁它。

我还应该指出，养成将 threadlocal 包装为类中的静态变量的习惯。这样，您可以保证通过在 ServeltRequestListener 中销毁它，您不必担心同一类的其他实例挂在周围。

Answer 6

@lyaffe 的答案对于 Java 6 来说是最好的。这个答案使用 Java 8 中的可用内容解决了一些问题。

@lyaffe 的答案是在 MethodHandle 可用之前为 Java 6 编写的。由于反射，它会遭受性能损失。如果按如下方式使用，MethodHandle 提供对字段和方法的零开销访问。

@lyaffe 的答案也明确地通过了 ThreadLocalMap.table，并且很容易出现错误。现在有一个方法 ThreadLocalMap.expungeStaleEntries() 可以执行相同的操作。

下面的代码有 3 个初始化方法来最小化调用 expungeStaleEntries() 的成本。

private static final MethodHandle        s_getThreadLocals     = initThreadLocals();
private static final MethodHandle        s_expungeStaleEntries = initExpungeStaleEntries();
private static final ThreadLocal<Object> s_threadLocals        = ThreadLocal.withInitial(() -> getThreadLocals());

public static void expungeThreadLocalMap()
{
   Object threadLocals;

   threadLocals = s_threadLocals.get();

   try
   {
      s_expungeStaleEntries.invoke(threadLocals);
   }
   catch (Throwable e)
   {
      throw new IllegalStateException(e);
   }
}

private static Object getThreadLocals()
{
   ThreadLocal<Object> local;
   Object result;
   Thread thread;

   local = new ThreadLocal<>();

   local.set(local);   // Force ThreadLocal to initialize Thread.threadLocals

   thread = Thread.currentThread();

   try
   {
      result = s_getThreadLocals.invoke(thread);
   }
   catch (Throwable e)
   {
      throw new IllegalStateException(e);
   }

   return(result);
}

private static MethodHandle initThreadLocals()
{
   MethodHandle result;
   Field field;

   try
   {
      field = Thread.class.getDeclaredField("threadLocals");

      field.setAccessible(true);

      result = MethodHandles.
         lookup().
         unreflectGetter(field);

      result = Preconditions.verifyNotNull(result, "result is null");
   }
   catch (NoSuchFieldException | SecurityException | IllegalAccessException e)
   {
      throw new ExceptionInInitializerError(e);
   }

   return(result);
}

private static MethodHandle initExpungeStaleEntries()
{
   MethodHandle result;
   Class<?> clazz;
   Method method;
   Object threadLocals;

   threadLocals = getThreadLocals();
   clazz        = threadLocals.getClass();

   try
   {
      method = clazz.getDeclaredMethod("expungeStaleEntries");

      method.setAccessible(true);

      result = MethodHandles.
         lookup().
         unreflect(method);
   }
   catch (NoSuchMethodException | SecurityException | IllegalAccessException e)
   {
      throw new ExceptionInInitializerError(e);
   }

   return(result);
}

Answer 7

JVM 会自动清理 ThreadLocal 对象中的所有无引用对象。

清理这些对象的另一种方法（例如，这些对象可能是周围存在的所有线程不安全对象）是将它们放入某个对象持有者类中，该类基本上保存它，您可以覆盖 Finalize 方法来清理对象驻留在其中。同样，它何时调用 finalize 方法取决于垃圾收集器及其策略。

这是一个代码示例：

public class MyObjectHolder {

    private MyObject myObject;

    public MyObjectHolder(MyObject myObj) {
        myObject = myObj;
    }

    public MyObject getMyObject() {
        return myObject;
    }

    protected void finalize() throws Throwable {
        myObject.cleanItUp();
    }
}

public class SomeOtherClass {
    static ThreadLocal<MyObjectHolder> threadLocal = new ThreadLocal<MyObjectHolder>();
    .
    .
    .
}

Answer 8

final ThreadLocal<T> old = backend;

// try to clean by reflect
try {
    // BGN copy from apache ThreadUtils#getAllThreads
    ThreadGroup systemGroup = Thread.currentThread().getThreadGroup();
    while (systemGroup.getParent() != null) {
        systemGroup = systemGroup.getParent();
    }
    int count = systemGroup.activeCount();
    Thread[] threads;
    do {
        threads = new Thread[count + (count / 2) + 1]; //slightly grow the array size
        count = systemGroup.enumerate(threads, true);
        //return value of enumerate() must be strictly less than the array size according to javadoc
    } while (count >= threads.length);
    // END

    // remove by reflect
    final Field threadLocalsField = Thread.class.getDeclaredField("threadLocals");
    threadLocalsField.setAccessible(true);

    Class<?> threadLocalMapClass = Class.forName("java.lang.ThreadLocal$ThreadLocalMap");
    Method removeMethod = threadLocalMapClass.getDeclaredMethod("remove", ThreadLocal.class);
    removeMethod.setAccessible(true);

    for (int i = 0; i < count; i++) {
        final Object threadLocalMap = threadLocalsField.get(threads[i]);
        if (threadLocalMap != null) {
            removeMethod.invoke(threadLocalMap, old);
        }
    }

}
catch (Exception e) {
    throw new ThreadLocalAttention(e);
}