defined a threadlocal variable in a class to maintain some instances. setting and getting in a recursive method. Somewhat i cant clear the threadlocal variable when the request completes (i have analysed in all other ways. I can't clear threadlocal).
My question is, If i didn't clear threadlocal variable for each request, what will happen? What are the impacts?
The javadoc says:
after a thread goes away, all of its copies of thread-local instances are subject to garbage collection (unless other references to these copies exist).
For instance, the implementation here is backed by a HashTable that uses weak references for the key. In this case, the key is the thread. If the thread terminates, the entry in the map becomes eligible for garbage collection.
The garbage colleciton might happen only when the system starts running out of memory space. But this consideration applies to all objects in the system: when objects start being reclaimed depend on the GC policy, which is VM specifc and subject to tuning.
This is my view of good and bad usage of thread locals:
It is good ot use thread locals if the point is to address a concurrency issue. For instance, avoiding synchronization of an object that is not thread-safe by keeping one copy per thread. Or to address other design issue related to concurrency.
It is bad if the point is to "pass a parameter" down the call chain in a cheap way. You should better refactor your code and pass the object down the call chain as a regular method paramter.
It is ok to use thread local to store some form of "current" context, e.g. the current request.
If the thread dies, so does the reference to the ThreadLocal entry and so your object (assuming there are no other references) will be garbage collected.
As long as the thread lives, so does your object.
You have to assess what the impact is for your object being long-lived.
You have a memory leak and the ThreadLocal might already be set, the next time your code gets called. ThreadLocals are a bit of a code smell imo.
