Java多线程----很多人问的ThreadLocal实现原理和过程（源码分析）

最新推荐文章于 2022-07-02 00:26:39 发布

何义竏

最新推荐文章于 2022-07-02 00:26:39 发布

阅读量304

点赞数 7

分类专栏： Java进阶文章标签： java 多线程 spring 并发编程

本文链接：https://blog.csdn.net/weixin_44766232/article/details/118525763

版权

Java进阶专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Java线程—ThreadLocal 辨析

ThreadLocal 用法（如有错误，欢迎指正！）

ThreadLocal 用法（如有错误，欢迎指正！）

与Synchonized 的比较

ThreadLocal 和 Synchonized 共同点在于都能用于解决多线程并发访问，可是 ThreadLocal 与 synchronized 有本质的差别：

synchronized 是利用锁的机制，使变量或代码块在某一时该仅仅能被一个线程访问。
ThreadLocal 为每个线程都提供了变量的副本，使得每个线程在某一时间訪问到的并非同一个对象，这样就隔离了多个线程对数据的数据共享，保证了线程间的安全

ThreadLocal在Spring事务管理过程中运用较为常见：

public void serviceMethod(){
	Connecion conn = null;
	try{
		Connection conn = getConnetion();
		conn.setAutoCommit(false);
		Dao1 dao1 = new Dao1(conn);
		dao1.doSomething();
		Dao2 dao2 = new Dao2(conn);
		dao2.doSomething();
		Dao3 dao3 = new Dao3(conn);
		dao3.doSomething();
		conn.commit();
	}
}
Class Dao1{
	private Connection conn = null;
	public Dao1(Connection conn){
		this.conn = conn;
	}
	public void doSomething(){
		PrepareStatement pstmt = null;
		try{
			pstmst = conn.prepareStatement(sql);
			pstmt.execute...	
		}
	}
}

上面的代码中未使用 ThreadLoca，Spring主要解决的是如何让Spring的多个执行阶段中链接同一个数据来源，若是不能保证数据源相同，代码都无法正确运行

要让三个Dao都连接相同数据源，可以给他们都传一个相同的数据库连接：

所以Spring事务通过多线程绑定解决这个问题，因为Dao的每一个请求周期是通过线程来执行，即运用ThreadLocal将数据库中的connection作为独立的副本绑定到每一个线程中，线程自然也可以独立改变自己的副本，也不影响其他线程所对应的副本，可以理解为各线程专有的本地变量
因为不管程序开启事务还是执行具体的 sql 都需要一个具体的数据库连接。

ThreadLocal 思路：

public class HYQ{
	public static ThreadLocal<Integer> tlForInteger = new ThreadLocal<Integer>(){
		@Override
		protected Integer initialValue(){
			return 1;
		}
	};
	public static ThreadLocal<String> tlForString = new TreadLocal<String>(){
		@Override
		protected String initialValue(){
			return "i miss u";
		}
	};
	public static class Tsthread implements Runnable{
		@Override
		public void run() {
			tlForString.set("thread");
			System.out.println(threadLocalLong.get());
			System.out.println(threadLocalString.get());
			}
	}
	public static void main(String[] args){
		tlForInteger.set(100L);
		tlForString.set("test");
		
		//打包 Runnable 和start()的方法，这里就不写了
		//new Thread(new Runnable() {}).start();

		Tsthread XYDD = new Tsthread();
		Thread thread = new Thread(XYDD);
		thread.start();
		
		System.out.println(threadLocalLong.get());
		System.out.println(threadLocalString.get());

	}
}

具体实现：

import java.util.HashMap;
import java.util.Map;
 
public class TaiYuan {
	public static void main(String [] args){
		ResourceHolder.putResource("conn",new Conn("connection1"));
		new Thread(new Runnable() {
			@Override
			public void run() {
				// 该线程不会得到主线程绑定的变量
				System.out.println(ResourceHolder.getResource("conn"));
			}
		}).start();
		
		System.out.println(ResourceHolder.getResource("conn"));
		new TaiYuan().function1();
		new Taiyuan().function2();
		System.out.println(ResourceHolder.getResource("conn"));
	}
	public void function1(){
		System.out.println(ResourceHolder.getResource("conn"));
	}
	public void function2(){
		System.out.println(ResourceHolder.getResource("conn"));
	}
}
 
class ResourceHolder{
	
	public static ThreadLocal<Map<Object,Object>> 
		threadLocalMap=new ThreadLocal<Map<Object,Object>>();
	public static void putResource(Object key,Object value){
		if(threadLocalMap.get()==null)
			threadLocalMap.set(new HashMap<Object,Object>());
		threadLocalMap.get().put(key, value);
	}
	public static Object getResource(Object key){
		if(threadLocalMap.get()==null)
			threadLocalMap.set(new HashMap<Object,Object>());
		return threadLocalMap.get().get(key);
	}
	public static void clearResource(Object key,Object value){
		if(threadLocalMap.get()!=null)
			threadLocalMap.remove();
	}
}
class Conn{
	private String name;
	
