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

This article focuses on "ThreadLocal source code analysis into how to achieve ThreadLocal", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Next let the editor to take you to learn "ThreadLocal source code analysis into how to achieve ThreadLocal" bar!

1 introduction

ThreadLocal is a thread-local variable (cache), which is often used to implement the scenario in which variables interact within the same thread, and there is no interaction between threads. It maintains a data within each thread, and the value of set in a thread can only be get in a thread.

Specific usage scenarios: for example, you can use ThreadLocal to encapsulate database connections; you can also use ThreadLocal to transfer data between methods under complex logic: if you set a data at the beginning, but because the call logic is complex, and you need to get this data again after many classes and methods are called, then you can use ThreadLocal to cache the data, which is very convenient to access. It is important to note, however, that all of these operations must be done in the same thread, that is, set and get in the same thread. In the Spring framework, in addition to using HashMap and ConcurrentHashMap for various caches, ThreadLocal is also used to cache data.

1.1 ThreadLocal and synchronization control

Beginners of ThreadLocal may think that it is the same synchronization mechanism as synchronized and ReentrantLock (I have previously written an article on ReentrantLock source code analysis-the exclusive mode of AQS source code in-depth analysis-detailed explanation of ReentrantLock lock features), but in fact they are completely different things. The implementation is different, and the solution scenarios are also different. Synchronized and ReentrantLock use time-for-space thinking and are used to access shared variables in multithreaded scenarios. Threads that cannot get resources are queued to get them, while ThreadLocal uses space for time for data isolation and data sharing within a single thread. The set method caches data only in the current thread, and the get method only gets this data in the current thread, which is not available by calling the get method in another thread (calling the get method in another thread will only get the value that ThreadLocal caches in that thread).

1.2 ThreadLocalMap

ThreadLocal maintains a static inner class ThreadLocalMap,ThreadLocal in which all operations are implemented. (by the way: I have read a lot of articles about ThreadLocal source code analysis, but they have not analyzed the implementation of ThreadLocalMap. Without the analysis of the ThreadLocalMap level, of course, we will find the implementation of ThreadLocal very simple. Because ThreadLocal can only be said to be a wrapper, the core operations are all in ThreadLocalMap):

1 static class ThreadLocalMap {2 3 static class Entry extends WeakReference k = e.get (); 17 18 / * 19 if this ThreadLocal is the ThreadLocal of the current thread, update the value value, that is, overwrite the value. Then return 20. If it is not equal, it means that a hash conflict has occurred. At this time, continue to look for the next hash slot, that is, using linear detection method 21 * / 22 if (k = = key) {23 e.value = value; 24 return 25} 26 27 / * 28 if the current slot is not null, but the saved ThreadLocal is null, the weak reference is recycled (Entry inherits the weak reference) 29 the junk data (and other invalid locations) in this location will be deleted at this time. Prevent memory leaks 30 * / 31 if (k = = null) {32 replaceStaleEntry (key, value, I) 33 return 34} 35} 3637 / * 38 come here to show that all the above for loops have finished and no key equivalent node or key node is found. At this time, I is the next slot 39 to be inserted, so just insert the new value data into this location now 40 * / 41 tab [I] = new Entry (key, value) 42 / / count + 1 43 int sz = + + size; 44 / * 45 when the data is stored, it will check whether garbage data needs to be cleaned up. If there is no garbage data, 46 and the capacity of the current array is greater than or equal to the threshold threshold, "expand" 47 * / 48 if (! cleanSomeSlots (I, sz) & & sz > = threshold) 49 rehash () 50} 6 cleaning method of dirty Entry

It has been said before that there will be memory leaks in ThreadLocal, that is, dirty data with ThreadLocal of null. So you can see at line 32 above that it was processed:

