Java ThreadLocal 线程本地变量

ThreadLocal 作用

ThreadLocal的功能在Java多线程并发环境中非常实用，其作用是提供线程本地变量，例如用户ID、会话ID等与当前线程密切关联的信息。

这里提到的线程本地变量指的是：当前线程自身拥有的变量值。其他线程中可能存在相同性质的变量值，但是彼此存在线程隔离，互不共享，所以在多线程环境中，对变量值的操作不需要添加同步控制。

声明示例：

public class Test {
    private static ThreadLocal<Long> threadId = new ThreadLocal<>();
    //...
}

这里声明的方式较为简单，后续会提供ThreadLocal类的使用函数说明。

ThreadLocal 产生背景

原始代码

以id的查询和修改操作为例，若多线程环境中类成员的声明、使用为如下方式，则使用过程中可能存在访问结果不确定的情况：

public class Test {

    private Long id = 1L;

    public void updateId() {
        this.id = Thread.currentThread().getId();
    }

    public Long getId() {
        return this.id;
    }
}

当一个线程访问getId函数时，可能同时有另一个线程执行了updateId修改函数，所以查询到的id值存在不确定性。

这里对id的赋值使用的是Thread.currentThread().getId()，也就是赋予了线程id，此处只是为了表示该变量值与当前线程有关而已。

synchronized 修饰

为了保证当一个线程执行查询id操作的同时，不会有其他线程执行修改操作，这里可以使用synchronized关键字对查询和修改操作进行同步控制：

public class Test {

    private Long id = 1L;

    public synchronized void updateId() { 
        this.id = Thread.currentThread().getId();
    }

    public synchronized Long getId() {
        return this.id;
    }
}

在方法声明中增加synchronized关键字修饰，则线程需要先获取对象锁，然后才能执行同步方法内容。虽然该方式可以达到同步访问的目的，但是串行访问的代价较大。

这里使用Java内置的synchronized关键字来进行访问控制，只是为了举例说明同步的形式。由于该示例中的getId和updateId函数相当于读、写操作，所以也可以使用java.util.concurrent.locks包中提供的Lock、ReadWriteLock读写锁来实现读写控制。

ThreadLocal 线程本地变量

为了避免多线程场景下的串行访问现象，这里给每一个线程提供一个id对象，由于每个线程都有一个自己的id对象，所以查询、修改操作彼此不再相互影响：

public class Test {

    private ThreadLocal<Long> idLocal = new ThreadLocal<Long>();

    public void updateId() {
        idLocal.set(Thread.currentThread().getId());
    }

    public Long getId() {
        return idLocal.get();
    }
}

在代码中声明了一个idLocal成员，给每个线程分配一个自己单独id对象的功能，就是由该成员实现的；每个线程对自己id对象的查询和修改操作，也都是由该对象完成的。

从代码中可以发现一个很明显的现象，一直讲的id对象不见了，或者说它是被idLocal成员隐藏掉了。这是因为idLocal成员与id对象构成一个键值对，键为idLocal成员，值为id对象，所以代码中只需要保留一个idLocal键成员就可以了，对值的修改通过updateId函数中的idLocal.set()完成，对值的查询通过getId函数中的idLocal.get()完成。

因为idLocal成员与id对象构成了一个键值对，所以现在关注的重点不再是id对象，而是idLocal成员，因为得idLocal，即可通过idLocal.get()得id对象。因为idLocal是一个成员变量，用于指向一个ThreadLocal类型对象，下面分析该成员变量是怎么保存于每个线程中的。

ThreadLocal 实现原理

要实现每个线程中都保存一个自己的id对象，则需要实现每个线程中都保存一个<idLocal, id>键值对。首先看一下ThreadLocal的set函数是怎么在每个线程上保存<idLocal, id>键值对；然后看一下ThreadLocal的get函数是怎么从每个线程上获取<idLocal, id>键值对，继而获取键值id对象的。

后续引用的Java源码版本为jdk1.8.0_121

set 函数

ThreadLocal的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);
    }
    //...
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

由源码可知，set函数中，首先获取当前线程对象t，然后获取t对象的threadLocals属性，该属性的类型为ThreadLocalMap，维持的是一个键值对序列。当t对象的threadLocals属性不为空时，执行map.set(this, value)，键为this，即idLocal，键值为value，即id对象。

由ThreadLocal类中的set函数内容分析可知，每个线程对象通过自身的threadLocals成员，维持一个键值对序列，前面提到的<idLocal, id>键值对，则是保存在该threadLocals成员中的一个键值对。由此可知，在每个线程上保存<idLocal, id>键值对，是通过获取每个线程的threadLocals成员属性来实现的。

ThreadLocalMap 类型

线程对象的成员属性threadLocals，其声明方式为：

public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
    //...
}

ThreadLocalMap是ThreadLocal类中的一个静态内部类，其键值对类型定义为：

public class ThreadLocal<T> {
    //...
    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;
            }
        }
        private static final int INITIAL_CAPACITY = 16;
        private Entry[] table;
        //...
    }
}

由ThreadLocalMap定义可知，其内部维持的是一个Entry数组，Entry是一个键值对类型，键的类型为ThreadLocal，键值的类型为Object。

由定义可知，Entry对键类型ThreadLocal保持的是弱引用，当测试类对象test消除或者线程终止后，即除了Entry之外，不存在其他对ThreadLocal对象的引用，当执行垃圾回收时，会回收该ThreadLocal对象。

get 函数

ThreadLocal的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();
    }

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

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

    protected T initialValue() {
        return null;
    }

要获得每个线程上保存的<idLocal, id>键值对，get方法内首先获得当前线程对象t，继而获得线程对象的threadLocals成员属性，即这里的ThreadLocalMap类型变量map，然后根据idLocal获得map上的<idLocal, id>键值对，最后获取键值id对象。

在get方法中有两种情况下可能会调用setInitialValue()方法设置初始值：

• 一是线程对象t的threadLocals成员属性为空时，即当前线程对象上并没有保存任何键值对，此时会初始化threadLocals成员属性，并赋予初始键值对<idLocal, null>；

• 另一种情况是线程对象t的threadLocals成员属性不为空，但是并不存在idLocal对应的键值对，此时会赋予默认键值对<idLocal, null>。

由get方法的分析可知，在查询idLocal对应的键值之前，若没有执行set函数进行设置，则默认会创建并返回null值，所以推荐ThreadLocal的使用方式为重写initialValue函数，设定初始值：

public class Test {
    private ThreadLocal<Long> idLocal_one = new ThreadLocal<Long>();

    private ThreadLocal<Long> idLocal_two = new ThreadLocal<Long>() {
        protected Long initialValue() {
            return Thread.currentThread().getId();
        }
    };

    public static void main(String[] args) {
        Test test = new Test();
        System.out.println("main thread idLocal_one get: " + test.idLocal_one.get());  
        System.out.println("main thread idLocal_two get: " + test.idLocal_two.get());   
    }
}

输出结果为：

main thread idLocal_one get: null
main thread idLocal_two get: 1

由示例可知，idLocal_one没有设置初始值，所以直接查询其对应的键值为null，idLocal_two设置了初始值，所以直接查询其对应的键值不为null。

ThreadLocal 使用注意

由前面的分析可知，要想在每个线程中保存仅供自身使用的对象id_1、id_2...，可以声明使用ThreadLocal类型对象idLocal_1、idLocal_2...，构成<idLocal, id>键值对，保存于每个线程对象的threadLocals成员中，通过idLocal对象的get方法即可查询对应的id对象。

对于如下的使用场景：

public class Test {
    private ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
        protected Long initialValue() {
            return Thread.currentThread().getId();
        }
    };

    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        System.out.println("main thread idLocal: " + test.idLocal);
        System.out.println("main thread idLocal get: " + test.idLocal.get());

        new Thread() {
            public void run() {
                System.out.println("sub thread idLocal: " + test.idLocal);
                System.out.println("sub thread idLocal get: " + test.idLocal.get());
            }
        }.start();
        
    }
}

代码中存在两个线程，主线程和子线程，输出结果为：

main thread idLocal: Test$1@1540e19d
main thread idLocal get: 1
sub thread idLocal: Test$1@1540e19d
sub thread idLocal get: 11

由结果可知主线程和子线程引用的是同一个idLocal对象，因为Test类中声明的idLocal变量是可更改的，所以这里存在一个潜在的问题：如果多个线程中使用的是同一个idLocal变量，其中某一个线程更改了该变量的引用对象，则会导致其他所有线程查询不到之前设置的键值对。

情况一：

public class Test {
    private ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
        protected Long initialValue() {
            return Thread.currentThread().getId();
        }
    };

    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();

        test.idLocal.set(123L);
        System.out.println("main thread idLocal get: " + test.idLocal.get());

        Thread subThread = new Thread() {
            public void run() {
                test.idLocal = new ThreadLocal<Long>() {
                    protected Long initialValue() {
                        return 456L;
                    }
                };
            }
        };
        subThread.start();
        subThread.join();

        System.out.println("main thread idLocal get: " + test.idLocal.get());
    }
}

输出结果为：

main thread idLocal get: 123
main thread idLocal get: 456

主线程和子线程共用一个test对象，在子线程中更新了idLocal的引用对象，导致主线程丢失根据之前idLocal设置的键值。

情况二：

public class Test {
    private static ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
        protected Long initialValue() {
            return Thread.currentThread().getId();
        }
    };

    public static void main(String[] args) throws InterruptedException {
        Test one = new Test();
        one.idLocal.set(123L);
        System.out.println("main thread idLocal get: " + one.idLocal.get());

        Thread subThread = new Thread() {
            public void run() {
                Test two = new Test();
                two.idLocal = new ThreadLocal<Long>() {
                    protected Long initialValue() {
                        return 456L;
                    }
                };
            }
        };
        subThread.start();
        subThread.join();

        System.out.println("main thread idLocal get: " + one.idLocal.get());
    }
}

输出结果为：

main thread idLocal get: 123
main thread idLocal get: 456

因为idLocal声明为静态变量，所以多个Test实例对象共享该变量，一个线程中的实例更改了该变量引用的对象，则其他线程会丢失根据该变量设置的键值。

所以推荐以final修饰ThreadLocal类型成员，使用方式为：

public class Test {

    private final static ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
        protected Long initialValue() {
            return Thread.currentThread().getId();
        }
    };

    public void set(Long value) {
        idLocal.set(value);
    }

    public Long get() {
        return idLocal.get();
    }
    //...
}

参考

When and how to use a ThreadLocal
How is ThreadLocal implemented?