	public Conn(String name) {
		super();
		this.name = name;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Conn [name=" + name + "]";
	}
}

ThreadLocal 实现

实现 ThreadLocal 类接口分别有四种方法：

void set(Object value)——设置当前线程的线程局部变量的值，意思就是你要吧那个变量当作副本。
public Object get()——该方法返回当前线程所对应的线程局部变量，用于变量发生改变。
public void remove()——将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是 JDK5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
protected Object initialValue()——返回该线程局部变量的初始值，该方法是一个 protected 的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第 1 次调用 get() 或 set(Object)时才执行，并且仅执行 1 次。ThreadLocal 中的缺省实现直接返回一个 null。

private static ThreadLocal <Integer/String> XYDD = new ThreadLocal <Integer/String> (){};
——XYDD 代表一个能够存放 Integer/String 类型的ThreadLocal 对象

上代码分析 ThreadLocal 的实现过程：

先定义一个静态 ThreadLocal 对象

//先初始化ThreadLocal，同时初始化Integer
private static THreadLocal<Integer> XYDD = new ThreadLocal<Integer>(){
	//重写初始化方法	
	@Override
	protected Integer initialValue(){
		//返回integer随便一个值
		Integer integer = 1;
		return integer;
	}
}

//ThreadLocal对象是可以定义多个的，并且是部疼痛类型的
//上面定义的integer类型的ThreadLocal，这里可以定义一个String的ThreadLocal
//且最终都会被保存在entry[]数组里面
private static ThreadLocal<String> stringThreadLocal;

创建一个方法用于开启多个线程用作测试

public void StartThreadArray(){
	//创建线程数组，用于下面遍历线程
	Thread[] xiaowang = new Thread[3];

	for(int i = 0; i < xiaowang.length; i++){
		//new一个自定义线程类的对象，传入自定义类里的局部变量的值
		TestThread WSQ = new TestThread(i+2);
		//创建线程，传入自定义线程类的对象
		Thread thread = new Thread(WSQ);
		//遍历把多线程赋值给线程数组
		xiaowang[i] = thread;
	}
	//通过遍历start每个线程
	for(int i = 0; i < xiaowang.length; i++){
		xiaowang[i].start();
	}
}

创建 Runnable 自定义线程类

/**
*创建测试线程，线程的工作是使 ThreadLocal 变量的的值发生变化，并重新写回
*测试线程之间是否会发生相互影响
*/
public static class TestThread implements Runnabble{
	int id = 0;
	public TestThread(int id){
		this.id = id;
	}
	public void run(){
		//搞清楚currentThread()的用处：
		//currentThread()源码解释：返回对当前正在执行的线程对象的引用
		//返回值：当前正在执行的线程
		//Thread.currentThread().getName():返回当前执行的线程的名字
		System.out.println(Thhread.currentThread().getName() + ":start");
		
		//get()方法：拿到threadLocal对象 XYDD的i值，i则为当前变量副本
		Integer q = XYDD.get();
		
		//更改 q 的值,要怎么把新的 q 设置为副本，
		//看下面的set()
		q = q + id;
		
		//set()的作用
		//@@@*****下面解释*****@@@@@
		XYYDD.set(q);

		System.out.println(Thread.currentThread().getName()+":"+XYDD.get());
	}
}

set() 的用处：

来看看源码的解释：将此线程局部变量的当前线程副本设置为指定值
放到这段代码块的意思就是：前面的get()方法已经拿到thresadLocal XYDD的初始化值，但是经过run()方法里的id，q的值变了，所以通过set()方法可以将新的 q 设置回去做新的副本
注意在这里怎么set()都是在该线程内部的entry[]搞定，不涉及其他线程和threadLocal

不管使set()还是get(),都是对自己独有的ThreadLocalMap进行操作的
也因为每个线程自己独有的ThreadLocalMap是别的线程访绝对问不到的
这就是为什么threadLocal能保证各线程之间的安全性

最后创建主线程

    public static void main(String[] args){
    	UseThreadLocal test = new UseThreadLocal();
        test.StartThreadArray();
    }

来看看运行结果：
在这里插入图片描述

思路都在注释里了，跟着走没问题的，下面注重对源码的分析

ThreadLocal 解析

直接来理解一下变量的副本到底是怎么创建的，最好的方法就是解析所执行的方法：

get()—返回当前线程所对应的线程局部变量

源码如下：

