Android 中ThreadLocal的深入理解

threadlocal

前言：

    threadlocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，threadlocal并不是一个thread，threadlocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其它线程来说无法获取到数据。设计初衷就是：提供线程内部的局部变量，在本线程内随时可取，而隔离了其他线程。

private static void prepare(boolean quitallowed) { 
  if (sthreadlocal.get() != null) { 
    throw new runtimeexception("only one looper may be created per thread"); 
  } 
  sthreadlocal.set(new looper(quitallowed)); 
} 

这段代码就是在初始化looper的时候会执行到的方法，这里也可以看出，一个looper只能对应一个thread。

public void set(t value) { 
  thread currentthread = thread.currentthread(); 
  values values = values(currentthread); 
  if (values == null) { 
    values = initializevalues(currentthread); 
  } 
  values.put(this, value); 
} 

looper创建时调用了threadlocal类中的set方法，这里，首先获取到当前的线程，然后，将线程通过values的方法得到当前线程的values，而values类是threadlocal中的一个嵌套类，用来存储不同thread的信息。

/** 
 * gets values instance for this thread and variable type. 
 */ 
values values(thread current) { 
  return current.localvalues; 
} 

在thread类中有这么一段：

/** 
  * normal thread local values. 
  */ 
  threadlocal.values localvalues; 

所以从上面我们了解到set方法把当前thread中的localvalues获取到，然后用得到的values将当前的this和传进来的looper进行put操作：

/** 
 * sets entry for given threadlocal to given value, creating an 
 * entry if necessary. 
 */ 
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; 
    } 
  } 
} 

这段代码的意思就是将传进来的looper对象保存在了values类中的table成员变量中，保存的下标是在[index+1]里，table是一个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); 
  } 

首先获取到当前线程，然后去取当前线程的values值，如果值不空，先拿table数组，再得到此values的下标，最后返回此下标对应的table[]值。所以threadlocal我自己的理解是：不同的线程拥有不同的values值，这个值统一在threadlocal类的table数组中，也就是说每个线程有自己的副本，在自己的副本里面读写信息互补干扰！

    时间过得好快，转眼一年了。整整快了一年没怎么写东西，说多了都是借口，没有及时整理和沉淀，今年间是有点想法把自己平日写的小demo总结下的，但总是忘记弄，后续得多鞭策下自己，写点东西相当于自己做个笔记，把知识框架化，不对的地方请大神们多多指教！

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！