类ThreadLocal的使用与源码分析

Posted qlqwjy

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了类ThreadLocal的使用与源码分析相关的知识,希望对你有一定的参考价值。

  变量值的共享可以使用public static的形式,所有的线程都使用同一个变量。如果每个线程都有自己的共享变量,就可以使用ThreadLocal。比如Hibernat的session问题就是存在ThreadLoca中。

  类ThreadLocal主要解决的就是每个线程绑定自己的值,可以将ThreadLocal比喻成存放数据的盒子,盒子中可以存储每个线程的私有数据。

  而且ThreadLocal一般用作静态成员变量封装在工具类中实现线程隔离数据。在JavaEE结构中就是从Action层到Dao层可以使用threadLocal实现共享数据,并且线程之间相互隔离。(对于ThreadLocal,每个线程存进去的东西与取出来的是一致的,不会出现相互覆盖的现象。)

1. 方法 get()与null

   ThreadLocal的基本使用方法。

package cn.qlq.thread.ten;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * ThreadLocal的基本使用
 * 
 * @author QiaoLiQiang
 * @time 2018年12月15日下午9:00:19
 */
public class Demo1 {
    public static ThreadLocal<String> t1 = new ThreadLocal<String>();
    private static final Logger LOGGER = LoggerFactory.getLogger(Demo1.class);

    public static void main(String[] args) {
        if (t1.get() == null) {
            LOGGER.info("从未放过值");
            t1.set("存放的值");
        }
        LOGGER.info("{}", t1.get());
        LOGGER.info("{}", t1.get());
    }
}

 

结果:

21:02:38 [cn.qlq.thread.ten.Demo1]-[INFO] 从未放过值
21:02:38 [cn.qlq.thread.ten.Demo1]-[INFO] 存放的值
21:02:38 [cn.qlq.thread.ten.Demo1]-[INFO] 存放的值

 

  从第一个的返回结果看,第一次调用t1对象的get()方法时返回的值是null,通过set()赋值之后可以取出值。类ThreadLocal解决的是变量在不同线程间的隔离性,也就是每个线程拥有自己的值,不同线程中的值是可以放入ThreadLocal类中进行保存的。

  

2.验证变量间的隔离性

  验证其隔离性,每个线程在变量间存放的值不同。

package cn.qlq.thread.ten;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * ThreadLocal的基本使用
 * 
 * @author QiaoLiQiang
 * @time 2018年12月15日下午9:00:19
 */
public class Demo2 {
    public static ThreadLocal<String> t1 = new ThreadLocal<String>();
    private static final Logger LOGGER = LoggerFactory.getLogger(Demo2.class);

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if (t1.get() == null) {
                    LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName());
                    t1.set("存放的值" + Thread.currentThread().getName());
                }
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
            }
        }, "thread1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                if (t1.get() == null) {
                    LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName());
                    t1.set("存放的值" + Thread.currentThread().getName());
                }
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
            }
        }, "thread2").start();
    }
}

 

结果: (由结果可以看出每个线程存放了不同的值,但是在获取值的时候,每个线程又获取到了不同的值。)

21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] 从未放过值,threadName->thread2
21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] 从未放过值,threadName->thread1
21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] threadName - >thread2,值->存放的值thread2
21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] threadName - >thread1,值->存放的值thread1

 

3.解决get()返回null问题

   为了解决返回为null的问题,也就是在get()的时候直接就返回默认值,采用继承ThreadLocal并且重写initialValue的方式实现。(初始值的时候也可以实现线程的隔离线)

package cn.qlq.thread.ten;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 解决get()返回null的问题
 * 
 * @author QiaoLiQiang
 * @time 2018年12月15日下午9:16:17
 */
public class Demo3<T> extends ThreadLocal<String> {
    public static Demo3<String> t1 = new Demo3<String>();
    private static final Logger LOGGER = LoggerFactory.getLogger(Demo3.class);

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if (t1.get() == null) {
                    LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName());
                    t1.set("存放的值" + Thread.currentThread().getName());
                }
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
            }
        }, "thread1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                if (t1.get() == null) {
                    LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName());
                    t1.set("存放的值" + Thread.currentThread().getName());
                }
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
            }
        }, "thread2").start();
    }

    @Override
    protected String initialValue() {
        return "这是初始值" + Thread.currentThread().getName();
    }
}

 

 

结果:

21:23:54 [cn.qlq.thread.ten.Demo3]-[INFO] threadName - >thread2,值->这是初始值thread2
21:23:54 [cn.qlq.thread.ten.Demo3]-[INFO] threadName - >thread1,值->这是初始值thread1

 

4. ThreadLocal中存入多个对象

   有时候我们在ThreadLocal 中希望共享多个变量。

  最简单的一种办法创建一个ThreadLocal就是将所有共享的数据存入一个Map,将Map存入ThreadLocal,另一种办法就是所有共享数据放入一个bean中将bean存入ThreadLocal。

  另一种办法就是每个创建多个ThreadLocal分别存放多种共享的数据。

