Java ThreadLocal Example

Filed Under: Java

Java ThreadLocal is used to create thread local variables. We know that all threads of an Object share it’s variables, so the variable is not thread safe. We can use synchronization for thread safety but if we want to avoid synchronization, we can use ThreadLocal variables.

Java ThreadLocal

ThreadLocal, Java ThreadLocal

Every thread has it’s own ThreadLocal variable and they can use it’s get() and set() methods to get the default value or change it’s value local to Thread.

ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread.

Java ThreadLocal Example

Here is a small example showing use of ThreadLocal in java program and proving that every thread has it’s own copy of ThreadLocal variable.

ThreadLocalExample.java


package com.journaldev.threads;

import java.text.SimpleDateFormat;
import java.util.Random;

public class ThreadLocalExample implements Runnable{

    // SimpleDateFormat is not thread-safe, so give one to each thread
    private static final ThreadLocal<SimpleDateFormat> formatter = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue()
        {
            return new SimpleDateFormat("yyyyMMdd HHmm");
        }
    };
    
    public static void main(String[] args) throws InterruptedException {
        ThreadLocalExample obj = new ThreadLocalExample();
        for(int i=0 ; i<10; i++){
            Thread t = new Thread(obj, ""+i);
            Thread.sleep(new Random().nextInt(1000));
            t.start();
        }
    }

    @Override
    public void run() {
        System.out.println("Thread Name= "+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern());
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //formatter pattern is changed here by thread, but it won't reflect to other threads
        formatter.set(new SimpleDateFormat());
        
        System.out.println("Thread Name= "+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern());
    }

}

Output of the above java ThreadLocal example program is:


Thread Name= 0 default Formatter = yyyyMMdd HHmm
Thread Name= 1 default Formatter = yyyyMMdd HHmm
Thread Name= 0 formatter = M/d/yy h:mm a
Thread Name= 2 default Formatter = yyyyMMdd HHmm
Thread Name= 1 formatter = M/d/yy h:mm a
Thread Name= 3 default Formatter = yyyyMMdd HHmm
Thread Name= 4 default Formatter = yyyyMMdd HHmm
Thread Name= 4 formatter = M/d/yy h:mm a
Thread Name= 5 default Formatter = yyyyMMdd HHmm
Thread Name= 2 formatter = M/d/yy h:mm a
Thread Name= 3 formatter = M/d/yy h:mm a
Thread Name= 6 default Formatter = yyyyMMdd HHmm
Thread Name= 5 formatter = M/d/yy h:mm a
Thread Name= 6 formatter = M/d/yy h:mm a
Thread Name= 7 default Formatter = yyyyMMdd HHmm
Thread Name= 8 default Formatter = yyyyMMdd HHmm
Thread Name= 8 formatter = M/d/yy h:mm a
Thread Name= 7 formatter = M/d/yy h:mm a
Thread Name= 9 default Formatter = yyyyMMdd HHmm
Thread Name= 9 formatter = M/d/yy h:mm a

As you can see from the output that Thread-0 has changed the value of formatter but still thread-2 default formatter is same as the initialized value. You can see the same pattern for other threads too.

Update: ThreadLocal class is extend in Java 8 with a new method withInitial() that takes Supplier functional interface as argument. So we can use lambda expressions to easily create the ThreadLocal instance. For example, above formatter ThreadLocal variable can be defined in one line as below:


private static final ThreadLocal<SimpleDateFormat> formatter = 
	ThreadLocal.<SimpleDateFormat>withInitial
	(() -> {return new SimpleDateFormat("yyyyMMdd HHmm");});

If you are new to Java 8 features, please check out Java 8 Features and Java 8 Functional Interfaces.

That’s all for ThreadLocal in java programming.

Reference: API Doc

