理解Android之ThreadLocal

引言

我们知道在android上，主要利用了Handle实现了线程之间的消息通信。在Handle消息机制中有个很重要的类ThreadLocal，理解ThreadLocal有助于我们更深入的理解Handle通信机制。

android上的ThreadLocal跟java jdk上的实现方式有点不一样，但是它们的功能都是一致的，下面我会用android上的ThreadLocal跟大家进行分析。

ThreadLocal是什么？

要了解一个类，那必须先看它的类注释

Implements a thread-local storage, that is, a variable for which each thread has its own value. All threads share the same ThreadLocal object, but each sees a different value when accessing it, and changes made by one thread do not affect the other threads. The implementation supports null values.

根据上面的意思，简单的说ThreadLocal就是一个供线程保存数据的存储类，但是它可以使各个线程保存在同一个ThreadLocal对象里的数据互不干扰，一个线程修改ThreadLocal里的数据并不会影响其他线程所存储的数据。

感觉用文字描述好乏力啊，还是看看下面的小例子吧。

首先我们先实例化一个存储String类型数据的ThreadLocal

threadLocal = new ThreadLocal<>();" data-snippet-id="ext.01c88b9f32ec9492459099ba3124a095" data-snippet-saved="false" data-csrftoken="tFn0ygPU-6ZBgTScueLcUIr_6YUbnuCptdDg" data-codota-status="done">[code]ThreadLocal<String> threadLocal = new ThreadLocal<>();

然后再定义两个线程类

class MyThread1 extends Thread {
@Override
public void run() {
threadLocal.set("MyThread1 data");
Log.i(TAG, getName() + "  " + threadLocal.get());
}
}
class MyThread2 extends Thread {
@Override
public void run() {
Log.i(TAG, getName() + "  " + threadLocal.get());
threadLocal.set("MyThread2 data");
Log.i(TAG, getName() + "  " + threadLocal.get());
}
}

然后再启动这两个线程

new MyThread1().start();
Thread.sleep(1000);
new MyThread2().start();

输出结果如下



在上面的例子中两个线程都是使用同一个threadLocal实例，利用ThredLocal的set和get方法对数据进行存储和获取，在MyThread1中存入数据，在MyThread2并没有获取到，而只有在本线程进行存储的数据，才可以在本线程获取，其他线程无法获取，这保证了线程之间存储的数据不会互相干扰，这就是Threadlocal的神奇之处。

为什么ThreadLocal可以为根据不同的线程对数据进行区分呢？接下我们就要为分析下ThreadLocal到底是如何实现的。

ThreadLocal源码分析

ThreadLocal类里面包含了一个静态内部类Values，以及提供了几个公共的方法set、get、remove，我们根据这个几方法进行分析。

构造方法

public ThreadLocal() {}

没和初始化任何东西，很简单的一个无参构造方法。

set方法

set方法可以为当前线程保存一个变量到ThreadLocal中，且这个值可以为null。

ThreadLocal

public void set(T value) {
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values == null) {
values = initializeValues(currentThread);
}
values.put(this, value);
}

Values values(Thread current) {
return current.localValues;
}

Values initializeValues(Thread current) {
return current.localValues = new Values();
}

set方法中代码首先获取当前线程currentThread ,并传递给values方法，values方法返回了Thread类的一个成员变量localValues。

Thread

public class Thread implements Runnable {
//...
ThreadLocal.Values localValues;
//...
}

因为返回的localValues为null，所以我们对它进行实例化(initializeValues)，然后localValues(values)变量通过put方法把值进行存储。

通过上面简单的分析，我们知道每个线程都有一个ThreadLocal.Values类型的成员变量localValues，利用ThreadLocal的set方法进行存储，本质上是把该数据存储到本线程中的localValues变量上，这样就保证了不同线程存储的数据可以互不干扰，因为数据是保存在自己的线程变量中的。

ThreadLocal.Values

localValues类型是ThreadLocal.Values，那它到底是一个怎么样的类呢，我们继续往下探索。

ThreadLocal.Values

static class Values {

private static final int INITIAL_SIZE = 16;
private Object[] table;

private int mask;

private int size;

private int maximumLoad;
//...
Values() {
initializeTable(INITIAL_SIZE);
this.size = 0;
this.tombstones = 0;
}
private void initializeTable(int capacity) {
this.table = new Object[capacity * 2];
this.mask = table.length - 1;
this.clean = 0;
this.maximumLoad = capacity * 2 / 3; // 2/3
}
//...
}

Values是ThreadLocal的静态内部类，被设计用来保存线程变量的容器，它里面有个table数组，在构造方法会为该数组分配空间，而我们要存入的数据就是方在这个数组中的。

通过ThreadLocal的set的分析，知道set最终调用的是ThreadLocal.Values的put方法，如下：

ThreadLocal.Values#put

