【高并发程序设计】 ThreadLocal

上一篇【高并发程序设计】锁优化  探讨的是通过控制资源访问来保证线程安全。这一篇我们换个思路，通过增加资源来保证线程的安全： TreadLocal。

1. 简单使用

顾名思义， ThreadLocal是线程的局部变量， 被线程独享， 那么自然而然其是线程安全的。首先我们看一个简单的例子， 看一下下面的代码。 

public class ThreadLocalDemo {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static class ParseDate implements Runnable {

        private int i;

        public ParseDate(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                Date date = sdf.parse("2019-10-31 00:10:" + i % 60);
                System.out.println(i + ":" + date);
            } catch (ParseException e) {
                System.out.println(e.toString());
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 50000; i++) {
            executor.submit(new ParseDate(i));
        }
    }
}

上面这段代码在执行过程中很可能会得到一些异常(如NumberFormatException)， 其原因在于SimpleDateFormat类的parse方法并不是线程安全的， 因此多线程情况下共享这个对象是有问题的， 故可以使用ThreadLocal对其进行如下的改写。

public class ThreadLocalDemo {
    private static final ThreadLocal<SimpleDateFormat> tlSdf = new ThreadLocal<>();

    public static class ParseDate implements Runnable {

        private int i;

        public ParseDate(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                if (Objects.isNull(tlSdf.get())) {
                    tlSdf.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
                }

                Date date = tlSdf.get().parse("2019-10-31 00:10:" + i % 60);
                System.out.println(i + ":" + date);
            } catch (ParseException e) {
                System.out.println(e.toString());
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 50000; i++) {
            executor.submit(new ParseDate(i));
        }
    }
}

可以看到，为每个线程分配一个对象的工作并非由ThreadLocal来完成的， 而是需要应用测代码来保证。若应用测为ThreadLocal设置的是同一个对象， 那么依然无法保证线程安全，ThreadLocal仅仅起到了简单容器的作用。

2. 底层原理

本小节从源码入手来探讨ThreadLocal的底层实现。

先来看看set()方法的源码：

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

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

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

set()方法先获取到了当前线程， 然后调用getMap()方法获取当前线程的threadLocals对象(其是个ThreadLocalMap类型对象)，该map存在， 则将threadlocal对象和value分别做为key/value设置到map中； 不存在， 则new一个新ThreadLocalMap对象， 并将threadlocal对象和value作出初始值设置到map中。

再来看看get方法：

protected T initialValue() {
    return null;
}

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

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

get()方法依然是先从当前线程中获取ThreadLocalMap对象， 若map为null， 则对其进行初始化操作： 新创建一个map并赋值给当前线程， 并将当前threadLocal对象作为key， null作为value放入map， 并返回null；  若存在， 则使用当前theadLocal对象从map中获取Entry， 并将Entiry的value作为返回值return回去。 

由此上面的源码可见， 每个线程都维护着自己的ThreadLocalMap对象， 用以存储自己线程内使用到的相关对象(value)， 自己线程中的ThreadLocal， 别的线程是无法访问到的。 但若ThreadLocal中的对象是一个对象， 就没办法保证线程安全了。 另一个要注意点是， 若我们使用线程池来进行线程管理， 线程是不会被释放掉的， 这也就意味着ThreadLocal对象不会被释放掉， 那么若 其内部存储了大对象， 很有可能会引起内存泄漏。

 

下面我们来看看上文源码中一直提到的TreadLocalMap类， 可以将其理解为一个类似HashMap的容器， 我们来看看其内部处理， 其内部使用了一个Entry数组来存储ThreadLocal以及value：

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

private Entry[] table;

Entry类继承了WeakReference类， 其对于ThreadLocal的引用是个弱引用， 这就意味着， 当线程中存储的threadLocal对象失去了强引用时， 即便线程中仍然保留着其引用(实际上是弱引用)， 该ThreadLocal对象仍然可能会被回收， 如下图：

 

 

3. 实际应用--动态数据源/表的选择

数据库开发过程中， 经常会有分库分表的需求，常用方案无外乎以下几种:

1. 使用三方插件/服务(如当当的sharding-jdbc、阿里的mycat等)；

2. 借助spring.jdbc动态数据源以及mybatis拦截器纯手写实现， 此方法经常会用到ThreadLocal， 下文将详细介绍。 

