Anti Pattern - ThreadLocal variables with Thread Pool

In a previous post I wrote the usage and benefits of ThreadLocal based instance variables in concurrent applications. This seemingly innocent and fail proof implementation will provide clear data separation and visibility between threads in multi threaded applications UNTIL, you use Thread Pooling.

ThreadLocal variables as the name suggest is local to the thread, til the thread is alive the ThreadLocal instance variable can not be Garbage Collected. This post explains the theory clearly.

To see it in action I wrote small program which infinitely creates Tasks in one implementation submitting tasks to a Thread Pool and in another instance creating ad-hoc Threads which are no pooled. And I used jVisualVM to monitor the VM.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class ThreadLocalTest {

    private static ExecutorService executor = Executors.newFixedThreadPool(100);
    
    public static void main(String[] args) {
        while(true) {
            // Thread Pooled based implementation
            executor.execute(new SimpleThread());
            // Ad-hoc Thread based implementation
            new SimpleThread().start();
        }
    }
    
    public static class SimpleThread extends Thread {
        
        private ThreadLocal<Integer> no = new ThreadLocal<Integer>() {

            @Override
            protected Integer initialValue() {
                return 0;
            }
            
        };
        
        public void run() {
            while(no.get() < 100) {
                no.set(no.get() + 1);
            }
            System.out.println(String.format("Thread : %s Finished", Thread.currentThread().getName()));
            no.remove();
        }
    }
}

In the Thread pooled implementation one thread throwing an Exception: java.lang.OutOfMemoryError thrown from the UncaughtExceptionHandler in thread "Thread Name" is just a matter of time.

Where as the adhoc Thread creation seems to keep on running with good VM Garbage Collection but the Thread pool implementation fills up the heap space within minutes and eventually runs out of memory. 

Lesson

Always keep an eye on the Thread classes you use in your application, make sure they don't have ThreadLocal variables when you are using Thread Pooling.

Give special care when you get pre-compiled third party libraries which might have ThreadLocal so always read javadocs thoroughly when you use Thread pooling.