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);
    }
}

Answer 1

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!

Answer 2

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.

Answer 3

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.

Answer 4

In your example there should be no problem using a ThreadLocal at all.

Thread locals (and singletons also!) become a problem when thread locals are set to instances loaded by a classloader to be unloaded later. A typical situation in a servlet container (like tomcat):

1. A webapp set a thread local during request processing.
2. The thread is managed by the container.
3. The webapp should be undeployed.
4. The classloader of the webapp cannot be garbaged, because there is a reference left: from the thread local to the instance to its class to its classloader.

The same with singletons (java.sql.DriverManger and JDBC drivers offered by the webapp).

So avoid such things in particular in environments not under your full control!

Answer 5

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 (and you won't like this)
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