Comments

  1. praveen gupta says:

    How is it possible, “We can use synchronization for thread safety but if we want to avoid synchronization, we can use ThreadLocal variables.” as mentioned in the first paragraph, to avoid synchronization with ThreadLocal?

    I think if we use synchronization then it means that the shared resource will be accessed by only one thread at once and after that another thread take lock then that thread will get the updated value of resource(if it was updated by any thread) while in ThreadLocal resource remains same even after modifying resource in threads because it is local to thread.

    So, We can use ThreadLocal for resource if we want the default value of that in each thread and according to thread purpose we can modify locally and it will not impact in the main copy.

    Please let me know if i’m not in correct direction.

  2. rahul G says:

    Fan of your all articles , but this 2 line making me confuse .
    1) ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread.
    2) Every thread has it’s own ThreadLocal variable and they can use it’s get() and set() methods to get the default value or change it’s value local to Thread

    if a Variable is static how each thread can use that variable as separate (own variable) ?

    1. Pankaj says:

      See the example itself, private static final ThreadLocal<SimpleDateFormat> formatter.

  3. Andrey says:

    I also do not see where is that new pattern declared that is used by toPattern()

  4. Andrey says:

    What I do not see is where ThreadLocalExample that implements Runnable starts …

    Thank you

  5. dz says:

    The lambda expression part at the end, why do you need the “” in front of “withInitial”? I can just call ThreadLocal.withInitial(..), right?

    Thanks for the great articles!

  6. I’m try to understand how to use the ThreadLocal class. I understand that there is a cleanup phase but this article doesn’t mention anything about it !

  7. Sriharsha says:

    I got the point that ThreadLocal maiitains a private kind of value respective to the threads.
    But in other sites too,it is given that it could be used as an alternative to synchronization,to improve performance.
    I just wonder,since we creating a new value(object instance) in its initial value,obviously,all the changes made to that object by that thread will be exclusive to that object only.So maintaining “thread safety”.I could get this even with Out ThreadLocal variable or Synchronized block,if i am creating a new Instance for every thread.
    Could some one please explain, what is special in this ThreadLocal for making its things private,isn’t it obvious?
    Couldn’t i get same thing,by making separate objects,without ThreadLocal and achieve this thread safety?

  8. yogi g says:

    Very good article.
    Below are my comments :
    This is not required and not in use.
    protected SimpleDateFormat initialValue()
    {
    return new SimpleDateFormat(“yyyyMMdd HHmm”);
    }
    Instead this is required :
    formatter.set(new SimpleDateFormat(“yyyyMMdd HHmm”));

    1. Pankaj says:

      initialValue() method is providing the initial value. You can see from the output that every thread starts with default value of formatter “yyyyMMdd HHmm” even though other threads are changing it’s value to “M/d/yy h:mm a” in formatter.set(new SimpleDateFormat());.

  9. Sriharsha says:

    Hi sir,
    can u give some instances where this could be practically used.I mean wait and notify could be used for Consumer-Producer problems,similarly,where is this concept generally used.

  10. infoj says:

    One interesting point about ThreadLocal variable is the global access. Any thread local variable is global to the thread. It can be accessed anywhere from the thread. If, from a thread several methods residing in different classes are called, thread local variable will be visible to all those methods. There is no need to pass the thread local variable as a parameter.

    At the same time any thread local variable is local to a thread. If there are 10 threads spawned all the 10 threads will have their own thread local variable. One thread can not access/modify other thread’s Thread Local variables.

    1. michael says:

      Can you give an example or point me to an example of how to access the thread local variable from methods in different classes?

      1. ganesh says:

        class {

        static Tl tl=new Tl();

        in that class tl.set(object);
        tl.get()–return object

        }

  11. jeffrey says:

    hi,
    formatter is final, how could change its value via set() method?

    1. Pankaj says:

      formatter is final but we can call it’s setter methods. It’s not immutable.

  12. Hi Pankaj,

    I want to tell you, I follow your posts, I study them. But this post example is not good one. Can you come up with some better example to explain about ThreadLocal class.
    Thanks in advance!

    1. Pankaj says:

      The examples are meant to be simple for clear understanding, like in here I am using ThreadLocal<SimpleDateFormat> to showcase that they are local to the thread and even if it’s changed by one of the thread, the other threads remains unaffected.

      If you have something that you think would be a good example, let me know and I will try to extend the post to include that too.

    2. ryan says:

      I think the best example is to read JDK source code, ThreadLocal is maintained by each thread self, it is a map

  13. Shashank says:

    Very nice post. Helped me understand. Thanks.

Leave a Reply

Your email address will not be published. Required fields are marked *

close
Generic selectors
Exact matches only
Search in title
Search in content
Search in posts
Search in pages