1 / * * 2 * ThreadLocal: 3 * / 4 private void replaceStaleEntry (ThreadLocal key, Object value, 5 int staleSlot) {6 Entry [] tab = table; 7 int len = tab.length; 8 Entry e 9 10 / * 11 look forward from the staleSlot location to find the first ThreadLocal null hash slot location (that is, junk data) 12 here does not directly use staleSlot but uses a traversal to determine the slotToExpunge because: here will not only delete the junk data at the staleSlot location, but also delete all the junk data 14 * / 15 int slotToExpunge = staleSlot 16 / / forward ring search junk data 17 for (int I = prevIndex (staleSlot, len); 18 (e = tab [I])! = null; 19 I = prevIndex (I, len)) 20 if (e.get () = = null) 21 slotToExpunge = I; 22 23 / backward ring search 24 for (int I = nextIndex (staleSlot, len) 25 (e = tab [I])! = null; 26 I = nextIndex (I, len)) {27 / / get ThreadLocal 28 ThreadLocal k = e.get () saved in the Entry in the current slot 29 30 / / if key (ThreadLocal) is the same, 31 if (k = = key) {32 / / just overwrite the value 33 e.value = value 34 35 / * 36 will exchange staleSlot (garbage location) and I data at the same time 37 (because tab [I] data is already cached on it, there is no need to temporarily store variables) 38 after the exchange The garbage data goes to I (this ensures that the garbage data will eventually be placed in the last hash slot of 39 same key, ensuring the order of hash) 40 * / 41 tab [I] = tab [staleSlot] 42 tab [staleSlot] = e 43 44 / * 45 if no junk data is found during the previous forward circular search, I is assigned to slotToExpunge, 46 which means taking the current I position as the starting point for cleaning 47 * / 48 if (slotToExpunge = = staleSlot) 49 slotToExpunge = I 50 / / find junk data and clean up 51 cleanSomeSlots (expungeStaleEntry (slotToExpunge), len); 52 return 53} 54 55 / * 56 if no junk data is found in the previous forward loop search, but it is found in the backward loop search at this time, 57 assigns I to slotToExpunge Take the current I position as the starting point for cleaning 58 * / 59 if (k = = null & & slotToExpunge = = staleSlot) 60 slotToExpunge = I 61} 62 63 / / if the same key is not found in the above loop, set the value at the junk data location to null, remove the strong reference 64 tab [staleSlot] .value = null; 65 / / and assign a new Entry (that is, the data that currently needs to be entered by set) 66 tab [staleSlot] = new Entry (key, value) 67 68 / / if junk data is found during the above backward circular search, it is also necessary to clean up 69 if (slotToExpunge! = staleSlot) 70 cleanSomeSlots (expungeStaleEntry (slotToExpunge), len) 71} 72 73 / * * 74 * lines 17 and 19 code: 75 * find the previous location according to the specified hash slot location, and if you have reached the first location, return to the last location 76 * / 77 private static int prevIndex (int I, int len) {78 return ((I-1 > = 0)? I-1: len-1); 79} 80 81 / * 82 * 24, 26, 105, 107, 132 and 154: 83 * find the next location according to the specified hash slot location, and if you have reached the last location, return to the first location 84 * / 85 private static int nextIndex (int I, int len) {86 return ((I + 1)

< len) ? i + 1 : 0); 87 } 88 89 /** 90 * 第51行、第70行和第164行代码处： 91 */ 92 private int expungeStaleEntry(int staleSlot) { 93 Entry[] tab = table; 94 int len = tab.length; 95 96 //删除垃圾数据位置处的强引用value和Entry 97 tab[staleSlot].value = null; 98 tab[staleSlot] = null; 99 //计数-1 100 size--; 101 102 Entry e; 103 int i; 104 //从staleSlot位置处向后环形搜索 105 for (i = nextIndex(staleSlot, len); 106 (e = tab[i]) != null; 107 i = nextIndex(i, len)) { 108 //获取当前槽中的Entry中保存的ThreadLocal 109 ThreadLocal k = e.get(); 110 if (k == null) { 111 //如果再次遇到垃圾数据，就将其清理掉，并且计数-1 112 e.value = null; 113 tab[i] = null; 114 size--; 115 } else { 116 /* 117 在线性探测中删除一个节点的话，是不能简单地将一个节点置为null就完事了的。因为在线性探测查找的时候， 118 如果遍历时遇到一个为null的位置，就可以停止遍历、认定为找不到这个数据了。而如果删除的时候只将这个数据 119 置为null的话，那么后面的节点就有可能会访问不到。本来存在的数据，但却访问不到，从而出现了问题 120 所以在这里需要对staleSlot后面的节点做一些处理，这里选择的是rehash的方式 121 122 获取哈希槽的位置 123 */ 124 int h = k.threadLocalHashCode & (len - 1); 125 //如果这次获取哈希槽的位置和i不同的话（如果相同就不转移） 126 if (h != i) { 127 //就将tab[i]位置的数据清空 128 tab[i] = null; 129 130 //并且重新线性探测一个新的空位置处 131 while (tab[h] != null) 132 h = nextIndex(h, len); 133 //同时把数据转移进去 134 tab[h] = e; 135 } 136 } 137 } 138 /* 139 返回staleSlot位置后第一个为null的哈希槽位置，从本方法的实现中可以看出：本方法只是清理了从staleSlot 140 到其后不为null的这一段哈希槽的垃圾数据，并不是清理全部哈希槽。清理全部的话需要借助下面的cleanSomeSlots方法 141 */ 142 return i; 143 144 145 /** 146 * 第51行和第70行代码处： 147 */ 148 private boolean cleanSomeSlots(int i, int n) { 149 boolean removed = false; 150 Entry[] tab = table; 151 int len = tab.length; 152 do { 153 //获取下一个哈希槽的位置 154 i = nextIndex(i, len); 155 //获取其中的Entry 156 Entry e = tab[i]; 157 //如果有垃圾数据的话（Entry不为null但是其中的ThreadLocal为null） 158 if (e != null && e.get() == null) { 159 //就将n重新置为当前数组的长度，再重新进行do-while循环 160 n = len; 161 //删除标志位置为true 162 removed = true; 163 //调用expungeStaleEntry方法来删除垃圾数据，删除后会继续循环，直到n等于0为止 164 i = expungeStaleEntry(i); 165 } 166 //n每次循环都会除以2 167 } while ((n >

> > = 1)! = 0); 168 / / returns the capacity expansion method of 169169 return removed; 170} 7 that indicates whether junk data has been deleted.

As you can see in line 49 of the map.set method, the rehash method determines whether expansion is needed and removes any possible junk data:

1 / * * 2 * ThreadLocal: 3 * if you need to expand the capacity, you will first check whether the current full table contains junk data. If there is junk data and the deleted data is still more than half of the array capacity, then expand 4 * / 5 private void rehash () {6 / / whether the full table scan contains junk data. If so, delete 7 expungeStaleEntries (). 8 9 / * 10 if after calling the above expungeStaleEntries method, the size is still greater than or equal to threshold*0.75 (that is, half the capacity of the array), 11 will expand the capacity 12 * / 13 if (size > = threshold-threshold / 4) 14 resize () 15} 16 17 / * 18 * Line 7: 19 * traverse backwards from the first position of the table array. If junk data is found (Entry is not null but ThreadLocal is null), 20 * call the expungeStaleEntry method to delete 21 * / 22 private void expungeStaleEntries () {23 Entry [] tab = table; 24 int len = tab.length; 25 for (int j = 0) J < len; jungle +) {26 Entry e = tab [j]; 27 if (e! = null & & e.get () = null) 28 expungeStaleEntry (j); 29} 30} 31 32 / * 33 * 14: 34 * / 35 private void resize () {36 Entry [] oldTab = table; 37 int oldLen = oldTab.length 38 / / the capacity of the new array is twice that of the old array (k = e.get () is not used here; 47 if (k = = key) 48 / / if the ThreadLocal is equal, return this Entry 49 return e 50 if (k = = null) 51 / * 52 if Entry is not null but ThreadLocal is null, it means that the current data is junk data 53 call the expungeStaleEntry method to delete 54 * / 55 expungeStaleEntry (I) 56 else 57 / / otherwise find the location of the next hash slot by linear detection 58 I = nextIndex (I, len); 59 / re-update the Entry pointing to 60 e = tab [I]; 61} 62 / return null 63 return null if you can't find it after the loop 64} 65 66 / * * 67 * line 22 code: 68 * / 69 private T setInitialValue () {70 / / get the initial value 71 T value = initialValue (); 72 / get the current thread 73 Thread t = Thread.currentThread (); 74 / get threadLocals 75 ThreadLocalMap map = getMap (t) 76 if (map! = null) 77 / / if threadLocals exists, store the initial data 78 map.set (this, value) in it; 79 else 80 / / if ThreadLocalMap is not initialized, complete the initialization and put in the initial data 81 createMap (t, value); 82 / / finally return this initial value to 83 return value 84} 85 86 / * * 87 * line 71 code: 88 * this method returns null by default, and the caller can overwrite 89 * / 90 protected T initialValue () {91 return null; 92} 9 remove method 1 / * 2 * ThreadLocal: 3 * / 4 public void remove () {5 / / to get threadLocals 6 ThreadLocalMap m = getMap (Thread.currentThread ()) in the current thread 7 if (m! = null) 8 / / delete if not for null (the current ThreadLocal is deleted) 9 m.remove (this); 10} 11 12 private void remove (ThreadLocal key) {13 Entry [] tab = table; 14 int len = tab.length; 15 / / get the location of the hash slot 16 int I = key.threadLocalHashCode & (len-1) 17 for (Entry e = tab [I]; 18 e! = null 19 e = tab [I = nextIndex (I, len)]) {20 / / traverses the table array, if the ThreadLocal is equal (if the hash conflict occurs, then use linear probe to find the next hash slot) 21 if (e.get () = = key) {22 / / clear ThreadLocal 23 e.clear () 24 / / also attempted to delete junk data 25 expungeStaleEntry (I); 26 return; 27} 28} 29} 10 InheritableThreadLocal

InheritableThreadLocal is a subclass of ThreadLocal. As we know previously, ThreadLocal can only share variables within the same thread, while InheritableThreadLocal can share variables not only within the same thread, but also between parent and child threads. For example, if a child thread b is created in parent thread a, then variables wrapped in InheritableThreadLocal in thread a can also be obtained in child thread b. It is important to note, however, that InheritableThreadLocal, like ThreadLocal, still cannot share the values of variables in peer threads. And InheritableThreadLocal can only be passed from father to son, not from son to father (and it is not always possible to pass data from father to son at the beginning of initialization, as you will see later).

1 public class InheritableThreadLocal extends ThreadLocal {2 3 protected T childValue (T parentValue) {4 return parentValue; 5} 6 7 ThreadLocalMap getMap (Thread t) {8 return t.ThreadLocals; 9} 10 11 void createMap (Thread t, T firstValue) {12 t.inheritableThreadLocals = new ThreadLocalMap (this, firstValue); 13} 14}

The above is all the source code of InheritableThreadLocal, it can be seen that it only overrides the three methods of ThreadLocal. You can see the inheritableThreadLocals property in the getMap and createMap methods, so what exactly is this property for? It is actually the same as the threadLocals property, which is placed in the Thread class:

1 public class Thread implements Runnable {2 / /... 3 4 / * ThreadLocal values pertaining to this thread. This map is maintained 5 * by the ThreadLocal class. * / 6 ThreadLocal.ThreadLocalMap threadLocals = null; 7 8 / * 9 * InheritableThreadLocal values pertaining to this thread. This map is 10 * maintained by the InheritableThreadLocal class. 11 * / 12 ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; 13 14 / /... 15}

It is precisely because of the inheritableThreadLocals property that the child thread can access local variables in the parent thread.

When the thread is created, the init method of the Thread class is called:

1 / * * 2 * Thread: 3 * / 4 private void init (ThreadGroup g, Runnable target, String name, 5 long stackSize, AccessControlContext acc, 6 boolean inheritThreadLocals) {7 / /... 8 9 Thread parent = currentThread () 10 / /... 11 if (inheritThreadLocals & & parent.inheritableThreadLocals! = null) 12 / * 13 initializes the data of the inheritableThreadLocals in the parent thread to a new ThreadLocalMap, 14 and assigns inheritableThreadLocals 15 * / 16 this.inheritableThreadLocals = 17 ThreadLocal.createInheritedMap (parent.inheritableThreadLocals) to the child thread; 18 / /. 19}

Other irrelevant logic is omitted here, just take a look at the initialization process of inheritableThreadLocals and further trace the code on line 17:

1 / * * 2 * ThreadLocal: 3 * / 4 static ThreadLocalMap createInheritedMap (ThreadLocalMap parentMap) {5 / / parentMap is the data 6 return new ThreadLocalMap (parentMap) in the parent thread 7} 8 9 / * * 10 * copy the inheritableThreadLocals from the parent thread into a new ThreadLocalMap 11 * I think it should be possible to return the parentMap directly here, but it feels like rebuilding a 12 * ThreadLocalMap here is to clean up the hash slot where Entry is null. 13 * / 14 private ThreadLocalMap (ThreadLocalMap parentMap) {15 Entry [] parentTable = parentMap.table 16 int len = parentTable.length; 17 / / sets the threshold 18 setThreshold (len) of the child thread; 19 / / initializes the table of the child thread (because it is called here when the child thread is created, there is no need to determine whether it has been initialized, it must be uninitialized) 20 table = new Entry [len]; 21 22 / traverses the table 23 for in the parent thread (int j = 0 J < len; jungle +) {24 / / get Entry 25 Entry e = parentTable [j]; 26 if (e! = null) {27 / / get ThreadLocal 28 @ SuppressWarnings ("unchecked") 29 ThreadLocal key = (ThreadLocal) e.get () saved in the current slot. 30 if (key! = null) {31 / / the childValue method overridden by InheritableThreadLocal is called here, that is, 32 Object value = key.childValue (e.value) is returned to e.value itself; 33 / / build a new Entry 34 Entry c = new Entry (key, value) 35 / / get the location of the hash slot 36 int h = key.threadLocalHashCode & (len-1); 37 / / find the position to be inserted by linear detection 38 while (table [h]! = null) 39 h = nextIndex (h, len) 40 / / insert data 41 table [h] = c; 42 / / count + 1 43 size++; 44} 45} 46} 47} 48 49 / * 50 * InheritableThreadLocal: 51 * 32 line code: 52 * / 53 protected T childValue (T parentValue) {54 return parentValue 55}

The complete process is as follows:

First, when the parent calls the set or get method, the InheritableThreadLocal overridden getMap method returns inheritableThreadLocals, but because it is not initialized, the overridden createMap method is called to create the ThreadLocalMap and assign the value to inheritableThreadLocals. In this way, the inheritableThreadLocals property of the parent thread is not null; then the parent thread calls the set method to assign a value to the table array in the inheritableThreadLocals property of the parent thread.

Then when the child thread is created, the ThreadLocal.createInheritedMap method in the init method of the Thread class is called. Initialize the data in the parent thread's inheritableThreadLocals property to a new ThreadLocalMap and assign a value to the child thread's inheritableThreadLocals. In this way, the inheritableThreadLocals property of the thread has the data in the parent thread.

Finally, the child thread can get the data in the parent thread when it calls the get method. But it should be noted that after the child thread finishes execution, the parent thread calls the get method to get the same inheritableThreadLocals in the parent thread, not the ThreadLocalMap to which the child thread will change. In other words, the data of the child thread is not passed to the parent thread, and the child thread synchronizes the data in the parent thread only when it is initialized.

At this point, I believe that everyone on the "ThreadLocal source code analysis into how to achieve ThreadLocal" have a deeper understanding, might as well to the actual operation of it! Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.