ThreadLocal原理剖析

不念不忘少年蓝@ 2023-01-20 06:53 284阅读 0赞

`ThreadLocal`提供线程局部变量。 这些变量与普通变量不同，因为每个访问一个线程（通过其get或set方法）的线程都有其自己的，独立初始化的变量副本。通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。而使用ThreadLocal创建的变量只能被当前线程访问，其他线程则无法访问和修改。 ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态字段（例如，用户ID或事务ID）供线程局部变量。 这些变量与普通变量不同，因为每个访问一个线程（通过其get或set方法）的线程都有其自己的，独立初始化的变量副本。

## 使用方法 ##

### 创建对象 ###

ThreadLocal<String> threadLocal = new ThreadLocal<>();

set()方法

threadLocal.set("HelloWorld");

get()方法

threadLocal.get();

Example:

public class ThreadLocalTest { 
        public static void main(String[] args) { 
            ThreadLocal<OperatorContext> threadLocal = new ThreadLocal<>();
    
            Thread thread1 = new Thread(() -> { 
                OperatorContext operatorContext = new OperatorContext();
                operatorContext.setUsername("xybh");
                operatorContext.setPassword("password");
                threadLocal.set(operatorContext);
    
                while (true) { 
                    System.out.println("thread1: " + threadLocal.get());
                    try { 
                        Thread.sleep(500);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            });
    
            Thread thread2 = new Thread(() -> { 
                OperatorContext operatorContext = new OperatorContext();
                operatorContext.setUsername("daodan");
                operatorContext.setPassword("root");
                threadLocal.set(operatorContext);
    
                while (true) { 
                    System.out.println("thread2: " + threadLocal.get());
                    try { 
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            });
    
            thread1.start();
            thread2.start();
        }
    
        static class OperatorContext { 
            private String username;
            private String password;
    
            public OperatorContext() { }
    
            public String getUsername() {  return username; }
            public void setUsername(String username) {  this.username = username; }
            public String getPassword() {  return password; }
            public void setPassword(String password) {  this.password = password;}
    
            @Override
            public String toString() { 
                return "OperatorContext{" +
                        "username='" + username + '\'' +
                        ", password='" + password + '\'' +
                        '}';
            }
        }
    }

thread1: OperatorContext{ username='xybh', password='password'}
    thread2: OperatorContext{ username='daodan', password='root'}
    thread1: OperatorContext{ username='xybh', password='password'}
    thread2: OperatorContext{ username='daodan', password='root'}
    thread1: OperatorContext{ username='xybh', password='password'}
    thread1: OperatorContext{ username='xybh', password='password'}
    thread2: OperatorContext{ username='daodan', password='root'}

两个线程之间数据互不干扰

## 源码解析 ##

为了更好的学习ThreadLocal的实现机制，必须去研究它的源码，了解它的实现机制。

### 类声明及创建方法 ###

首先我们先看一下类的声明以及创建方法  
ThreadLocal支持泛型，可以存储简单属性也可存储复合属性，常用于保存线程上下文。

public class ThreadLocal<T> { 
        
        /** * Creates a thread local variable. The initial value of the variable is * determined by invoking the {@code get} method on the {@code Supplier}. * * @param <S> the type of the thread local's value * @param supplier the supplier to be used to determine the initial value * @return a new thread local variable * @throws NullPointerException if the specified supplier is null * @since 1.8 */
        public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) { 
            return new SuppliedThreadLocal<>(supplier);
        }
    
        /** * Creates a thread local variable. * @see #withInitial(java.util.function.Supplier) */
        public ThreadLocal() { 
        }
    }

ThreadLocal中有两种实现方法，一种是未带任何实现的默认构造函数，一种是通过withInitial(Supplier<? extends S> supplier)方法，可通过实现Supplier接口产生带初始值的ThreadLocal对象。

### get()和set() ###

接下来我们再看到ThreadLocal中最重要的两个方法get()和set()  
首先我们先看到get()方法

public T get() { 
         Thread t = Thread.currentThread();
         ThreadLocalMap map = getMap(t);
         if (map != null) { 
             ThreadLocalMap.Entry e = map.getEntry(this);
             if (e != null) { 
                 @SuppressWarnings("unchecked")
                 T result = (T)e.value;
                 return result;
             }
         }
         return setInitialValue();
    }

当我们调用get()方法的时候，会先获取到当前线程，然后获取到当前线程的ThreadLocalMap对象，如果非空，那么取出ThreadLocal的value，否则进行初始化，初始化就是将initialValue的值set到ThreadLocal中。

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;
    }

当ThreadLocal未调用set()方法或者为进行初始化的情况下，调用get()方法将会调用setInitialValue方法获取默认值，未重写initialValue方法的情况下，返回值为null，我们也可以重写initialValue方法来设置默认值

public class ThreadLocalTest { 
        public static void main(String[] args) { 
            new Thread(()->{ 
                StringThreadLocal stringThreadLocal = new StringThreadLocal();
                System.out.println(stringThreadLocal.get());
            }).start();
    
        }
    
        static class StringThreadLocal extends ThreadLocal<java.lang.String>{ 
            @Override
            protected java.lang.String initialValue() { 
                return "init StringThreadLocal";
            }
        }
    }

result:  
![result][]

接下来我们看下set()

public void set(T value) { 
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    void createMap(Thread t, T firstValue) { 
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

set方法很简单，首先获取当前线程，再获取当前线程的ThreadLocalMap对象，如果ThreadLocalMap对象不为空，则覆盖当前ThreadLocal为key的值(并不是以当前对象为key)，而当ThreadLocal为空时，则创建一个ThreadLocalMap对象将value赋值进去并将这个对象赋值给当前线程。

## 原理剖析 ##

### 为什么ThreadLocal里的值只能单个线程使用 ###

这个问题要看到ThreadLocalMap这个类，这个类创建后赋值给了当前线程的threadLocals，而threadLocals是每一个线程独享的，这使得ThreadLocal里的值只能单个线程使用。

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

### ThreadLocal对象存放的位置 ###

了解过JMM的同学应该清楚，在Java中，栈内存归属于单个线程，每个线程都会有一个栈内存，其存储的变量只能在其所属线程中可见，即栈内存可以理解成线程的私有内存。可能很多同学会认为应该ThreadLocal的其他线程不可见，那么它应该是存在在栈内存中，其实不然，因为ThreadLocal实例实际上也是被其创建的类持有（更顶端应该是被线程持有）。而ThreadLocal的值其实也是被线程实例持有。只不过它使用了一些技巧使其对其他线程不可见，但它还是存放在堆内存中的。

### ThreadLocal内存泄漏问题 ###

之前阅读过一些文章，说ThreadLocal存在内存泄漏问题，在使用完ThreadLocal后需要手动将其关闭，这里我们通过阅读源码发现：真正用来存储值的对象是ThreadLocalMap中的Entry，而它是一个弱引用对象。

> 弱引用: 在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。  
> 如果一个对象是偶尔(很少)的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用Weak Reference来记住此对象。

因为ThreadLocalMap在选择key的时候，并不是直接选择ThreadLocal实例，而是ThreadLocal实例的弱引用。所以实际上从ThreadLocal设计角度来说是不会导致内存泄露的。

## 参考 ##

【1】理解Java中的ThreadLocal——技术小黑屋  
【2】[ThreadLocal详解][ThreadLocal]——神一般的存在

[result]: /images/20221021/e9a03958dfb7495a9c2664fe2e4ca802.png
[ThreadLocal]: https://www.cnblogs.com/dreamroute/p/5034726.html