关于ThreadLocal的实现原理以及ThreadLocal为什么会造成内存泄露

系统管理员 2022-05-25 02:07 265阅读 0赞

# ThreadLocal是干嘛的？ #

可以私有化存储线程的变量值，  
典型的应用比如在一个Spring的事务中，两次执行SQL需要拿到同一个数据库的connection对象，如何能够保证两次从连接池中拿到的是同一个对象？就可以把connection对象放到线程的ThreadLocal中。我们来看一个关于ThreadLocal的使用Demo

**一个关于ThreadLocal的使用Demo**

static class ResourceClass { 
    
    	public final static ThreadLocal<String> RESOURCE_1 =
    								   new ThreadLocal<String>();
    
    	public final static ThreadLocal<String> RESOURCE_2 =
    								   new ThreadLocal<String>();
    
    }
    
    static class A { 
    
    	public void setOne(String value) { 
    		ResourceClass.RESOURCE_1.set(value);
    	}
    
    	public void setTwo(String value) { 
    		ResourceClass.RESOURCE_2.set(value);
    	}
    }
    
    static class B { 
    	public void display() { 
    		System.out.println(ResourceClass.RESOURCE_1.get()
    					+ ":" + ResourceClass.RESOURCE_2.get());
    	}
    }
    
    public static void main(String []args) { 
    	final A a = new A();
    	final B b = new B();
    	for(int i = 0 ; i < 15 ; i ++) { 
    		final String resouce1 = "线程-" + I;
    		final String resouce2 = " value = (" + i + ")";
    		new Thread() { 
    			public void run() { 
    			try { 
    				a.setOne(resouce1);
    				a.setTwo(resouce2);
    				b.display();
    			}finally { 
    				ResourceClass.RESOURCE_1.remove();
    				ResourceClass.RESOURCE_2.remove();
    			}
    		}
    	}.start();
    	}
    }

输出

线程-4: value = (4)
    线程-2: value = (2)
    线程-5: value = (5)
    线程-1: value = (1)
    线程-0: value = (0)
    线程-3: value = (3)
    线程-6: value = (6)
    线程-7: value = (7)
    线程-10: value = (10)
    线程-11: value = (11)
    线程-9: value = (9)
    线程-12: value = (12)
    线程-13: value = (13)
    线程-8: value = (8)
    线程-14: value = (14)

可以看到线程是交替执行的，但是每个线程取到的值却没有乱，说明已经做到了线程的私有化。接下来我们来说说ThreadLocal的实现原理

# ThreadLocal的实现原理 #

**看ThreadLocal的set方法源码**

public void set(T value) { 
    	//获取当前线程
        Thread t = Thread.currentThread();
        //获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null)
        	//以当前ThreadLocal对象为键，value为值存储到map中
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    ThreadLocalMap getMap(Thread t) { 
    	//获取当前线程的ThreadLocalMap
        return t.threadLocals;
    }

可以看到这里实际上是获取当前线程的ThreadLocalMap对象，那么这个ThreadLocalMap是什么东西呢？

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

我们可以理解为是一个简化版的Map，之所以说是简化版，是因为键与键之间不存在next应用。  
那么也就是说，每个线程天生就存在一个map属性。当我们调用ThreadLocal的`set`方法时，实际上是以当前ThreadLocal对象为键，我们set的value为值存储到这个map中。那么get的时候又是如何get的呢？

**ThreadLocal的get方法源码**

public T get() { 
        Thread t = Thread.currentThread();
        //获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null) { 
        	//以当前ThreadLocal对象为键,获取到map中的对象
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) { 
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

想必你也猜到了，get方法就是set方法的逆过程，通过获取当前线程的`ThreadLocalMap`对象，然后以`ThreadLocal`对象为key获取value。为了便于记忆，我画出了存储结构图

# ThreadLocal存储结构图 #

![这里写图片描述][70]  
也就是说 ThreadLocal 本身并不存储值，它只是作为一个 key 存储到 ThreadLocalMap中。这一点网上很多文章其实是说错的了的。

# ThreadLocal内存泄漏问题 #

## 为什么会造成内存泄漏 ##

上面我们说到，ThreadLocal通过把自己当初key，把set的值当初了value保存到了线程的变量ThreadLocalMap中，保存的方法是`ThreadLocalMap.set`，我们看ThreadLocalMap的set方法的关键代码

private void set(ThreadLocal<?> key, Object value) { 
    	//其余代码略
        tab[i] = new Entry(key, value);
    }
    
    static class Entry extends WeakReference<ThreadLocal<?>> { 
        Object value;
    
        Entry(ThreadLocal<?> k, Object v) { 
            super(k);
            value = v;
        }
    }

可以看到Entry是继承了WeakReference，WeakReference如字面意思，弱引用。那么也就是说，ThreadLocalMap中保存的Entry实际上是一个弱引用对象（这句话可能需要对map源码熟悉的人才能看懂），而弱引用对象，其所指向的对象在GC的时候是会被回收掉。

**Java中弱引用的简单定义**

> 当一个对象仅仅被weak reference（弱引用）指向, 而没有任何其他strong reference（强引用）指向的时候，如果这时GC运行, 那么这个对象就会被回收，不论当前的内存空间是否足够，这个对象都会被回收。

**ThreadLocal中的内存泄漏原因**  
那么也就是说，ThreadLocal对象我们程序用完了由于从 `程序->ThreadLocal` 这条强引用链不存在了，而`线程本身->ThreadLocalMap->Entry->ThreadLocal` 这条链又是一条虚引用链，那么GC的时候`ThreadLocal`就会被回收了。但是使用ThreadLocal对象作为key的这些Entry本身是不会被清除的，为什么呢？因为存在一条强引用链。即`线程本身->ThreadLocalMap->Entry`，而有由于作为Entry的key对象的ThreadLocal被回收了，这样就会在ThreadLocalMap中存在一些key为null的Entry。因为key变成null了，我们是没法访问这些Entry的，但由于Entry中还保存着value，value可能还占用着一大块内存，那么这部分内存就相当于内存泄漏了，因为他占用着内存没法回收，而我们又没法访问到它。  
理论上，这条线程结束，这部分内存就会被回收，但是我们在使用线程池的时候，线程使用完了是会放回到线程池循环使用的。由于ThreadLocalMap的生命周期和线程一样长，如果没有手动删除对应key就会导致这块内存即不会回收也无法访问，也就是内存泄漏。

**如何解决ThreadLocal的内存泄漏问题**  
其实，ThreadLocalMap的设计中已经考虑到这种情况，也加上了一些防护措施：在调用ThreadLocal的`get()/set()/remove()`方法的时候都会清除线程ThreadLocalMap里所有key为null的value。但是这些举动不能保证内存就一定会回收，因为可能这条线程被放回到线程池里后再也没有使用，或者使用的时候没有调用其`get()/set()/remove()`方法。  
但需要注意的是，并不是所有使用ThreadLocal的地方，都要在最后`remove()`，他们的生命周期可能是需要和项目的生存周期一样长的，所以要进行恰当的选择，以免出现业务逻辑错误。

**为什么使用弱引用，内存泄漏是否是弱引用的锅？**  
你是否觉得，如果我们把弱引用改成强引用就能够解决内存泄漏的问题呢？

下面我们分两种情况讨论：  
（1）key 使用强引用：引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。

（2）key 使用弱引用：引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用`set、get、remove`的时候会被清除。

**因此：内存泄漏归根结底是由于ThreadLocalMap的生命周期跟Thread一样长。如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。**

[70]: /images/20220525/cb8e54978602494ea4dd36f42285b0af.png