key, Object value) {
cleanUp();
// Keep track of first tombstone. That's where we want to go back
// and add an entry if necessary.
int firstTombstone = -1;
for (int index = key.hash & mask;; index = next(index)) {
Object k = table[index];
if (k == key.reference) {
// Replace existing entry.
table[index + 1] = value;
return;
}
if (k == null) {
if (firstTombstone == -1) {
// Fill in null slot.
table[index] = key.reference;
table[index + 1] = value;
size++;
return;
}
// Go back and replace first tombstone.
table[firstTombstone] = key.reference;
table[firstTombstone + 1] = value;
tombstones--;
size++;
return;
}
// Remember first tombstone.
if (firstTombstone == -1 && k == TOMBSTONE) {
firstTombstone = index;
}
}
}" data-snippet-id="ext.b8b9a373e5fb5994b85fe46d43825294" data-snippet-saved="false" data-csrftoken="T8h3uErk-LXmt-6PKX7smjtIZC_A8FZBsCK4" data-codota-status="done">[code]void put(ThreadLocal<?> key, Object value) {
cleanUp();
// Keep track of first tombstone. That's where we want to go back
// and add an entry if necessary.
int firstTombstone = -1;
for (int index = key.hash & mask;; index = next(index)) {
Object k = table[index];
if (k == key.reference) {
// Replace existing entry.
table[index + 1] = value;
return;
}
if (k == null) {
if (firstTombstone == -1) {
// Fill in null slot.
table[index] = key.reference;
table[index + 1] = value;
size++;
return;
}
// Go back and replace first tombstone.
table[firstTombstone] = key.reference;
table[firstTombstone + 1] = value;
tombstones--;
size++;
return;
}
// Remember first tombstone.
if (firstTombstone == -1 && k == TOMBSTONE) {
firstTombstone = index;
}
}
}

在上面的代码中通过该ThreadLocal对象的hash值来定位相应的的索引，如果该索引的值与key.reference是同一个对象，那么就把value放到table[index + 1]中。

key.referece到底是什么呢，见如下：

ThreadLocal#reference

{
//...
private final Reference> reference
= new WeakReference>(this);
//...
}" data-snippet-id="ext.f7af8c0e7f52677fc45b6f3bd2b36b25" data-snippet-saved="false" data-csrftoken="g3BZFz7j-PgVparvk3AjUlv4lRfzjYMnjJ0k" data-codota-status="done">[code]public class ThreadLocal<T> {
//...
private final Reference<ThreadLocal<T>> reference
= new WeakReference<ThreadLocal<T>>(this);
//...
}

referece其实是ThreadLocal对象本身的弱引用，使用弱引用可以保证ThreadLocal对象可以得到释放，而不会因table数组的持有导致无法释放资源。

继续put方法中的代码，如果table[index]返回的是null,那么我们就把key.reference和value都放入table数组中，这里的算法我不详细讲解，我们只要记住table数组不仅存储了我们要存入的变量，也存储了当前ThreadLocal的弱引用，如果弱引用存储的位置为 table[index]，那么变量存储的位置就为table[index + 1]。在这里我也可以知道，如果有个多个ThreadLocal实例在线程中存储数据，那么这些实例的弱引用和数据都会存储在此table数组中，并且这些数据不会相互干扰。

简单的探索完了ThreadLocal.Vaules类后，我们继续探索ThreadLocal.get方法

get方法

get方法可以获取当线程所存储的变量，如果没有则返回null,源码如下：

ThreadLocal#get

public T get() {
// Optimized for the fast path.
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values != null) {
Object[] table = values.table;
int index = hash & values.mask;
if (this.reference == table[index]) {
return (T) table[index + 1];
}
} else {
values = initializeValues(currentThread);
}
return (T) values.getAfterMiss(this);
}

上面的代码 首先去获取当前线程的localValues变量，如果localValues不为空，那么就根据hash值获取当前ThreadLocal对象的索引index，然后返回的table[index + 1]就是我们所存储的值，是不是跟上面分析put中存储的数据的下标index + 1一样？如果返回为null，那么我们实例化一个新的values值，然后执行values的getAfterMiss(this)方法。

Valuse#getAfterMiss

key) {
Object[] table = this.table;
int index = key.hash & mask;
// If the first slot is empty, the search is over.
if (table[index] == null) {
Object value = key.initialValue();
// If the table is still the same and the slot is still empty...
if (this.table == table && table[index] == null) {
table[index] = key.reference;
table[index + 1] = value;
size++;
cleanUp();
return value;
}
// The table changed during initialValue().
put(key, value);
return value;
}
//...
}" data-snippet-id="ext.4b7eebb4f02bff63f0d68d076e1d7a9b" data-snippet-saved="false" data-csrftoken="SfbWqJdX-7FsJQATWM_aIL6eYqMsfeZYpb4w" data-codota-status="done">[code]Object getAfterMiss(ThreadLocal<?> key) {
Object[] table = this.table;
int index = key.hash & mask;
// If the first slot is empty, the search is over.
if (table[index] == null) {
Object value = key.initialValue();
// If the table is still the same and the slot is still empty...
if (this.table == table && table[index] == null) {
table[index] = key.reference;
table[index + 1] = value;
size++;
cleanUp();
return value;
}
// The table changed during initialValue().
put(key, value);
return value;
}
//...
}

因为新实例化后的values 中table数组里面并没有数据，所以table[index]为null,然后把value值设置为initialValue()，见如下

ThreadLocal#initialValue

protected T initialValue() {
return null;
}

然后把当前的ThreadLocal弱引用和value(null)值，存入table数组中，并返回value(null)。这也验证了如果没有之前存储变量，get方法返回的默认值为null。

get方法与set方法是相对应的，通过上面的分析我们可以知道get方法其实获取的还是各自线程中的localValues变量中的值，每个线程对应的localValues内容不一样，获取的值当然会不一样。

remove方法

remove方法的作用其实就是移除存储的数据，把table数组中原本存储的数据置为null，具体是实现方法和上面的一致，我这里就不再进行分析了。

总结：

ThreadLocal 的set、get、remove方法都是针对当前线程的localValuse变量中的table数组进行操作的，因此保证了不同线程对一同个ThreadLocal实例进行数据操作的时候不会互相干扰。在Android中有个地方用到了ThreadLocal，那就是Looper，因为Looper的作用域就是线程，每个线程都有各自的Looper，所以系统把这些Looper都通过ThreadLocal进行存储，便于系统的管理和调度，省去了建立全局存储的麻烦。