java并发--ThreadLocal

作者：opLW 记录平时所学内容

从源码理解ThreadLocal

目录

1.ThreadLocal概述
2.ThreadLocal源码理解
3.综合理解

1.ThreadLocal概述

• ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为ThreadLocalVariable更容易让人理解一些。负责为每个线程单独保存一份变量使访问不冲突。
• 在Java的多线程编程中，为保证多个线程对共享变量的安全访问，通常会使用synchronized来保证同一时刻只有一个线程对共享变量进行操作。这种情况下可以将类变量放到ThreadLocal类型的对象中，使变量在每个线程中都有独立拷贝，不会出现一个线程读取变量时而被另一个线程修改的现象。
• 下面配合图食用 ?
  
  

2.ThreadLocal源码理解

• 通过上述内容我们对ThreadLocal有了一个大概的了解，下面我们从源码理解Thread如何为每个线程单独备份。
• ThreadLocal的主要成员函数

public void set(T value) //设置当前线程对应的值
public T get() //获取当前线程对应的值
public void remove() //移除当前线程对应的值

• set方法源码

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread(); // 显然是用来获取当前线程的
        ThreadLocalMap map = getMap(t); // 1
        if (map != null)
            map.set(this, value); // 2
        else
            createMap(t, value); // 3
    }

(1) ThreadLocalMap 我们先理解这个是什么

由上图我们可以知道ThreadLocalMap是ThreadLocal的一个内部类，ThreadLocalMap中又有一个Entry类。下面是Entry类：

static class ThreadLocalMap {

       /**
        * The entries in this hash map extend WeakReference, using
        * its main ref field as the key (which is always a
        * ThreadLocal object).  Note that null keys (i.e. entry.get()
        * == null) mean that the key is no longer referenced, so the
        * entry can be expunged from table.  Such entries are referred to
        * as "stale entries" in the code that follows.
        */
       static class Entry extends WeakReference<ThreadLocal<?>> {
           /** The value associated with this ThreadLocal. */
           Object value;

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

由此可以大概的知道ThreadLocalMap类似HashMap，其内部有Entry用于保存键值对，其中键就是对应ThreadLocal<?>，值则对应我们的目标变量。

(2)getMap(t)

//ThreadLocal.java
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    } 
    
//我们进到t中看看这个变量是什么
//Thread.java
ThreadLocal.ThreadLocalMap threadLocals = null;

由此可见每个Thread都会持有一个ThreadLocal.ThreadLocalMap 用于保存这个线程的特有的备份。但是一开始这个threadLocals是null，所以也就有了下面的判空

if (map != null)
	map.set(this, value); // 2
else
    createMap(t, value); // 3

如果不为空则直接赋值，如果为空则调用createMap(t, value)

(3)createMap(t, value)

//ThreadLocal.java
void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue); //调用ThreadLocalMap的构造函数
}

//ThreadLocal.ThreadLocalMap.java
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY]; //初始化ThreadLocalMap内部的Entry数组
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); //1
            table[i] = new Entry(firstKey, firstValue); //进行赋值
            size = 1;
            setThreshold(INITIAL_CAPACITY);
}

注意上方的1代码行 该行代码对ThreadLocal进行hash，从而确定该类型对应的位置，一个Thread中可以保存着多种类型变量的备份而互不干扰，就是因为这行代码。比如ThreadLocal<A>进行hash之后对应的i为1，ThreadLocal<B>进行hash之后对应的i为2，从而区分放置。
至此，当前Thread持有的ThreadLocal.ThreadLocalMap就被初始化完成。下次调用public void set(T value) 时便可以直接使用。

• get方法源码

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //如果ThreadLocalMap已经存在则直接获取该值
            ThreadLocalMap.Entry e = map.getEntry(this);  
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果没有ThreadLocalMap为空或者对应的目标值不存在
        return setInitialValue();
    }

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

由上可知当创建一个ThreadLocal后马上调用它的get方法会调用setInitialValue，因为此时的线程对应的map还没有创建完成。setInitialValue的代码与上面已经分析过的set方法大同小异，唯一不同的是T value = initialValue();
下面我们看看这个方法：

protected T initialValue() {
        return null;
}

居然返回一个null?，这显然不合适会引起NullPointerException；想想也合乎情理：必须先有值，然后才可以调用get方法，不然肯定返回null，抛出异常。那么如何解决呢？

(1) 重写initialValue()方法 (A是一个类)。

ThreadLocal<A> t = new ThreadLocal<A>(){
        @Override
        protected A initialValue() {
            return new A();
        }
}

此时调用t的get方法，便会返回一个新的A，而不会发生异常。

(2) 先调用set方法，再调用get方法

ThreadLocal<A> t = new ThreadLocal<A>();
t.set(new A());
A a = t.get();

3.综合理解

经过上面的分析，相信大家对ThreadLocal都有一定的理解。下面举个例子具体理解一下。

public class A {
    private int num = 0;

    public A() { }

    @Override
    public String toString() {
        String msg = " " + num;
        num++;
        return msg;
    }
}

public class Client {
    public static void main(String[] args) {
        ThreadLocal<A> a = new ThreadLocal<A>(){
            @Override
            protected A initialValue() {
                return new A();
            }
        };
        ThreadLocal<B> b = new ThreadLocal<B>(){
            @Override
            protected B initialValue() {
                return new B();
            }
        };
        for (int i = 0 ; i < 2; i ++) {
            new Thread("" + i) {
                @Override
                public void run() {
                    System.out.println("我是线程：" + getName() + 
                    " 变量A：" + a.get().toString());
                    System.out.println("我是线程：" + getName() + 
                    " 变量B：" + b.get().toString());
                }
            }.start();
        }
        //验证再次调用会加1
        System.out.println("我是主线程" + " 变量A：" + a.get().toString());
        System.out.println("我是主线程" + " 变量A：" + a.get().toString()); 
    }
}
我是线程：1 变量A： 0
我是主线程 变量A： 0
我是线程：0 变量A： 0
我是主线程 变量A： 1
我是线程：0 变量B： 0
我是线程：1 变量B： 0

• 上述有A和B两个类。只贴出了A，B的代码一样，只是类的名字不一样，所以就不贴出来了。?
• 最底下是运行的结果。假设没有为每个线程单独备份，那么当第一个线程调用a.get().toString()，必然会引起A.num++，所以下次调用的输出会是1。从输出结果可见每个线程之间的变量是没有关系的，验证了ThreadLocal的作用。
• 下面根据图理解。
  
• 使用场景 如Handler机制中，为每个线程单独保存Looper单例，ThreadLocal很适合多线程的单例模式。

记录美好学习的点点滴滴,希望能和各位一起学习！?
好记性不如烂笔头！！
万水千山总是情，麻烦手下别留情。
如若讲得有不妥，文末留言告知我，
如若觉得还可以，收藏点赞要一起。
opLW原创七言律诗，转载请注明出处