如下一个ThreadLocal存入Map中实现共享多个数据

package cn.qlq.thread.ten;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SuppressWarnings("all")
public class Demo7 {
    public static ThreadLocal t1 = new ThreadLocal();

    private static final Logger LOGGER = LoggerFactory.getLogger(Demo7.class);

    public static void main(String[] args) throws InterruptedException {
        Map data = new HashMap();
        data.put("str", "111222");
        data.put("int", 11122);
        data.put("obj", new Object());
        t1.set(data);
        Object object = t1.get();
        System.out.println(object);
    }
}

 

结果:

{str=111222, int=11122, obj=java.lang.Object[email protected]}

 

或者多个ThreadLocal共享多个数据

package cn.qlq.thread.ten;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SuppressWarnings("all")
public class Demo7 {
    public static ThreadLocal t1 = new ThreadLocal();
    public static ThreadLocal<String> t2 = new ThreadLocal<String>();

    private static final Logger LOGGER = LoggerFactory.getLogger(Demo7.class);

    public static void main(String[] args) throws InterruptedException {
        Map data = new HashMap();
        data.put("str", "111222");
        data.put("int", 11122);
        data.put("obj", new Object());
        t1.set(data);

        t2.set("t2");

        System.out.println(t1.get());
        System.out.println(t2.get());
    }
}

 

结果:

{str=111222, int=11122, [email protected]}
t2

 

 5. 类InheritableThreadLocal的使用

5.1值继承

   使用InheritableThreadLocal可以在子线程从父线程中继承值。主线程存入值,在子线程中获取。

package cn.qlq.thread.ten;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 主线程中设置值,子线程中获取值
 * 
 * @author QiaoLiQiang
 * @time 2018年12月15日下午9:29:40
 * @param <T>
 */
public class Demo4<T> extends InheritableThreadLocal<String> {
    public static Demo4<String> t1 = new Demo4<String>();
    private static final Logger LOGGER = LoggerFactory.getLogger(Demo4.class);

    public static void main(String[] args) {
        // 主线程中存入值
        t1.set("存放的值" + Thread.currentThread().getName());

        new Thread(new Runnable() {
            @Override
            public void run() {
                if (t1.get() == null) {
                    LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName());
                    t1.set("存放的值" + Thread.currentThread().getName());
                }
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
            }
        }, "thread1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                if (t1.get() == null) {
                    LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName());
                    t1.set("存放的值" + Thread.currentThread().getName());
                }
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
            }
        }, "thread2").start();
    }
}

 

 结果:

21:29:02 [cn.qlq.thread.ten.Demo4]-[INFO] threadName - >thread2,值->存放的值main
21:29:02 [cn.qlq.thread.ten.Demo4]-[INFO] threadName - >thread1,值->存放的值main

 

测试在子线程中再次创建子线程。(值会一直继承下去,对自己的子线程创建的子线程也有效

package cn.qlq.thread.ten;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 主线程中设置值,子线程中获取值
 * 
 * @author QiaoLiQiang
 * @time 2018年12月15日下午9:29:40
 * @param <T>
 */
public class Demo5<T> extends InheritableThreadLocal<String> {
    public static Demo5<String> t1 = new Demo5<String>();
    private static final Logger LOGGER = LoggerFactory.getLogger(Demo5.class);

    public static void main(String[] args) {
        // 主线程中存入值
        t1.set("存放的值" + Thread.currentThread().getName());

        // 创建子线程获取值
        new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());

                // 创建子子线程获取值
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
                    }
                }, "thread2").start();
            }
        }, "thread1").start();
    }
}

 

结果:

21:32:34 [cn.qlq.thread.ten.Demo5]-[INFO] threadName - >thread1,值->存放的值main
21:32:34 [cn.qlq.thread.ten.Demo5]-[INFO] threadName - >thread2,值->存放的值main

 

5.2 值继承再修改

  值也可以被继承再修改。

package cn.qlq.thread.ten;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 继承再修改值
 * 
 * @author QiaoLiQiang
 * @time 2018年12月15日下午9:34:41
 * @param <T>
 */
public class Demo6<T> extends InheritableThreadLocal<String> {
    public static Demo6<String> t1 = new Demo6<String>();
    private static final Logger LOGGER = LoggerFactory.getLogger(Demo6.class);

    public static void main(String[] args) throws InterruptedException {
        // 主线程中存入值
        t1.set("存放的值" + Thread.currentThread().getName());
        LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());

        // 创建子线程获取值
        new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());

                // 主线程中存入值
                t1.set("存放的值" + Thread.currentThread().getName());
                LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());

                // 创建子子线程获取值
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
                    }
                }, "thread2").start();
            }
        }, "thread1").start();

        Thread.sleep(2 * 1000);
        LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get());
    }
}

 

结果:(主线程中存入值,在子线程修改了值,main线程取到的值还是main中存入的值,子线程以及子子线程获得的值是子线程修改的值。)

