Java基础-并发编程-ThreadLocal使用与原理分析

Java工程师知识树 / Java基础

---

java.lang.ThreadLocal

JDK针对ThreadLocal的描述

public class ThreadLocal 

这个类提供线程局部变量。 这些变量与其正常的对应方式不同，因为访问一个的每个线程（通过其get或set方法）都有自己独立初始化的变量副本。 ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态字段（例如，用户ID或事务ID）。

解读：ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。

ThreadLocal实现线程间的数据隔离原理:
每个线程对应的数据存储在不同的Thread对象的 threadLocals 属性中，而 threadLocals 属性是一个ThreadLocal.ThreadLocalMap 对象。
ThreadLocalMap为ThreadLocal的静态内部类。其实现是使用一个数组 private Entry[] table 来保存键值对的实体，初始大小为16，ThreadLocalMap自己实现了如何从 key 到 value 的映射：

int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

使用一个 static 的原子属性 AtomicInteger nextHashCode，通过每次增加 HASH_INCREMENT = 0x61c88647 ，然后 & (INITIAL_CAPACITY - 1)取得在数组 private Entry[] table中的索引。

总结:ThreadLoca为每个线程都会分配有一个新的变量对象,在使用时每个线程获取的对象都是不同的。

ThreadLocal的使用

ThreadLocal和Synchonized的区别和联系

ThreadLocal和Synchonized都用于解决多线程并发访问。

但是ThreadLocal与synchronized有本质的区别。

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

Synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问，用于在多个线程间通信时能够获得共享资源的同步数据。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

ThreadLocal的常见使用场景

当很多线程需要多次使用同一个对象，并且需要该对象具有相同初始化值的时候最适合使用ThreadLocal

比如：

1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。

2、线程间数据隔离

3、进行事务操作，用于存储线程事务信息。

4、数据库连接，Session会话管理。

注意事项：使用完ThreadLocal后，执行remove操作，避免出现内存溢出情况。

ThreadLocal源码分析

    //-------set---------    
    public void set(T value) {
        //(1)获取当前线程（调用者线程）
        Thread t = Thread.currentThread();
        //(2)以当前线程作为key值，去查找对应的线程变量，找到对应的map
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //(3)如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
            map.set(this, value);
        else
            //(4)如果map为null，说明首次添加，需要首先创建出对应的map
            createMap(t, value);
    }

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals; //获取线程自己的变量threadLocals，并绑定到当前调用线程的成员变量threadLocals上
    }

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

    //-------get---------

    public T get() {
        //(1)获取当前线程
        Thread t = Thread.currentThread();
        //(2)获取当前线程的threadLocals变量
        ThreadLocalMap map = getMap(t);
        //(3)如果threadLocals变量不为null，就可以在map中查找到本地变量的值
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //(4)执行到此处，threadLocals为null，调用该更改初始化当前线程的threadLocals变量
        return setInitialValue();
    }

    private T setInitialValue() {
        //protected T initialValue() {return null;}
        T value = initialValue();
        //获取当前线程
        Thread t = Thread.currentThread();
        //以当前线程作为key值，去查找对应的线程变量，找到对应的map
        ThreadLocalMap map = getMap(t);
        //如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
        if (map != null)
            map.set(this, value);
        else
            //如果map为null，说明首次添加，需要首先创建出对应的map
            createMap(t, value);
        return value;
    }

    //-------remove---------

    public void remove() {
        //获取当前线程绑定的threadLocals
         ThreadLocalMap m = getMap(Thread.currentThread());
         //如果map不为null，就移除当前线程中指定ThreadLocal实例的本地变量
         if (m != null)
             m.remove(this);
    }

    // 通过静态内部类实现变量与线程绑定
    static class ThreadLocalMap {...}

使用完ThreadLocal后，执行remove操作的原因：

每个线程的本地变量存放在自己的本地内存变量threadLocals中，如果当前线程一直不消亡，那么这些本地变量就会一直存在（所以可能会导致内存溢出），因此使用完毕需要将其remove掉。

应用实例

cn.hutool.db.ThreadLocalConnection

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package cn.hutool.db;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;

public enum ThreadLocalConnection {
    INSTANCE;

    private final ThreadLocal threadLocal = new ThreadLocal();//使用ThreadLocal保存Connection变量

    private ThreadLocalConnection() {
    }

    public Connection get(DataSource ds) throws SQLException {
        ThreadLocalConnection.GroupedConnection groupedConnection = (ThreadLocalConnection.GroupedConnection)this.threadLocal.get();
        if (null == groupedConnection) {//如果connThreadLocal没有本线程对应的Connection创建一个新的Connection，
            groupedConnection = new ThreadLocalConnection.GroupedConnection();
            this.threadLocal.set(groupedConnection);//并将其保存到线程本地变量中。
        }

        return groupedConnection.get(ds);//直接返回线程本地变量
    }
    //提供ThreadLocal的remove()方法，防止内存溢出
    public void close(DataSource ds) {
        ThreadLocalConnection.GroupedConnection groupedConnection = (ThreadLocalConnection.GroupedConnection)this.threadLocal.get();
        if (null != groupedConnection) {
            groupedConnection.close(ds);
            if (groupedConnection.isEmpty()) {
                this.threadLocal.remove();
            }
        }

    }

    public static class GroupedConnection {
        private final Map connMap = new HashMap(1, 1.0F);

        public GroupedConnection() {
        }

        public Connection get(DataSource ds) throws SQLException {
            Connection conn = (Connection)this.connMap.get(ds);
            if (null == conn || conn.isClosed()) {
                conn = ds.getConnection();
                this.connMap.put(ds, conn);
            }

            return conn;
        }

        public ThreadLocalConnection.GroupedConnection close(DataSource ds) {
            Connection conn = (Connection)this.connMap.get(ds);
            if (null != conn) {
                try {
                    if (!conn.getAutoCommit()) {
                        return this;
                    }
                } catch (SQLException var4) {
                }

                this.connMap.remove(ds);
                DbUtil.close(new Object[]{conn});
            }

            return this;
        }

        public boolean isEmpty() {
            return this.connMap.isEmpty();
        }
    }
}