ThreadLocal

最新推荐文章于 2024-05-10 09:14:14 发布

Bitw-QwQ--猿究院

最新推荐文章于 2024-05-10 09:14:14 发布

阅读量122

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/q_qwp_p/article/details/132414873

版权

ThreadLocalMap如何查找数据？

前言

相信很多人都听过ThreadLocal，即使没用过也听过，但是要仔细一问ThreadLocal是个啥，也不一定能说清楚。

它是实现线程封闭的一种方式，那么什么是线程封闭？

把对象封闭在一个线程里，即使这个对象不是线程安全的，也不会出现并发安全问题。

实现线程封闭大致有三种方式：

Ad-hoc线程封闭：维护线程封闭性的职责完全由程序来承担，不推荐使用
栈封闭：就是用栈（stack）来保证线程安全

局部变量存储在虚拟机栈，虚拟机栈是线程隔离的，所以不会有线程安全问题

ThreadLocal线程封闭：简单易用

通过ThreadLocal来实现线程封闭，线程封闭的指导思想是封闭，而不是共享。所以说ThreadLocal是用来解决变量共享的并发安全问题，多少有些不精确。

概述

ThreadLocal被称为线程局部变量，用于在线程中保存数据。

由于在ThreadLocal中保存的数据仅属于当前线程，所以该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。

用于在同一个线程间，在不同的类和方法之间共享数据的的场景，也可以用于在不同线程间隔离数据的场景。

利用Thread中的ThreadLocalMap来进行数据存储。

使用：

例子：


public class Demo01 {
	
	public static ThreadLocal<String> role = new ThreadLocal<String>();

	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				role.set("AA");
				show();
				Sample.dosth();
			}
		},"11");
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				role.set("BB");
				show();
				Sample.dosth();
			}
		},"22");
		
		t1.start();
		t2.start();
		
		t1.join();
		t2.join();
		
	 
	}
	
	public static void show() {
		System.out.println("show:"+Thread.currentThread().getName());
	}
}
class Sample {
	//	线程1或线程2
	public static void dosth() {
		System.out.println("dosth:"+Thread.currentThread().getName());
	}
}

输出结果：

show:22
show:11
dosth:22
dosth:11

运行结果说明了ThreadLocal只能获取本线程设置的值，也就是线程封闭。基本上，ThreadLocal对外提供的方法只有三个set(T)、get()、remove()。

常用方法：

存储数据至当前线程的ThreadLocalMap：public void set(T value)

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取当前线程的
    ThreadLocalMapThreadLocalMap map = getMap(t);
    // 存储数据至当前线程的ThreadLocalMap中
    // 使用ThreadLocal对象做key，保存数据value
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

从当前线程的ThreadLocalMap中获取数据：public T get()

public T get() {
    // 获取当前线程的
    ThreadLocalMapThread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    // 使用ThreadLocal对象做key，获取数据(Entry类型)
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

从当前线程的ThreadLocalMap中删除数据：public void remove()

public void remove() {
    // 获取当前线程的
    ThreadLocalMapThreadLocalMap m = getMap(Thread.currentThread());
    // 使用当前ThreadLocal对象做key，删除数据
    if (m != null)
        m.remove(this);
}

ThreadLocalMap内部结构

ThreadLocalMap内部数据结构是一个Entry类型的数组。每个Entry对象的key为ThreadLocal对象，value为存储的数据。

public class ThreadLocal<T> {

    public T get() {
       ……
    }

    public void set(T value) {
        ……
    }

     public void remove() {
        ……
     }

    // 从这里可以看出ThreadLocalMap对象是被Thread类持有的
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    // 内部类ThreadLocalMap
    static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            // 内部类Entity，实际存储数据的地方
            // Entry的key是ThreadLocal对象，不是当前线程ID或者名称
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        // 注意这里维护的是Entry数组
        private Entry[] table;
    }
}

ThreadLocal在虚拟机内存中的大致结构

实线箭头表示强引用，虚线箭头表示弱引用

ThreadLocalMap虽然是在ThreadLocal类中定义的，但是实际上被Thread持有。
Entry的key是（虚引用的）ThreadLocal对象，而不是当前线程ID或者线程名称。
ThreadLocalMap中持有的是Entry数组，而不是Entry对象。

为什么用ThreadLocal做key？

如果在应用中，一个线程中只使用了一个ThreadLocal对象，那么使用Thread做key也是可以的，代表每个Thread线程对应一个value。

但是，在实际应用程序开发过程中，一个线程中很有可能不只使用了一个ThreadLocal对象。这时使用Thread做key就会产生混淆。