—get( )

    public T get() {
    
    	------1. 先拿到调用这个get()方法的当前线程
        Thread t = Thread.currentThread();

		------2. 再把当前线程 t 作为参数传给了 getmap()方法
		------3. 通过 getmap() 方法创建一个 map 对象！！ 看下面的getmap() 解释
		------4. 通过 getmap() 拿到每个线程自己独有的 ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        
        ------判空
        if (map != null) {
        
        	------5. 拿enty条目，通过取threadLocal键对应的value
            ThreadLocalMap.Entry e = map.getEntry(this);

            if (e != null) {
            ------6.返回值
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

要搞明白就要先搞明白getMap()方法到底是什么：

—getMap()

    ThreadLocalMap getMap(Thread t) {
    -----调用 getMap()返回当前线程里的threadLocals
        return t.threadLocals;
    }

可以看到调用 getMap()返回线程里的 threadLocals ，再继续看这个 threadLocals 是什么：

—threadLocals

    /* ThreadLocal values pertaining to this thread. This map is maintainedby the ThreadLocal class. 
    与此线程相关的本地值。此映射由ThreadLocal类维护
	 */
    ThreadLocal.ThreadLocalMap threadLocals = null;

threadLocals 是一个定义在 ThreadLocal 里面的 ThreadLocalMap

所以每一个线程都有一个自己的成员变量，而这个成员类型是ThreadLocalMap，搞不懂ThreadLocalMap 是什么，没关系！继续：

—ThreadLocalMap

    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 t he code that follows.
         */
         ------定义一个Enty------
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            
			//第一个参数是 key, 第二个参数是 value;
			//以threadLocal为键，以Object为Value
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        private static final int INITIAL_CAPACITY = 16;
        //Enty[] 被定义成了一个数组，因为传入的ThreadLocal可以是多个，一个线程拥有的ThreadLocal变量副本可能是多个
        private Entry[] table;
        private int size = 0;
        ...

Enty 为什么是个数组：

因为传入的ThreadLocal可以是多个，一个线程拥有的ThreadLocal变量副本可能是多个，数组初始化大小是16

而 ThreadLocalMap 表示每个线程自己会有一个 ThreadLocalMap，本质上还是一个Map，只不过每个这个 Map 中间对每个条目来说是以 ThreadLocal 为键盘，以传入的 Object 的值为Value。

set()—设置当前线程的线程局部变量的值

—set()

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

其实 set() 也是差不多的， currentThread() 拿到当前线程，getMap() 拿 threadLocals，threadLocals 又是个 threadLocalMap，也就是拿 Enty 条目
有点区别的就是 createMap()，看下面吧

—getMap()


    /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

return threadLocals，得到的threadLocals 与set() 相同

—createMap()


    /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

拿到当前线程的 threadLocals，是通过 new 一个 ThreadLocalMap 类的实例实现，传入第一个参数是 this 代表当前线程，第二个参数是 firstValue

—ThreadLocalMap()

这个方法啊，也就是ThreadLocalMap 类中的方法，该咋实现咋实现


        /**
         * Construct a new map initially containing (firstKey, firstValue).
         * ThreadLocalMaps are constructed lazily, so we only create
         * one when we have at least one entry to put in it.
         */
         -------还是 key Value 类型
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        
        	-------Enty[] 实例，大小16
            table = new Entry[INITIAL_CAPACITY];
			
			-------下面是判断ThreadLocal的副本有没重复，没有重复就返回
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

ThreadLocalMap 是 ThreadLocal 的静态内部类，每一个 Thread，都有一个自己的 ThreadLocalMap。
而ThreadLocalMap 里是一个 Entry 数组。

—threadLocalHashCode & nextHashCode

目的是 set() 中采用 nexHash，重复计算哈希值来判断ThreadLocal是否重复

private final int threadLocalHashCode = nextHashCode();

private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

—Entry类


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

Entry 是 ThreadLocalMap 的静态内部类，ThreadLocal 与副本对象，做成了 key-value 的形式。
它继承了 WeakReference，总之它记录了两个信息，一个是 ThreadLocal<?> 类型，一个是 Object 类型的值。反正 getEntry() 则是获取某个 ThreadLocal 对应的值， set() 就是更新或赋值相应的 ThreadLocal 对应的值。

总结：
在这里插入图片描述

先定义一个某个类型的ThreadLocal
比如有两个线程，一个小扬，一个小钊，当小扬过来的时候，就现在自己的内部声明一个 ThreadLocalMap，而 ThreadLocalMap 里面是有 Enty[ ] 的，数组里面又有多个条目，且每个条目以 key-value 形式存在
然后以 ThreadLocal 为键保存一个当前线程自己的value
当第二个线程来了后也一样的顺序
当定义了第二个类型的 ThreadLocal 也是一样可以保存在条目中

在这里插入图片描述
——谢谢你阿蒨

何义竏

关注

7
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
Java多线程----很多人问的ThreadLocal实现原理和过程（源码分析）

Java线程—ThreadLocal 辨析ThreadLocal 用法（如有错误，欢迎指正！）与Synchonized 的比较ThreadLocal 实现ThreadLocal 解析get()---返回当前线程所对应的线程局部变量---get( )---getMap()---threadLocals---ThreadLocalMapset()---设置当前线程的线程局部变量的值---set()---getMap()---createMap()---ThreadLocalMap()---threadLocal
复制链接

扫一扫