1 前言

变量值共享可以使用静态变量形式，所有的线程都可以使用同一个静态变量。如果想实现每一个线程都有自己的共享变量如何解决？Java提供ThreadLocal类来解决这个问题。

ThreadLocal类主要解决每个线程绑定自己的值，ThreadLocal对象可以提供线程局部变量，每个线程Thread拥有一份自己的副本变量，多个线程互不干扰。ThreadLocal类可以看做全局存储数据的盒子，盒子中可以存储每个线程的私有数据。

接下来就说说ThreadLocal的使用以及其原理，我也是作为一个学习者，如果我有写错的地方请大家多多包涵，并欢迎指正！

2 正文

先来看一个ThreadLocal的简单使用：

public class Demo19 {
        public static void main(String[] args) {
            ThreadLocal tl = new ThreadLocal();
            // 获取当前线程存储的数据
            if (tl.get() == null){
                // 保存当前线程的数据
               System.out.println("The Value is NUll");
                tl.set("ThreadLocal test Demo!");
            }
            System.out.println(tl.get());
            System.out.println(tl.get());
        }
    }

运行结果：

ThreadLocal的源码如下：

通过源码可以发现ThreadLocal有get方法和set方法。

所以可以理解：ThreadLocal提供了线程的局部变量，每个线程都可以通过set()和get()来对这个局部变量进行操作，但不会和其他线程的局部变量进行冲突，实现了线程的数据隔离。

也就是说往ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。

ThreadLocal的get、set源码如下：

  /**
     * 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) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
/**
 * 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
    ThreadLocalMap map = getMap(t);
    // 如果map不为空（存在），则将当前线程对象t作为key，要存储的对象作为value存到map里面去
    if (map != null)
        map.set(this, value);
    else
    // 如果该Map不存在，则初始化一个
        createMap(t, value);
}

可以发现不管是get还是set方法都有个ThreadLocalMap，而ThreadLocalMap的源码如下：

通过上面的源码发现ThreadLocalMap是ThreadLocal的一个内部类。Thread为每个线程维护了ThreadLocalMap这么一个Map，并且用Entry类来进行存储，值都是存储到这个Map上的，可以简单地将ThreadLocalMap的key视作LocalThread对象本身，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用--WeakReference）。

每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。如果该Map存在，则从Thread中获取！该Map不存在，则初始化一个。

ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构。

其数据结构可以总结如下：

ThreadLocal的对象引用关系如下：

通过上面的对象引用的图可以发现，由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。

这里顺便提一下Java的四种引用类型：

强引用：我们常常new出来的对象就是强引用类型，只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足的时候

软引用：使用SoftReference修饰的对象被称为软引用，软引用指向的对象在内存要溢出的时候被回收

弱引用：使用WeakReference修饰的对象被称为弱引用，只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收

虚引用：虚引用是最弱的引用，在 Java 中使用 PhantomReference 进行定义。虚引用中唯一的作用就是用队列接收对象即将死亡的通知

所以想要避免内存泄露就要对其进行手动remove()！

public class Demo20 {
    public static void main(String[] args) {
        ThreadLocal tl = new ThreadLocal();
        Thread t1 = new Demo20ThreadA(tl);
        t1.setName("A");
        t1.start();

        Thread t2 = new Demo20ThreadA(tl);
        t2.setName("B");
        t2.start();
    }
}

class Demo20ThreadA extends Thread{
    private ThreadLocal tl;
    public Demo20ThreadA(ThreadLocal tl){
        this.tl = tl;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 100; i++) {
                tl.set(Thread.currentThread().getName() + (i + 1));
                System.out.println(Thread.currentThread().getName() + " get value = " + tl.get());
                Thread.sleep(100);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

部分运行结果如下：

3 总结

通过上面的分析可以得出以下结论：

1、Java提供ThreadLocal类来实现每一个线程都有自己的共享变量的问题。

2、每个Thread维护着一个ThreadLocalMap的引用，ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储,调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值是传递进来的对象；调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象

3、ThreadLocal本身并不存储值，它只是作为一个key来让线程从ThreadLocalMap获取value。

本文是结合网上一些对于ThreadLocal介绍的文章加上一些自己的理解而得出的，本文的介绍也比较片面加浅显，如果文章有错的地方欢迎指正，大家互相交流。

相关推荐：

多线程编程之 ThreadLocal怎么用？

1 前言

2 正文

3 总结