21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >main,值->存放的值main
21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >thread1,值->存放的值main
21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >thread1,值->存放的值thread1
21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >thread2,值->存放的值thread1
21:36:28 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >main,值->存放的值main

 

6.ThreadLocal 源码解析

  ThreadLocal其实比较简单,因为类里就三个public方法:set(T value)、get()、remove()。

三个理论基础:

1、每个线程都有一个自己的ThreadLocal.ThreadLocalMap对象 (ThreadLocalMap 是ThreadLocal的静态内部类,一个类似于Map结构的普通类,没有实现Map接口,也是内部维护一个静态内部类Entry存放数据,而且其内部的Entry继承 WeakReference弱引用(被若引用关联的对象只能生存到下一次垃圾回收之前。其内部的key是Threadlocal,value就是存入的值)。)

Thread.class中的一个成员属性:

    ThreadLocal.ThreadLocalMap threadLocals = null;

2、每一个ThreadLocal对象都有一个循环计数器
3、ThreadLocal.get()取值,就是根据当前的线程,获取线程中自己的ThreadLocal.ThreadLocalMap,然后在这个Map中根据第二点中循环计数器取得一个特定value值

 

6.1 set(T value)源码解读

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

 

   可以看出是先获取到当前线程,然后根据当前线程去获取  ThreadLocalMap ,如果 获取到的ThreadLocalMap不为空的话就直接set值,否则走  createMap方法创建map。

 

(1)getmap(t)从线程中获取   ThreadLocalMap    (上面说过了每个Thread都有都有一个自己的ThreadLocal.ThreadLocalMap对象)

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

 

 

(2)map.set(this,value)设置值

        /**
         * Set the value associated with key.
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal key, Object value) {

            // We don‘t use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

 

    private final int threadLocalHashCode = nextHashCode();

    /**
     * The next hash code to be given out. Updated atomically. Starts at
     * zero.
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

  这个Map存储的方式不是链表法而是开地址法。看到设置table中的位置的时候,都把一个static的nextHashCode累加一下,这意味着,set的同一个value,可能在每个ThreadLocal.ThreadLocalMap中的table中的位置都不一样。

 

  1. 先对ThreadLocal里面的threadLocalHashCode取模获取到一个table中的位置
  2. 这个位置上如果有数据,获取这个位置上的ThreadLocal

  (1)判断一下位置上的ThreadLocal和我本身这个ThreadLocal是不是一个ThreadLocal,是的话数据就覆盖,返回

  (2)不是同一个ThreadLocal,再判断一下位置上的ThreadLocal是是不是空的,这个解释一下。Entry是ThreadLocalMap的一个静态内部类,并且是弱引用,"static class Entry extends WeakReference<ThreadLocal>",有可能这个 Entry 被垃圾回收了,这时候把新设置的value替换到当前位置上,返回

  (3)上面都没有返回,给模加1,看看模加1后的table位置上是不是空的,是空的再加1,判断位置上是不是空的...一直到找到一个table上的位置不是空的为止,往这里面塞一个value。换句话说,当table的位置上有数据的时候,ThreadLocal采取的是办法是找最近的一个空的位置设置数据

        3.这个位置上如果没有数据,就创建一个Entry到这个位置。

 

(3)   createMap(thread,value)方法查看:

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

 

创建一个ThreadLocalMap并且将引用传递给线程对象的 threadLocals 。

ThreadLocalMap创建的时候做了一些初始化工作,并且将值设置进去。

 

6.2  get()源码解读

get()方法的源码如下:

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

 

 

获取到当前线程-》获取到当前线程里面的ThreadLocalMap -》

                      如果ThreadLocalMap 为不为null,获取其内部的Entry对象-》获取entry的value(根据ThreadLocal 获取一个下标,然后获取对应下标的entry的信息)

        private Entry getEntry(ThreadLocal key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

 

 

                      如果ThreadLocalMap 为null,做默认设置并且返回默认值(这也是我们在上面的例子中继承ThreadLocal重写initialValue方法可以设置默认值的原因)

    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;
    }
    protected T initialValue() {
        return null;
    }

 

 

6.3  remove()源码解读

remove()源码如下:

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
        private void remove(ThreadLocal key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

 

根据当前线程获取到ThreadLocalMap-》如果获取的ThreadLocalMap不为null,调用其remove(key)方法

remove(ThreadLocal)根据ThreadLocal 对象获取一个下标i,如果tab[i]不为null,即存在对应的entry,调用entry的clear方法

 

补充:clear方法是Reference类型一个方法:--其作用就是将referent置为null,垃圾回收就可以回收此对象。

    public void clear() {
        this.referent = null;
    }

 

以上是关于类ThreadLocal的使用与源码分析的主要内容,如果未能解决你的问题,请参考以下文章

ThreadLocal源码小试

ThreadLocal源码分析理解弱引用和内存泄漏

ThreadLocal 源码分析

ThreadLocal源码及相关问题分析

ThreadLocal源码分析理解弱引用和内存泄漏

ThreadLocal源码分析理解弱引用和内存泄漏