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

This article introduces how to analyze ThreadLocal from the interview questions. The content is very detailed. Interested friends can use it for reference. I hope it will be helpful to you.

What is ThreadLocal?

ThreadLocal is a native thread copy variable utility class. It is mainly used to make a mapping between the private thread and the replica object stored by the thread. The variables of each thread do not interfere with each other. In high concurrency scenarios, stateless calls can be achieved. It is especially suitable for scenarios where each thread relies on the value of an impassable variable to complete the operation.

Starting from the data structure

The following picture shows the internal structure of ThreadLocal.

From the structure diagram above, we have seen the core mechanism of ThreadLocal:

There is a Map inside each Thread thread. The thread local object (key) and the thread's variable copy (value) are stored in the Map, but the Map inside the Thread is maintained by ThreadLocal, and ThreadLocal is responsible for getting and setting the thread's variable value from the map.

Therefore, for different threads, each time the replica value is obtained, other threads can not get the replica value of the current thread, which forms the isolation of the copy and does not interfere with each other.

The Map inside the Thread thread is described in the class as follows:

Public class Thread implements Runnable {/ * ThreadLocal values pertaining to this thread. This map is maintained* by the ThreadLocal class. * / ThreadLocal.ThreadLocalMap threadLocals = null;}

Deep analysis of ThreadLocal

The ThreadLocal class provides the following core methods:

Public T get () public void set (T value) public void remove ()

The get () method is used to get the value of the copy variable of the current thread. The set () method is used to hold the value of the copy variable of the current thread. InitialValue () is the initial replica variable value of the current thread. The remove () method removes the value of the copy variable for the current future.

Get () method

/ * Returns the value in the current thread's copy of this* thread-local variable. If the variable has no value for the* current thread, it is first initialized to the value returned* by an invocation of the {@ link # initialValue} method.** @ return the current thread's value of this thread-local*/public T get () {Thread t = Thread.currentThread ()

ThreadLocalMap map = getMap (t)

If (map! = null) {ThreadLocalMap.Entry e = map.getEntry (this)

If (e! = null) return (T) e.value

} return setInitialValue ()

} ThreadLocalMap getMap (Thread t) {return t.threadLocals;} private T setInitialValue () {T value = initialValue ()

Thread t = Thread.currentThread ()

ThreadLocalMap map = getMap (t); if (map! = null) map.set (this, value)

ElsecreateMap (t, value); return value;} protected T initialValue () {return null;}

Steps:

1. Gets the ThreadLocalMap object threadLocals of the current thread

two。 Get the thread-stored Kmuri V Entry node from map.

3. Gets the stored Value copy value from the Entry node and returns.

If 4.map is empty, the initial value null is returned, that is, the copy of the thread variable is null. You need to judge NullPointerException when using it.

Set () method

/ * Sets the current thread's copy of this thread-local variable* to the specified value. Most subclasses will have no need to* override this method, relying solely on the {@ link # initialValue} * method to set the values of thread-locals.** @ param value the value to be stored in the current thread's copy of* this thread-local.*/public void set (T value) {Thread t = Thread.currentThread ()

ThreadLocalMap map = getMap (t)

If (map! = null) map.set (this, value)

ElsecreateMap (t, value)

} ThreadLocalMap getMap (Thread t) {return t.threadLocals

} void createMap (Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap (this, firstValue)

}

Steps:

1. Gets the member variable map of the current thread

If the 2.map is not empty, the ThreadLocal and the new copy of the value are put back into the map.

If 3.map is empty, the thread's member variable ThreadLocalMap is initialized and copies of ThreadLocal and value are placed in map.

Remove () method

/ * Removes the current thread's value for this thread-local* variable. If this thread-local variable is subsequently* {@ linkplain # get read} by the current thread, its value will be* reinitialized by invoking its {@ link # initialValue} method,* unless its value is {

@ linkplain # set set} by the current thread* in the interim.

This may result in multiple invocations of the* initialValue method in the current thread.** @ since 1.5*/public void remove () {ThreadLocalMap m = getMap (Thread.currentThread ())

If (m! = null) m.remove (this)

} ThreadLocalMap getMap (Thread t) {return t.threadLocals;}

The remove method is relatively simple and does not go into detail.

ThreadLocalMap

