关于ThreadLocal的理解

先上一个使用ThreadLocal实例的demo，ThreadLocalDemo 实例包含一个ThreadLocal实例。从网上各种信息看到ThreadLocal是线程私有变量。保持了每个变量的副本，其实ThreadLocal不能用于解决多线程共享变量问题。
ThreadLocal 中只是保存该线程自己创建的局部变量的副本。如果是多线程共享的变量还是会发生不能同步该的后果。下面这个例子就是启动两个线程，通过threadLocal实例的set方法将person实例加入到线程本地变量ThreadLocal.Values localValues;中。但是localValues这个变量底层实现十基于数组的一个map结构。对于引用变量缓存引用。所以在这个demo中两个线程的localValues变量都指向了同一个person实例。也就不是线程私有的变量。要达到线程私有的话只有在线程中通过创建的变量通过ThreadLocal的set方法插入的元素才是线程私有的变量。

public class ThreadLocalDemo {
    private static Person person;
    private static ThreadLocal<Person> threadLocal = new ThreadLocal<Person>();

    public ThreadLocalDemo( Person person ) {
        this.person = person;
    }

    public static void main( String[] args ) throws InterruptedException {
        // 多个线程使用同一个Person对象
        Person per = new Person(111, "Sone");
        ThreadLocalDemo test = new ThreadLocalDemo(per);
        Thread th1 = new Thread(new Runnable() {

            public void run() {
                // TODO Auto-generated method stub
                threadLocal.set(person);
                String threadName = Thread.currentThread().getName();
                Person perLocal = threadLocal.get();
                System.out.println(threadName + " before:" + threadLocal.get());
                perLocal.setId(888);
                perLocal.setName("Admin");
                System.out.println(threadName + " after:" + threadLocal.get());
            }
        }, "thread-th1");
        Thread th2 = new Thread(new Runnable() {

            public void run() {
                // TODO Auto-generated method stub
                threadLocal.set(person);
                System.out.println(Thread.currentThread().getName() + " :"
                        + threadLocal.get());
            }
        }, "thread-th2");
        th1.start();
        th1.join();
        Thread.sleep(100);
        th2.start();

        th2.join();
        // Person对象已经被线程给修改了！
        System.out.println("Person对象的值为：" + per);
    }


}

 class Person {

    private int id;
    private String name;

    public Person( int id , String name ) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId( int id ) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName( String name ) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + "]";
    }
}

输出：
可以看到虽然将person实例加入到两个线程本地变量ThreadLocal.Values localValues; 但是都是指向同一个实例person。所以从输出结果可以看到在th1线程更改了person后，在th2线程也可以获取到最新的结果。

thread-th1 before:Person [id=111, name=Sone]
thread-th1 after:Person [id=888, name=Admin]
thread-th2 :Person [id=888, name=Admin]
Person对象的值为：Person [id=888, name=Admin]

下面给出在线程里面new一个实例然后通过ThreadLocal类的set方法插入到当前线程的ThreadLocal.Values localValues;变量中 ，最后对当前线程的localValues变量中的本地变量通过ThreadLocal类的get()方法获取到当前线程threadLocal实例为key对于的值。

public class ThreadLocalDemo {
    private static Person person;
    private static ThreadLocal<Person> threadLocal = new ThreadLocal<Person>();
//定义一个ThreadLocal类实例，这个是插入线程本地变量的接口类，
//有get/set方法；ThreadLocal类其实只是封装了插入线程本地变量的操作接口，
//每个线程的线程本地变量ThreadLocal.Values localValues就是一个map存储
//结构，以ThreadLocal类实例为key，存储的数据为值。
//如果需要获取到这个本地变量，只需要在线程内部通过ThreadLocal类实例的get（）方法就可以获取到与ThreadLocal类实例对于的值。

    public ThreadLocalDemo( Person person ) {
        this.person = person;
    }

