Android多线程之ThreadLocal

ThreadLocal简介

ThreadLocal实现的是线程的数据的本地存储，同一个ThreadLocal对象在不同的线程中都有自己的值，所有的线程共享同一个ThreadLocal对象，但是每一个访问它的线程都存储这个线程自己的值，并且一个线程改变了这个ThreadLocal对象的值但是并不能改变其他线程中ThreadLocal的值。ThreadLocal允许赋值为null。

ThreadLocal的主要方法

ThreadLocal的主要方法有set()方法，顾名思义，是对ThreadLocal进行赋值，get()方法则是取出当前线程中ThreadLocal的值，记住每一个线程中取出的值只是当前线程中之前所赋值。我们可以看一下ThreadLocal中的源码：

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

上述源码中我们可以看到set()方法所存储的值存放在了Values中，这个values是什么呢？我们可以接着看下一段源码：

static class Values {
private static final int INITIAL_SIZE = 16;
private static final Object TOMBSTONE = new Object();
private Object[] table;

private int mask;

private int size;

private int tombstones;

private int maximumLoad;

private int clean;

Values() {
initializeTable(INITIAL_SIZE);
this.size = 0;
this.tombstones = 0;
}

Values(Values fromParent) {
this.table = fromParent.table.clone();
this.mask = fromParent.mask;
this.size = fromParent.size;
this.tombstones = fromParent.tombstones;
this.maximumLoad = fromParent.maximumLoad;
this.clean = fromParent.clean;
inheritValues(fromParent);
}

@SuppressWarnings({"unchecked"})
private void inheritValues(Values fromParent) {

Object[] table = this.table;
for (int i = table.length - 2; i >= 0; i -= 2) {
Object k = table[i];

if (k == null || k == TOMBSTONE) {

continue;
}
tombstones and references.
Reference<InheritableThreadLocal<?>> reference
= (Reference<InheritableThreadLocal<?>>) k;
Object below.
InheritableThreadLocal key = reference.get();
if (key != null) {

table[i + 1] = key.childValue(fromParent.table[i + 1]);
} else {
// The key was reclaimed.
table[i] = TOMBSTONE;
table[i + 1] = null;
fromParent.table[i] = TOMBSTONE;
fromParent.table[i + 1] = null;

tombstones++;
fromParent.tombstones++;

size--;
fromParent.size--;
}
}
}

我们可以看到这个values是个静态内部类，其中的inheritValues方法我们可以看到我们存储的值实际上都是存放在了Object数组里。而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);
}

源码中的描述很清晰，我们的值所在object数组中的索引实际就是index＋1。还有remove()方法，这里remove()方法就不做详加解释，相信大家看名字亦能理解。

ThreadLocal的一个实现示例

这里写一个小的例子，帮助大家理解一下ThreadLocal:

mFutureTest = new FutureTest();
mFutureTest.test();
mThreadLocal = new ThreadLocal<Integer>();
new Thread("thread_one"){
@Override
public void run() {
mThreadLocal.set(1);
Log.i("threadloacl","thread_one======"+mThreadLocal.get());
}
}.start();

new Thread("thread_two"){
@Override
public void run() {
mThreadLocal.set(2);
Log.i("threadloacl","thread_two======"+mThreadLocal.get());
}
}.start();
Log.i("threadlocal","mainthread="+mThreadLocal.get());

运行结果：

I/threadlocal: mainthread=null
I/threadloacl: thread_one======1
I/threadloacl: thread_two======2

这里在主线程中并没有赋值，所以主线程中的值为null。这就是关于ThreadLocal的我的浅显的理解，希望对看到这篇文章的人能有所增益，同时这也是方便我自己理解，加强记忆，如有纰漏之处还望指正！