ThreadLocalMap is the inner class of ThreadLocal, which does not implement the Map interface, but implements the function of Map in an independent way, and its internal Entry is also implemented independently.

In ThreadLocalMap, Entry is also used to save Kmuri V structure data. However, the key in Entry can only be a ThreadLocal object, which is limited by the constructor of Entry.

Static class Entry extends WeakReference {/ * * The value associated with this ThreadLocal. * / Object value;Entry (ThreadLocal k, Object v) {super (k); value = v;}}

Entry inherits from WeakReference (weak references, and the life cycle can only survive until the next GC), but only Key is a weak reference type, and Value is not a weak reference.

Member variables of ThreadLocalMap:

Static class ThreadLocalMap {/ * The initial capacity-- MUST be a power of two.*/private static final int INITIAL_CAPACITY = 16 * The next size value at which to resize.*/private int threshold; * The table, resized as necessary.* table.length MUST always be a power of two.*/private Entry [] table;/*** The number of entries in the table.*/private int size = 0 * The next size value at which to resize.*/private int threshold; / / Default to 0}

How to resolve Hash conflict

The biggest difference between ThreadLocalMap and HashMap is that the structure of ThreadLocalMap is very simple and there is no next reference, that is to say, the way to resolve Hash conflicts in ThreadLocalMap is not a linked list, but a linear detection. The so-called linear detection is to determine the position of the element in the table array according to the hashcode value of the initial key. If it is found that other key elements are already occupied in this position, use a fixed algorithm to find the next location with a certain step size. Judge in turn until you find a location where you can store it.

ThreadLocalMap's way to resolve Hash conflicts is to simply add or subtract 1 steps to find the next adjacent location.

/ * Increment i modulo len.*/private static int nextIndex (int I, int len) {return ((I + 1)

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

Obviously, the efficiency of ThreadLocalMap to solve Hash conflicts by linear detection is very low. If a large number of different ThreadLocal objects are put into map to send conflicts, or secondary conflicts occur, the efficiency is very low.

So the good advice here is: only one variable is stored in each thread, so that the Key stored in map by all threads is the same ThreadLocal. If a thread wants to save multiple variables, it needs to create multiple ThreadLocal. When multiple ThreadLocal is put into Map, it will greatly increase the possibility of Hash conflict.

The problem with ThreadLocalMap

Because the key of ThreadLocalMap is a weak reference, while Value is a strong reference. This leads to a problem: when ThreadLocal has no strong references to external objects, when GC occurs, the weak reference Key will be recycled, but Value will not be recycled. If the thread that created the ThreadLocal continues to run, then the value in this Entry object may not be reclaimed all the time, resulting in a memory leak.

How to avoid leakage

Since Key is a weak reference, what we need to do is to call the remove method after calling the get () and set () methods of ThreadLocal to remove the reference relationship between the Entry node and Map, so that the entire Entry object becomes unreachable after GC Roots analysis and can be recycled the next time GC. If you use the set method of ThreadLocal and do not call the remove method as shown, memory leaks may occur, so it is very important to develop good programming habits. Remember to call the remove method after using ThreadLocal.

ThreadLocal threadLocal = new ThreadLocal (); try {threadLocal.set (new Session (1, "Misout's blog"); / / other business logic} finally {threadLocal.remove ();}

Application scenario

Remember the session acquisition scene of Hibernate?

Private static final ThreadLocal threadLocal = new ThreadLocal (); / / get Sessionpublic static Session getCurrentSession () {Session session = threadLocal.get (); / / determine whether Session is empty. If it is empty, a session will be created and set to the local thread variable try {if (session = = nullthread session. IsOpen ()) {if (sessionFactory==null) {rbuildSessionFactory (); / / SessionFactory} else {session = sessionFactory.openSession () of Hibernate;} threadLocal.set (session) } catch (Exception e) {/ / TODO: handle exception} return session;}

Why? Each thread accessing the database should be an independent Session session. If multiple threads share the same Session session, it is possible that other threads close the connection, and when the current thread executes the commit, the session has been closed, resulting in a system exception. This method can prevent threads from competing for Session and improve the security under concurrency.

Typical scenarios using ThreadLocal, such as database connection management and thread session management, are only suitable for copies of independent variables, but not for high concurrency if the variables are globally shared.

On how to analyze the questions from the interview ThreadLocal to share here, I hope the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

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.