To put it simply, a ThreadLocal is shared in a thread and isolated between different threads. (Each thread can only see the value of its own thread). As shown below:
Before using Threadlocal, let’s take a look at the following API:
The API of the ThreadLocal class is very simple. The more important ones here are get(), set(), and remove(). set is used for assignment operations, and get is used to obtain variables. Value, remove is to delete the value of the current variable. It should be noted that the initialValue method will be triggered when it is called for the first time and is used to initialize the current variable value. By default, initialValue returns null.
Now that we have finished talking about the API of the ThreadLocal class, let’s practice it to understand the previous sentence: A ThreadLocal is shared in a thread. It is isolated between different threads (each thread can only see the value of its own thread)
public class ThreadLocalTest {
private static ThreadLocal threadLocal = new ThreadLocal() {
// 重写这个方法，可以修改“线程变量”的初始值，默认是null
@Override
protected Integer initialValue() {
return 0;
}
};
public static void main(String[] args) throws InterruptedException {
//一号线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("一号线程set前：" + threadLocal.get());
threadLocal.set(1);
System.out.println("一号线程set后：" + threadLocal.get());
}
}).start();
//二号线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("二号线程set前：" + threadLocal.get());
threadLocal.set(2);
System.out.println("二号线程set后：" + threadLocal.get());
}
}).start();
//主线程睡1s
Thread.sleep(1000);
//主线程
System.out.println("主线程的threadlocal值：" + threadLocal.get());
}
} Explain the above code a little:
Each ThreadLocal instance is similar to A variable name, different ThreadLocal instances are different variable names, and there will be a value inside them (understood this way for the time being). The "ThreadLocal variable or thread variable" mentioned in the following description represents an instance of the ThreadLocal class.
Create a static "ThreadLocal variable" in the class, create two threads in the main thread, and set the ThreadLocal variables to 1 and 2 in these two threads respectively. Then wait for threads No. 1 and 2 to finish executing, and check the value of the ThreadLocal variable in the main thread.
Program results and analysis⌛
The key point of the program results is that the output of the main thread is 0. If it is an ordinary variable, the number one thread and Set the ordinary variables to 1 and 2 in the second thread, then print this variable after the first and second threads are executed, and the output value must be 1 or 2 (which one is output depends on the thread scheduling logic of the operating system). However, after using the ThreadLocal variable to assign values through two threads, the initial value 0 is output in the main thread thread. This is why "a ThreadLocal is shared in a thread and isolated between different threads". Each thread can only see the value of its own thread. This is the core role of ThreadLocal: to implement threads Scoped local variables.
Each Thread object has a ThreadLocalMap. When a ThreadLocal is created, the ThreadLocal object will be added to the Map. , where the key is ThreadLocal and the value can be of any type. You may not understand this sentence very well when you first read it, but we will understand it after reading the source code together.
Our previous understanding was that all constant values or reference types are stored in ThreadLocal instances, but in fact they are not. This statement just allows us to better understand the concept of ThreadLocal variables. . Storing a value to ThreadLocal actually stores a value to the ThreadLocalMap in the current thread object. ThreadLocalMap can be simply understood as a Map, and the key to store a value in this Map is the ThreadLocal instance itself.
????In other words, the data in ThreadLocal that you want to store is not actually stored in the ThreadLocal object. Instead, this ThreadLocal instance is used as a key and stored in a Map in the current thread. The same is true when obtaining the value of ThreadLocal. This is why ThreadLocal can achieve isolation between threads.
ThreadLocalMap is an internal class of ThreadLocal, which implements a set of its own Map structure✨
ThreadLocalMap attribute:
