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

This article mainly introduces how to use the golden section in ThreadLocal, which has a certain reference value. Interested friends can refer to it. I hope you will gain a lot after reading this article. Let's take a look at it.

one。 Premise

A recent project to be compatible with old and new systems ended up using ThreadLocal (actually using InheritableThreadLocal) to get variables shared in the parent thread in the child thread. The problem is solved, but later found that the understanding of ThreadLocal is not deep enough, so by the way to read and understand its source code. Before talking about ThreadLocal, let's buy a link and talk about the golden section. This article uses JDK8 (1.8.0 to 181) when reading the ThreadLocal source code.

two。 Golden Section number and Fibonacci sequence

First, review the Fibonacci series. The following derivation comes from the wiki of a search engine:

Fibonacci series: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …

General term formula: suppose F (n) is the nth term (n ∈ N*) of the sequence, then this sentence can be written as follows: F (n) = F (n Mel 1) + F (n Mel 2).

Interestingly, such a sequence of numbers is completely natural, but the general formula is expressed by irrational numbers. And when n tends to infinity, the ratio of the former term to the latter term is getting closer and closer to 0.618 (or the decimal part of the ratio of the latter term to the former term is getting closer and closer to 0.618), and this value of 0.618 is called the golden section. The proof process is as follows:

The exact value of the golden section is (root 5-1) / 2, which is about 0.618.

three。 Application of Golden Section number

The golden section is widely used in art, photography and other art fields, because it has strict proportionality, artistry, harmony, contains rich aesthetic value, and can stimulate people's sense of beauty. Of course, these are not the directions of this paper, let's first try to find out the specific values of the golden section of unsigned and signed integers:

Public static void main (String [] args) throws Exception {/ / the 32 th power of the golden section * 2 = 2654435769-the value long c = (long) corresponding to the golden section of the unsigned 32-bit integer (1L > {/ / this is the real stored value Object value / / the Key of Entry is the ThreadLocal instance itself, and Value is the input value Entry (ThreadLocal k, Object v) {super (k); value = v;}} / / initialization capacity, which must be the power of 2 private static final int INITIAL_CAPACITY = 16 / / Hash (Entry) table. If necessary, the capacity must be expanded. The length must be 2. The number of elements (Entry) in the private Entry [] table; / / hash table private int size = 0; / / the next threshold for capacity expansion. The default is 0 private int threshold. / / set the threshold for the next capacity expansion. Set the value to 2/3 private void setThreshold (int len) of the input value len {threshold = len * 2 / 3;} / / add i private static int nextIndex (int I, int len) {return ((I + 1)) to len.

< len) ? i + 1 : 0); } // 以len为模减少i private static int prevIndex(int i, int len) { return ((i - 1 >

= 0)? I-1: len-1);}}

It is very important to note here that ThreadLocalMap$Entry is a WeakReference (weak reference), and the key value Key is the ThreadLocal instance itself, where unqualified generic wildcards are used.

Then take a look at the constructor of ThreadLocalMap:

