多线程（46）线程局部存储

电玩女神 2024-04-24 23:13 12阅读 0赞

线程局部存储(Thread Local Storage, TLS)是一种允许数据在多个线程中被独立地存储的编程范式。在Java中，这通过`ThreadLocal`类实现，它提供了一种线程封闭的机制，确保每个线程都有自己的变量副本，从而避免了变量共享所带来的线程安全问题。

#### 工作原理 ####

`ThreadLocal`创建的变量，对于使用它的每个线程，都会提供一个独立初始化的副本，各个线程可以修改自己的副本而不会影响其他线程的副本。这种机制特别适合于实现线程安全的数据格式，或者保存线程的上下文信息，避免了同步操作的性能损耗。

#### 实现机制 ####

`ThreadLocal`内部通过维护一个`ThreadLocal.ThreadLocalMap`来实现线程局部存储，这是一个定制化的哈希映射，用于存储每个线程的局部变量。每个`Thread`对象都有一个`ThreadLocalMap`的引用，但这个映射表只能通过`ThreadLocal`对象访问。

当`ThreadLocal`的`get()`或`set(T value)`方法被调用时，会先找到当前线程的`ThreadLocalMap`，然后根据`ThreadLocal`对象作为键在这个映射表中查找或修改对应线程的局部变量。

#### 核心源码 ####

考虑到详细的源码分析可能非常复杂，这里提供一个简化的视角来理解`ThreadLocal`的核心逻辑：

public class ThreadLocal<T> {
        
        public T get() {
        
            Thread t = Thread.currentThread();
            ThreadLocalMap map = t.threadLocals;
            if (map != null) {
        
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) {
        
                    return (T)e.value;
                }
            }
            return setInitialValue();
        }
    
        public void set(T value) {
        
            Thread t = Thread.currentThread();
            ThreadLocalMap map = t.threadLocals;
            if (map != null) {
        
                map.set(this, value);
            } else {
        
                createMap(t, value);
            }
        }
        
        T initialValue() {
        
            return null;
        }
    
        private T setInitialValue() {
        
            T value = initialValue();
            Thread t = Thread.currentThread();
            ThreadLocalMap map = t.threadLocals;
            if (map != null) {
        
                map.set(this, value);
            } else {
        
                createMap(t, value);
            }
            return value;
        }
        
        // 注意：实际源码中ThreadLocalMap的实现更加复杂，这里仅为了提供一个直观的印象。
        static class ThreadLocalMap {
        
            static class Entry extends WeakReference<ThreadLocal<?>> {
        
                Object value;
                
                Entry(ThreadLocal<?> k, Object value) {
        
                    super(k);
                    this.value = value;
                }
            }
            
            private Entry[] table;
            
            void set(ThreadLocal<?> key, Object value) {
        
                // 实现省略：在表中找到或创建与key关联的条目，并更新其值
            }
            
            Entry getEntry(ThreadLocal<?> key) {
        
                // 实现省略：根据key找到对应的条目
                return null;
            }
        }
        
        void createMap(Thread t, T firstValue) {
        
            t.threadLocals = new ThreadLocalMap();
            t.threadLocals.set(this, firstValue);
        }
    }

#### 代码演示 ####

下面是一个使用`ThreadLocal`的基本示例：

public class ThreadLocalExample {
        
        public static ThreadLocal<Integer> threadLocalValue = ThreadLocal.withInitial(() -> 1);
    
        public static void main(String[] args) throws InterruptedException {
        
            for (int i = 0; i < 3; i++) {
        
                final int threadId = i;
                new Thread(() -> {
        
                    Integer value = threadLocalValue.get();
                    System.out.println("Thread " + threadId + " initial value: " + value);
                    
                    // 修改本线程的threadLocalValue
                    threadLocalValue.set(value + threadId);
                    
                    // 再次读取，显示已修改的值
                    System.out.println("Thread " + threadId + " new value: " + threadLocalValue.get());
                }).start();
            }
        }
    }

在这个例子中，每个线程都能独立地获取和设置`threadLocalValue`的值，而不会影响到其他线程。

#### 注意事项 ####

虽然`ThreadLocal`可以方便地实现线程局部存储，但它也可能导致内存泄漏问题。因为`ThreadLocal.ThreadLocalMap`中的键（`ThreadLocal`对象）是通过弱引用实现的，而值（存储的对象）是通过强引用实现的。如果一个`ThreadLocal`对象没有任何强引用指向它，那么在下一次垃圾回收时，这个`ThreadLocal`对象将被回收，但是它在`ThreadLocalMap`中对应的值不会被回收，这就可能导致内存泄漏。为了避免这种情况，一般建议在不再需要使用`ThreadLocal`变量时调用其`remove()`方法。

总之，`ThreadLocal`提供了一种优雅的线程局部存储方案，但需要谨慎使用，以避免内存泄漏等问题。