    public static void main( String[] args ) throws InterruptedException {
        // 多个线程使用同一个Person对象
        Person per = new Person(111, "Sone");
        ThreadLocalDemo test = new ThreadLocalDemo(per);
        Thread th1 = new Thread(new Runnable() {

            public void run() {
                // TODO Auto-generated method stub
                threadLocal.set(new Person(111, "Sone"));
                String threadName = Thread.currentThread().getName();
                Person perLocal = threadLocal.get();
                System.out.println(threadName + " before:" + threadLocal.get());
                perLocal.setId(9999);
                perLocal.setName("jim");
                System.out.println(threadName + " after:" + threadLocal.get());
            }
        }, "thread-th1");
        Thread th2 = new Thread(new Runnable() {

            public void run() {
                // TODO Auto-generated method stub
                threadLocal.set(new Person(112, "vincent"));
                String threadName = Thread.currentThread().getName();
                Person perLocal = threadLocal.get();
                System.out.println(threadName + " before:" + threadLocal.get());
                perLocal.setId(8);
                perLocal.setName("jack");
                System.out.println(threadName + " after:" + threadLocal.get());
            }
        }, "thread-th2");
        th1.start();
        th2.start();
        th1.join();
        th2.join();
        // Person对象已经被线程给修改了！
        System.out.println("Person对象的值为：" + per);
    }

    public void run() {

    }
}

 class Person {

    private int id;
    private String name;

    public Person( int id , String name ) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId( int id ) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName( String name ) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + "]";
    }
}

输出结果：
从输出结果可以看到我在各自线程创建一个person实例，然后插入到线程本地变量中（ThreadLocal.Values localValues; 是一个map结构的数据结构），每个线程有具有一个这样的实例；插入使用的是相同的ThreadLocal类实例为key，但是缓存的是不同person变量。

thread-th2 before:Person [id=112, name=vincent]
thread-th2 after:Person [id=8, name=jack]
thread-th1 before:Person [id=111, name=Sone]
thread-th1 after:Person [id=9999, name=jim]
Person对象的值为：Person [id=111, name=Sone]

最后说下看ThreadLocal类后对他的理解，首先ThreadLocal不是一个具体的线程。它是一个线程用于存取本地变量 ThreadLocal.Values localValues;的操作类，localValues是一个map类型的数据，key就是ThreadLocal，value就是插入的数据，在一个线程中可以插入不同ThreadLocal实例的数据，一个线程本地变量只能缓存特定ThreadLocal实例的一条数据。

在java中ThreadLocal以Map的形式存储数据（ThreadLocal对象为 key 数值为value）。在Android中做了些改动，在Thread-Local的add方法中，可以看到它会把ThradLocal对象（key）和相对应的value放在table数组连续的位置中。 也就是table被设计为下标为0,2,4…2n的位置存放key，而1,3,5…(2n +1 )的位置存放value。

先看下android的ThreadLocal类的源码，其中也就两个接口方法重要，get()和set(T data);

ThreadLocal数据插入流程

//set(T data)让线程插入一个key为当前ThreadLocal实例，value为value的键值对
   public void set(T value) {
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values == null) {
            values = initializeValues(currentThread);
        }
        values.put(this, value);
    }
//values(Thread current)这里就可以看到其实ThreadLocal类操纵的还是当前线程的本地变量。
Values values(Thread current) {
        return current.localValues;
    }
   //然后对values判定是否为空，如果为空那么初始化一个空的Values实例，
   //如下图就是初始化了一个空的Values类实例复制给了当前线程的
   //ThreadLocal.Values localValues属性字段;
   Values initializeValues(Thread current) {
        return current.localValues = new Values();
    }
Values() {
            initializeTable(INITIAL_SIZE);
            this.size = 0;
            this.tombstones = 0;
        }
        /**
         * Creates a new, empty table with the given capacity.
         */
        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实例的put方法完成了数据插入到map中，可以清晰看到key为ThreadLocal类实例，value就是set方法传进来的数据。

//下面是Values类的put方法处理逻辑，看到for循环时候，寻找插入位置时候先匹配到key，而key存放的位置比较特殊在数组下标的0 ，2， 4 ，6 ... 2n；这些位置，value存放位置在1,3，5，7...2n+1这些位置。


  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;
            //index是寻找key存放的下标， key.hash & mask寻找循环的起止位置，mask是table.length-1,默认是31，key.hash & mask计算后使得index一定指向key的下标。next（）方法是对index加2操作。
            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数据获取流程

//get获取数据
 public T get() {
        // Optimized for the fast path.
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);//获取到当前线程的本地变量map
        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数组ThreadLocal实例reference属性的下标。前文说过：ThradLocal对象（key）和相对应的value放在table数组连续的位置中。 也就是table被设计为下标为0,2,4…2n的位置存放key，而1,3,5…(2n +1 )的位置存放value。现在得到index后再index+1就是value在table数组中的下标。即value=table[index+1];return value即可。