/ / used when constructing ThreadLocal, the corresponding ThreadLocal instance method void createMap (Thread t, T firstValue) ThreadLocalMap (ThreadLocal firstKey, Object firstValue) {/ / Hash table default capacity is 16 table = new entry [inner _ CAPACITY]; / / calculate the hash code int I = firstKey.threadLocalHashCode & (INITIAL_CAPACITY-1) of the first element; table [I] = new Entry (firstKey, firstValue); size = 1; setThreshold (INITIAL_CAPACITY) } / / it is used when constructing InheritableThreadLocal to extract the contents of the ThreadLocalMap of the parent thread into the hash table of the new ThreadLocalMap / / the static method static ThreadLocalMap createInheritedMap (ThreadLocalMap parentMap) private ThreadLocalMap (ThreadLocalMap parentMap) of the corresponding ThreadLocal {Entry [] parentTable = parentMap.table; int len = parentTable.length; setThreshold (len); table = new Entry [len] / / copy for (Entry e: parentTable) {if (e! = null) {@ SuppressWarnings ("unchecked") ThreadLocal key = (ThreadLocal) e.get (); if (key! = null) {Object value = key.childValue (e.value) based on the parent hash table; Entry c = new Entry (key, value) Int h = key.threadLocalHashCode & (len-1); while (table [h]! = null) h = nextIndex (h, len); table [h] = c; size++;}

The private construct of ThreadLocalMap is provided for use by the static method ThreadLocal#createInheritedMap ().

Next, take a look at some of the example methods that ThreadLocalMap provides to ThreadLocal:

/ / if Key cannot find a hash slot in the hash table, it will call this method private Entry getEntryAfterMiss (ThreadLocal key, int I, Entry e) {Entry [] tab = table; int len = tab.length / / this will attempt to traverse the entire hash table through nextIndex. If a matching Key is found, Entry / / if there is Key = = null in the hash table, call expungeStaleEntry to clean up while (e! = null) {ThreadLocal k = e.get (); if (k = = key) return e; if (k = = null) expungeStaleEntry (I) Clear the Key and Value// 2 of the corresponding hash slot for staleSlot. Re-hash all possible conflicting hash table slots from staleSlot to the next empty hash slot, and empty the slot / / 3 whose Key is null. Note that the return value is the hash code private int expungeStaleEntry (int staleSlot) of the next empty hash slot after staleSlot {Entry [] tab = table; int len = tab.length; / / expunge entry at staleSlot / / clear Key and Value [staleSlot] .value = null; tab [staleSlot] = null; size-- of the corresponding staleSlot hash slot. / / Rehash until we encounter null / / the following procedure is to re-hash all possible conflicting hash table slots from staleSlot to the next empty hash slot, leaving the slot Entry e; int i; for with Key null (I = nextIndex (staleSlot, len); (e = tab [I])! = null; I = nextIndex (I, len)) {ThreadLocal k = e.get () If (k = = null) {e.value = null; tab [I] = null; size--;} else {int h = k.threadLocalHashCode & (len-1); if (h! = I) {tab [I] = null / / Unlike Knuth 6.4 Algorithm R, we must scan until / / null because multiple entries could have been stale. While (tab [h]! = null) h = nextIndex (h, len); tab [h] = e;} return I;} / / this method is long and replaces the value private void replaceStaleEntry (ThreadLocal key, Object value, int staleSlot) {Entry [] tab = table; int len = tab.length of Entry in the hash slot where the hash code is staleSlot. Entry e; / / Back up to check for prior stale entry in current run. / / We clean out whole runs at a time to avoid continual / / incremental rehashing due to garbage collector freeing / / up refs in bunches (i.e., whenever the collector runs). Int slotToExpunge = staleSlot; / / this loop is mainly to find the hash code for (int I = prevIndex (staleSlot, len); (e = tab [I])! = null; I = prevIndex (I, len)) if (e.get () = null) slotToExpunge = I / / Find either the key or trailing null slot of run, whichever / / occurs first / / traverses the hash slot after staleSlot. If Key matches, replace for (int I = nextIndex (staleSlot, len); (e = tab [I])! = null; I = nextIndex (I, len)) {ThreadLocal k = e.get () / / If we find key, then we need to swap it / / with the stale entry to maintain hash table order. / / The newly stale slot, or any other stale slot / / encountered above it, can then be sent to expungeStaleEntry / / to remove or rehash all of the other entries in run. If (k = = key) {e.value = value; tab [I] = tab [staleSlot]; tab [staleSlot] = e; / / Start expunge at preceding stale entry if it exists if (slotToExpunge = = staleSlot) slotToExpunge = I; cleanSomeSlots (expungeStaleEntry (slotToExpunge), len); return } / / If we didn't find stale entry on backward scan, the / / first stale entry seen while scanning for key is the / / first still present in the run. If (k = = null & & slotToExpunge = = staleSlot) slotToExpunge = I;} / / Key does not match, then create a new hash slot / / If key not found, put new entry in stale slot tab [staleSlot] .value = null; tab [staleSlot] = new Entry (key, value) / / if the current staleSlot is inconsistent with the slotToExpunge found before, a clean up will be performed / / If there are any other stale entries in run, expunge them if (slotToExpunge! = staleSlot) cleanSomeSlots (expungeStaleEntry (slotToExpunge), len);} / / A pair of Entry with Key of null in the current hash table will call expungeStaleEntryprivate void expungeStaleEntries () {Entry [] tab = table; int len = tab.length; for (int j = 0; j)

< len; j++) { Entry e = tab[j]; if (e != null && e.get() == null) expungeStaleEntry(j); }}// 清理第i个哈希槽之后的n个哈希槽，如果遍历的时候发现Entry的Key为null，则n会重置为哈希表的长度，expungeStaleEntry有可能会重哈希使得哈希表长度发生变化private boolean cleanSomeSlots(int i, int n) { boolean removed = false; Entry[] tab = table; int len = tab.length; do { i = nextIndex(i, len); Entry e = tab[i]; if (e != null && e.get() == null) { n = len; removed = true; i = expungeStaleEntry(i); } } while ( (n >

> > = 1)! = 0); return removed;} / * * this method is mainly called by `ThreadLocal#get () `to obtain the corresponding Entry * * / private Entry getEntry (ThreadLocal key) {/ / calculate the hash value of Entry int I = key.threadLocalHashCode & (table.length-1); Entry e = table [I]; if (e! = null & & e.get () = key) return e through the current ThreadLocal instance Else / / Note here, if e is null or Key does not match, getEntryAfterMiss return getEntryAfterMiss (key, I, e);} / double hash will be called. If necessary, expand private void rehash () {/ / clean up all empty hash slots, and re-hash expungeStaleEntries (). / / Use lower threshold for doubling to avoid hysteresis / / trigger capacity expansion if (size > = threshold-threshold / 4) resize () when the number of hash elements in the hash table is greater than the threshold of 3;} / / expansion, simply expand the capacity private void resize () {Entry [] oldTab = table; int oldLen = oldTab.length; int newLen = oldLen * 2; Entry [] newTab = new Entry [newLen] Int count = 0; for (Entry e: oldTab) {if (e! = null) {ThreadLocal k = e.get (); if (k = = null) {e.value = null; / / Help the GC} else {int h = k.threadLocalHashCode & (newLen-1) While (newTab [h]! = null) h = nextIndex (h, newLen); newTab [h] = e; count++;} setThreshold (newLen); size = count; table = newTab } / / set the value to the current hash table based on ThreadLocal as key. This method calls private void set (ThreadLocal key, Object value) {/ / We don't use a fast path as with get () because it is at / / least as common to use set () to create new entries as / / it is to replace existing ones, in which case, a fast / / path would fail more often than not by `hash () `. Entry [] tab = table; int len = tab.length; int I = key.threadLocalHashCode & (len-1); / / variable hash table for (Entry e = tab [I]; e! = null; e = tab [I = nextIndex (I, len)]) {ThreadLocal k = e.get (); / / Key match, directly set the value if (k = = key) {e.value = value Return;} / / if the Key of Entry is null, replace the Key to the current key and set the value if (k = = null) {replaceStaleEntry (key, value, I); return;} tab [I] = new Entry (key, value); int sz = + + size / / Clean the current newly set element's hash slot subscript to the sz segment's hash slot. If the cleanup is successful and the sz is greater than the threshold, trigger the expansion of if (! cleanSomeSlots (I, sz) & & sz > = threshold) rehash ();}

To put it simply, ThreadLocalMap is the true data storage container of ThreadLocal. In fact, all the logic of the complex part of the ThreadLocal data operation is done in ThreadLocalMap, and the ThreadLocalMap instance is a member variable of Thread, which is set to the currently executing thread instance when the ThreadLocal#set () method is called for the first time. If you use multiple ThreadLocal instances in the same thread, each ThreadLocal instance actually corresponds to a hash slot in ThreadLocalMap's hash table. For example, use multiple ThreadLocal instances in the main thread of the main function:

Public class ThreadLocalMain {private static final ThreadLocal TL_1 = new ThreadLocal (); private static final ThreadLocal TL_2 = new ThreadLocal (); private static final ThreadLocal TL_3 = new ThreadLocal (); public static void main (String [] args) throws Exception {TL_1.set (1); TL_2.set ("1"); TL_3.set (1L); Field field = Thread.class.getDeclaredField ("threadLocals") Field.setAccessible (true); Object o = field.get (Thread.currentThread ()); System.out.println (o);}}

In fact, the hash table in the threadLocals attribute of the main thread generally contains more than the three ThreadLocal we defined above, because ThreadLocal may also be used in other places when loading the main thread. The result of a Debug is as follows:

Simplify drawing with PPT:

The table in the threadLocalHashCode attribute row above is to mark the hash value of each Entry's hash slot. In fact, threadLocalHashCode is an attribute in ThreadLocal@XXXX, which is obvious that threadLocalHashCode is originally a member variable of ThreadLocal.

The above is only a simple rough analysis of the ThreadLocalMap source code, the following will make some detailed diagrams to illustrate the process of some core operations in ThreadLocal and ThreadLocalMap.

3. The creation of ThreadLocal

Judging from the constructor of ThreadLocal, the construction of the ThreadLocal instance does not do anything, just to get a generic instance of ThreadLocal, which can later be used as the key of ThreadLocalMap$Entry:

/ Note that threadLocalHashCode has determined private final int threadLocalHashCode = nextHashCode (); private static AtomicInteger nextHashCode = new AtomicInteger (); private static final int HASH_INCREMENT = 0x61c88647 * private static int nextHashCode () {return nextHashCode.getAndAdd (HASH_INCREMENT) in the construction of each new ThreadLocal` instance. } / / override the initialValue method public static ThreadLocal withInitial (Supplier >) through Supplier. When there is no strong reference to the ThreadLocal instance, the GC of JVM will reclaim the Key in the ThreadLocalMap. In this case, some Key is null, but Value is not the Entry item of null. If these Entry items are not cleaned up actively, they will always reside in ThreadLocalMap. That's why the get (), set (), and remove () methods in ThreadLocal all have blocks of code that clean up the ThreadLocalMap instance key as null. To sum up, the places where memory leaks can occur are:

ThreadLocal instances are initialized massively (statically), and the get (), set (), remove () methods are no longer called after initialization.

A large number of ThreadLocal are initialized, the ThreadLocal holds the large capacity of Value, and the threads that use these ThreadLocal instances are always active.

One of the design highlights of ThreadLocal is the use of weak references in the Key of the Entry structure in ThreadLocalMap. Imagine if you use strong references, which means that all data in ThreadLocalMap is bound to the life cycle of Thread, which can easily lead to memory leaks due to the continuous activity of a large number of threads. If weak references are used, after JVM triggers GC to recycle weak references, ThreadLocal can delete those values in ThreadLocalMap where Key is null the next time ThreadLocal calls the methods get (), set () and remove (), thus playing the role of lazy deletion and freeing memory.

In fact, the Entry hash table built by ThreadLocal in setting the inner class ThreadLocal.ThreadLocalMap has already taken into account the problem of memory leakage, so the ThreadLocal.ThreadLocalMap$Entry class is designed as a weak reference and the class signature is 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.