spring.jdbc中的AbstractRoutingDataSource类提供了动态配置/使用数据源的方案， 其可设置的字段如下： 

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

	private Map<Object, Object> targetDataSources;

	private Object defaultTargetDataSource;

	private boolean lenientFallback = true;

	private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();

	private Map<Object, DataSource> resolvedDataSources;

	private DataSource resolvedDefaultDataSource;

 其中通过设置targetDataSources， 可以指定应用程序所连接的所有数据源， 并通过覆写determineCurrentLookupKey()方法， 由应用程序外部根据具体场景决定使用的数据源Key(前面写到targetDataSources中的key)， 从而动态确定数据源：

protected DataSource determineTargetDataSource() {
	Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
	Object lookupKey = determineCurrentLookupKey();
	DataSource dataSource = this.resolvedDataSources.get(lookupKey);
	if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
		dataSource = this.resolvedDefaultDataSource;
	}
	if (dataSource == null) {
		throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
	}
	return dataSource;
}

/**
 * Determine the current lookup key. This will typically be
 * implemented to check a thread-bound transaction context.
 * <p>Allows for arbitrary keys. The returned key needs
 * to match the stored lookup key type, as resolved by the
 * {@link #resolveSpecifiedLookupKey} method.
 */
protected abstract Object determineCurrentLookupKey();

下面的是继承AbstractRoutingDataSource来实现动态数据源的具体代码， 供参考：

public class DynamicDataSource extends AbstractRoutingDataSource {

    public static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    /**
     * 主从数据源的对应关系，注意：添加数据源必须在此配置对应主从关系
     */
    private static Map<String, String> masterSlaveDataSourceMap = Maps.newHashMap();

    static {
        //主从数据源的对应关系，注意：添加数据源必须在此配置对应主从关系
        masterSlaveDataSourceMap.put("dataSourceM0", "dataSourceS0");
        masterSlaveDataSourceMap.put("dataSourceM1", "dataSourceS1");
    }


    public static <T> T executeSurroundDs(String dataSourceName, boolean useMaster, DynamicDsCallback<T> callback) throws Throwable {

        // 判断上层是否没有设置数据源
        boolean isPreNotSetDataSource = isNotSetDataSource();
        try {

            // 如果上层没有设置数据源, 此处根据主从进行数据源的设置
            // 如果上层设置了数据源, 此处略过数据源的设置
            if (isPreNotSetDataSource) {
                if (useMaster) {
                    useMaster(dataSourceName);
                } else {
                    useSlave(dataSourceName);
                }
            }

            // 进行业务逻辑的执行后返回结果
            return callback.execute();
        } catch(Throwable th) {
            throw th;
        } finally {
            // 上层没有设置数据源, 退出时就需要清除数据源了.
            if (isPreNotSetDataSource) {
                clearUsed();
            }
        }
    }

    /**
     * 使用主数据库
     * @param masterDataSourceName 主数据库的数据源名称
     */
    private static void useMaster(String masterDataSourceName) {
        contextHolder.set(masterDataSourceName);
    }

    /**
     * 使用从数据库
     * @param masterDataSourceName 主数据库的数据源名称
     */
    private static void useSlave(String masterDataSourceName) {
        contextHolder.set(masterSlaveDataSourceMap.get(masterDataSourceName));
    }

    public static Object getContextHolderContent() {
        return contextHolder.get();
    }

    /**
     * 是否沒有set了dataSource
     * @return
     */
    private static boolean isNotSetDataSource() {
        return getContextHolderContent() == null;
    }

    /**
     * 清除数据源设置
     */
    private static void clearUsed() {
        contextHolder.set(null);
    }

    @Override
    protected Object determineCurrentLookupKey() {
        //从threadlocal中获取当前线程正在使用的数据源
        return contextHolder.get();
    }
}

若使用的是spring.mvc， 在配置文件中设置动态数据源：

<bean id="dataSource" class="com.guomingr.course.sharding.datasource.DynamicDataSource">
    <property name="targetDataSources">
        <map>
            <entry key="dataSourceM0" value-ref="dataSourceM0"/>
            <entry key="dataSourceS0" value-ref="dataSourceS0"/>
            <entry key="dataSourceM1" value-ref="dataSourceM1"/>
            <entry key="dataSourceS1" value-ref="dataSourceS1"/>
        </map>
    </property>
    <property name="defaultTargetDataSource" ref="dataSourceM0"/>
</bean>

应用程序的逻辑代码中， 根据不同情况不同需求， 来动态设置数据源名称。

---

参考：

《实战Java高并发程序设计》