Shulou(Shulou.com)06/03 Report--

This article introduces the relevant knowledge of "how to master the relevant knowledge points of ThreadLocal". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

I. introduction

According to the description of the Java official documentation, we know that the ThreadLocal class is used to provide local variables within a thread, which can ensure the isolation of internal variables within each thread in a multithreaded environment.

In other words, ThreadLocal provides local variables within a thread, and different threads will not interfere with each other. The scope of the variable works throughout the life cycle of the thread, reducing the complexity of passing some common variables between multiple methods or components in the same thread.

2.1Common method return value method name description Tget () returns the value in the current thread copy of this thread local variable voidremove () removes the current thread value of this thread local variable voidset (T value) sets the value in the current thread copy of this thread local variable to the specified value 2.2 case demonstration

Demand: use 3 painters to draw a color on a canvas and print out the color they draw.

/ * canvas class * / public class Canvas {private String content; public String getContent () {return content;} public void setContent (String content) {this.content = content;}} / * painter class * / public class Painter extends Thread {private String name; private Canvas canvas Private String color; public Painter (String name, Canvas canvas, String color) {this.name = name; this.canvas = canvas; this.color = color;} @ Override public void run () {canvas.setContent (color) System.out.println (this.name + "draw on the artboard" + canvas.getContent ());}} / * launch class * / public class Demo {public static void main (String [] args) {/ / create canvas Canvas canvas = new Canvas () Painter painter1 = new Painter ("Xiaoqiang", canvas, "red"); Painter painter2 = new Painter ("Wangcai", canvas, "yellow"); Painter painter3 = new Painter ("dog egg", canvas, "blue"); painter1.start (); painter2.start () Painter3.start ();}}

The implementation results are as follows:

Xiaoqiang draws blue on the drawing board, draws yellow dog eggs on the drawing board, draws yellow on the drawing board.

Obviously, in the case of multithreaded access to the same resource (canvas), the output results have concurrency problems.

There are two solutions: one is to add synchronized synchronization code block to the run method, and the other is to use ThreadLocal to transform the Canvas type.

Since this article focuses on ThreadLocal, we will solve the above problems in the second way below.

Modify the Canvas class to the following:

Public class Canvas {private ThreadLocal map = new ThreadLocal (); public String getContent () {return map.get ();} public void setContent (String content) {map.set (content);}}

Start the execution class, and the result is as follows:

Xiaoqiang draws red dog eggs on the drawing board, blue on the drawing board, and yellow on the drawing board.

The result is normal output.

2.3 the principle of distinguishing names between ThreadLocal and synchronized focuses on ThreadLocal space for time, and each thread provides a copy of variables, thus achieving simultaneous access to resources among multiple threads without interfering with each other, synchronized time for space, providing only one variable, allowing threads to queue up to access shared resources between multiple threads, and synchronous access to the internal structure of ThreadLocal.

Before looking at the source code, we can try to guess what the internal structure of ThreadLocal looks like.

For example, a Map container is defined internally in ThreadLocal. When the set method of the ThreadLocal instance is called, the current thread name / current thread instance is used as the key, and the content that needs to be saved is operated as value. When the get mode is called, the data is obtained with the current thread name / current thread instance as key.

The above scheme seems to be able to function normally, but there are actually some problems:

1) the key-value container is maintained by ThreadLocal. When the number of threads increases and calls the set method of the ThreadLocal instance, the key-value container increases, that is, the memory footprint increases. 2) when the object calling the ThreadLocal instance method is a thread in the thread pool, it is impossible to tell whether the thread is recycled, that is, the current thread has been taken out of the thread pool to call the set method of the ThreadLocal instance. If the get method is called, the previous data will be fetched and the data will be contaminated.

So, how on earth is the isolation of internal variables between threads achieved within ThreadLocal?

As shown in the figure above, a container named ThreadLocalMap is maintained internally by the Thread instance. Its element is that the ThreadLocal instance is the key and the object is the data structure of the value, contrary to the way we guessed.

Compared to what we envisioned earlier, the JDK implementation has two benefits:

1) the number of Entry stored in Map decreases. 2) when the thread is destroyed, the ThreadLocalMap is also destroyed, reducing memory usage. 4. Source code analysis 4.1 ThreadLocal source code

We analyze the source code of the commonly used set, get and remove methods.

Public void set (T value) {/ / get the current thread object Thread t = Thread.currentThread (); / / get the ThreadLocalMap object maintained by the current thread object ThreadLocalMap map = getMap (t); if (map! = null) / / set entry map.set (this, value) if map exists Else / / if map does not exist, because the threadLocal instance helps create and bind data createMap (t, value);} ThreadLocalMap getMap (Thread t) {return t.threadLocals;} void createMap (Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap (this, firstValue);}

Set method execution process:

1) get the current thread object 2) get the ThreadLocalMap object through the current thread object 3) if the ThreadLocalMap object exists, set the input parameter into the ThreadLocalMap object 4) if the ThreadLocalMap object does not exist, create a ThreadLocalMap object for the current thread and set the input parameter

Public T get () {/ / get the current thread object Thread t = Thread.currentThread (); / / get the ThreadLocalMap object maintained by the current thread object ThreadLocalMap map = getMap (t); if (map! = null) {/ / if map is not empty, take the current ThreadLocal instance as key, get the data ThreadLocalMap.Entry e = map.getEntry (this) If (e! = null) {@ SuppressWarnings ("unchecked") T result = (T) e.value; return result;}} / / if map is empty, the initialization value is usually null return setInitialValue ();} private T setInitialValue () {T value = initialValue (); Thread t = Thread.currentThread (); ThreadLocalMap map = getMap (t) If (map! = null) map.set (this, value); else createMap (t, value); return value;} protected T initialValue () {return null;}

Get method execution process:

1) get the current thread object 2) get the ThreadLocalMap object through the current thread object 3) if the ThreadLocalMap object exists, take the current ThreadLocal instance as key and get the data 4) if the ThreadLocalMap object does not exist, initialize the value value through the initialValue method.

Public void remove () {ThreadLocalMap m = getMap (Thread.currentThread ()); if (m! = null) m.remove (this);}

Remove method execution process:

1) get the ThreadLocalMap object through the current thread object. 2) if the ThreadLocalMap object exists, delete 4.2 ThreadLocalMap source code using the current ThreadLocal instance as key.

ThreadLocalMap is the inner class of ThreadLocal, which does not implement the Map interface, but implements the function of Map alone.

Member variables:

/ * * initial capacity, must be the integer power of 2 * / private static final int INITIAL_CAPACITY = 16 entry * * the table where the data is stored, and the data length is also the integer power of 2 * / private Entry [] table;/** * the number of entry in the array * / private int size = 0 private int threshold; * * threshold for expansion * / private int threshold; / / Default to 0

Entry inner class:

Static class Entry extends WeakReference

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.