所以，不能使用Thread做key，而应该改成用ThreadLocal对象做key，这样才能通过具体ThreadLocal对象的get()方法，获取到当前线程的ThreadLocalMap，然后进一步获取到对应的Entry。

ThreadLocalMap如何查找数据？

当我们使用ThreadLocal获取当前线程中保存的Value数据时，是以ThreadLocal对象作为Key，通过访问Thread当前线程对象的内部ThreadLocalMap集合来获取到Value。
ThreadLocalMap集合的底层数据结构使用Entry[]数组保存Key-Value键值对数据。所以，当通过ThreadLocal的get、set()、remove()等方法，访问ThreadLocalMap时，最终都会通过一个下标，来完成对数组中的元素访问。

int i = key.threadLocalHashCode & (len-1);

通过key的“hashCode值”跟"数组的长度减1" 做“&按位与”运算。其中key就是ThreadLocal对象。这种计算方式，相当于用“hashCode值”跟“数组的长度”进行“%取余”运算。
假设：len=16，key.threadLocalHashCode=31
hash & len-1的计算结果与hash % len的计算结果一直，均为15，但是“&按位与”运算的效率更高。

父子线程如何共享数据?

在实际工作中，有可能需要在父子线程中共享数据的。即：在父线程中往ThreadLocal设置了值，在子线程中能够获取到。

在这种情况下使用ThreadLocal是行不通的。main方法是在主线程中执行的，相当于父线程。在main方法中开启了另外一个线程，相当于子线程。两个线程对象，各自拥有不同的ThreadLocalMap。应该使用InheritableThreadLocal，它是JDK自带的类，继承了ThreadLocal类。

public class ThreadLocalTest {



public static void main(String[] args) {
    InheritableThreadLocal<String> threadLocal = new InheritableThreadLocal<String>();

    threadLocal.set("12345");

    System.out.println("main主线程:"+threadLocal.get());

    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("子线程:"+threadLocal.get());
        }
    });
    thread.start();
    }
}

main:12345

thread:12345

ThreadLocal如何避免内存泄露？

使用完毕后，在finally调用ThreadLocal对象的remove()方法。

public class CurrentUser {
    private static final ThreadLocal<UserInfo> THREA_LOCAL = new ThreadLocal();
    public static void set(UserInfo userInfo) {
        THREA_LOCAL.set(userInfo);
    }

    public static UserInfo get() {
        THREA_LOCAL.get();
    }

    public static void remove() {
        THREA_LOCAL.remove();
    }

}

然后在业务代码中调用相关方法：

public void doSamething(UserDto userDto) {
    UserInfo userInfo = convert(userDto);
    try{CurrentUser.set(userInfo);
    ...
    //业务代码
    UserInfo userInfo = CurrentUser.get();
        ...
    } finally {
        CurrentUser.remove();
    }
}

需要特别注意的地方是：一定要在finally代码块中，调用remove()方法清理没用的数据。如果业务代码出现异常，也能及时清理没用的数据。
remove()方法中会把Entry中的key和value都设置成null，这样就能被GC及时回收，无需触发额外的清理机制，所以它能解决内存泄露问题。

应用场景

1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。
2、线程间数据隔离
3、进行事务操作，用于存储线程事务信息。
4、数据库连接，Session会话管理。

与synchronized的关系

有些文章拿ThreadLocal和synchronized比较，其实它们的实现思想不一样。

synchronized是同一时间最多只有一个线程执行，所以变量只需要存一份，算是一种时间换空间的思想
ThreadLocal是多个线程互不影响，所以每个线程存一份变量，算是一种空间换时间的思想

总结

ThreadLocal是一种隔离的思想，当一个变量需要进行线程隔离时，就可以考虑使用ThreadLocal来优雅的实现。

Bitw-QwQ--猿究院

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
ThreadLocal

相信很多人都听过ThreadLocal，即使没用过也听过，但是要仔细一问ThreadLocal是个啥，也不一定能说清楚。它是实现线程封闭的一种方式，那么什么是线程封闭？把对象封闭在一个线程里，即使这个对象不是线程安全的，也不会出现并发安全问题。Ad-hoc线程封闭：维护线程封闭性的职责完全由程序来承担，不推荐使用栈封闭：就是用栈（stack）来保证线程安全局部变量存储在虚拟机栈虚拟机栈是线程隔离的，所以不会有线程安全问题ThreadLocal线程封闭：简单易用。
复制链接

扫一扫