ThreadLocal Resource Leak and WeakReference

Question

My limited understanding of ThreadLocal is that it has resource leak issues. I gather this problem can be remedied through proper use of WeakReferences with ThreadLocal (although I may have misunderstood this point.) I would simply like a pattern or example for correctly using ThreadLocal with WeakReference, if one exists. For instance, in this code snippet where would the WeakReference be introduced?

static class DateTimeFormatter {
    private static final ThreadLocal<SimpleDateFormat> DATE_PARSER_THREAD_LOCAL = new ThreadLocal<SimpleDateFormat>() {
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy/MM/dd HH:mmz");
        }
    };
    public String format(final Date date) {
        return DATE_PARSER_THREAD_LOCAL.get().format(date);
    }
    public Date parse(final String date) throws ParseException
    {
      return DATE_PARSER_THREAD_LOCAL.get().parse(date);
    }
}

Solution 1

ThreadLocal uses a WeakReference internally. If the ThreadLocal is not strongly referenced, it will be garbage-collected, even though various threads have values stored via that ThreadLocal.

Additionally, ThreadLocal values are actually stored in the Thread; if a thread dies, all of the values associated with that thread through a ThreadLocal are collected.

If you have a ThreadLocal as a final class member, that's a strong reference, and it cannot be collected until the class is unloaded. But this is how any class member works, and isn't considered a memory leak.

---

Update: The cited problem only comes into play when the value stored in a ThreadLocal strongly references that ThreadLocal—sort of a circular reference.

In this case, the value (a SimpleDateFormat), has no backwards reference to the ThreadLocal. There's no memory leak in this code.

Solution 2

I'm guessing you're jumping through these hoops since SimpleDateFormat is not thread-safe.

Whilst I'm aware I'm not solving your problem above, can I suggest you look at Joda for your date/time work ? Joda has a thread-safe date/time formatting mechanism. You won't be wasting your time learning the Joda API either, as it's the foundation for the new standard date/time API proposal.

Solution 3

There shouldn't be such a problem.

A thread's ThreadLocal reference is defined to exist only as long as the corresponding thread is alive (see the javadoc)-- or put another way, once the thread is not alive, if the ThreadLocal was the only reference to that object, then the object becomes eligible for garbage collection.

So either you've found a genuine bug and should be reporting it, or you're doing something else wrong!

Solution 4

I realise this isn't strictly an answer to your question but as a general rule I won't suggest using a ThreadLocal in situration where there isn't a clear tear down at the end of a request/interaction. The classic is doing this sort of thing in a servlet container, at first glance it seems fine, but since the threads are pooled it becomes a issue with the ThreadLocal hanging onto the resource even after each request has been processed.

Suggestions:

1. Use a filter of similar wrapper for each interaction to clear the ThreadLocal at the end of each interaction
2. You could use a alternative to SimpleDateFormat like FastDateFormat from commons-lang or Joda as somebody has already suggested
3. Just create a new SimpleDateFormat every time you need it. Seems wasteful I know, but in most applications you just won't notice the difference

Solution 5

Just to add on to what @Neil Coffey said, this shouldn't be a problem as long as your ThreadLocal instance is static. Because you keep calling get() on a static instance, it should always hold the same reference to your simple date formatter. Therefore, as Neil said, when the Thread is terminated, the only instance of simple date formatter should be eligible for garbage collection.

If you have numbers or some other form of debugging that shows this introducing resource issues, then that's another story. But I believe as is it shouldn't be a problem.

View more solutions

Comments

[Alex Beardsley]

Why do you believe it has resource issues? The reason I ask is because in my experience, I haven't had a problem.

[brady]

Please provide some background on why you believe there's a memory leak.

[Julien Chastang]

Updated. Please see "resource leak issues" link above.

[brady]

I updated my answer to address your edit.

[Alex Beardsley]

+1: I didn't even think of that. It's a fair bet that this is the case, if not for this OP, then possibly for someone else.

[brady]

No, Formatters are not thread safe. Multiple threads invoking the parse method of a single instance is a disaster.

[Brett]

Leaking when a thread-local value (indirectly) references its ThreadLocal is still a bug in Sun's implementaiton. I'm not sure if crazy Bob Lee's implementation in Harmony has the same problem.

[brady]

Is it a bug in ThreadLocal, or the application and its use of ThreadLocal? I haven't run into it yet (and I try to avoid ThreadLocal), so I'm still not sure.

[Arne Burmeister]

ok, didnt thought about SimpleDateFormat, but there should be no problem with the ThreadLocal anyway.

[Patrick]

See also Tomcat's Memory Leak Protection. They also describe this ThreadLocal leak, but unfortunately do not suggest a workaround. It seems Tomcat itself attempts to nullify all static class references in a webapp's classloader classes when that webapp is undeployed.

[Charles Duffy]

Consider the case when you're running inside an app server/container which can unload your application (to install, say, a different version) but continue to use the threads for a new app release.

[Nestor Hernandez Loli]

Note that in a Servlet environment you NEED to use a servlet filter in order to clear that ThreadLocal, if you don't do that you will have a lot of leaks on redeploys