Java ThreadLocal原理解析以及应用场景分析案例详解

目录
  • ThreadLocal的定义
  • ThreadLocal的应用场景
  • ThreadLocal的demo
  • TheadLocal的源码解析
    • ThreadLocal的set方法
    • ThreadLocal的get方法
    • ThreadLocalMap的结构
    • ThreadLocalMap的set方法
    • ThreadLocalMap的getEntry方法
  • ThreadLocal的内存泄露
  • 如何避免内存泄露呢
  • 应用实例
  • 实际应用二
  • 总结

ThreadLocal的定义

JDK对ThreadLocal的定义如下:
TheadLocal提供了线程内部的局部变量:每个线程都有自己的独立的副本;ThreadLocal实例通常是类中的private static字段,该类一般与线程状态相关(或线程上下文)中使用。只要线程处于活动状态且ThreadLocal实例时可访问的状态下,每个线程都持有对其线程局部变量的副本的隐式引用,在线程消亡后,ThreadLocal实例的所有副本都将进行垃圾回收。

ThreadLocal的应用场景

ThreadLocal 不是用来解决多线程访问共享变量的问题,所以不能替换掉同步方法。一般而言,ThreadLocal的最佳应用场景是:按照线程多实例(每个线程对应一个实例)的对象的访问。
例如:在事务中,connection绑定到当前线程来保证这个线程中的数据库操作用的是同一个connection。

ThreadLocal的demo

public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        threadLocal.set("张三");

        new Thread(()->{
            threadLocal.set("李四");
            System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
        },"线程1").start();
        new Thread(()->{
            threadLocal.set("王二");
            System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
        },"线程2").start();
        new Thread(()->{
            System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
        },"线程3").start();
        System.out.println("线程=" + Thread.currentThread().getName() + "获取到的数据=" + threadLocal.get());
    }
}

运行结果:

从运行结果,我们可以看出线程1和线程2在ThreadLocal中设置的值相互独立,每个线程只能取到自己设置的那个值。

TheadLocal的源码解析

ThreadLocal存储数据的逻辑是:每个线程持有一个自己的ThreadLocalMap,key为ThreadLocal对象的实例,value 是我们需要设值的值。

ThreadLocal的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);
    }

getMap的方法如下:

public class Thread implements Runnable {

	//每个线程自己的ThreadLocalMap对象通过ThreadLocal保存下来
  ThreadLocal.ThreadLocalMap threadLocals = null;

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

首先获取当前线程的ThreadLocalMap对象,该对象是通过实例变量threadLocals保存的。

2. 如果获取得到ThreadLocalMap,则直接设值,key为当前ThreadLocal类的this实例,如果获取不到调用createMap方法创建ThreadLoalMap实例,并将值设置到这个ThreadLocalMap中,后面我们会重点介绍ThreadLocal的createMap方法。
接下来我们就来看看ThreadLocal的get方法。

ThreadLocal的get方法

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

1.首先获取当前线程的ThreadLocalMap对象,没有的话,设置初始值(null)并返回

2. 如果可以获取到ThreadLocalMap 则获取其Entry对象,如果不为空则直接返回value
说完了ThreadLocal的set方法和get方法。我就来具体看看前面提到的ThreadLocalMap。

ThreadLocalMap的结构

public class ThreadLocal<T> {

	private static AtomicInteger nextHashCode =new AtomicInteger();

	//初始的Hash值是0x61c88647
	 private static final int HASH_INCREMENT = 0x61c88647;

	//每次调用就原子性的将hash值增加HASH_INCREMENT
	private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

	static class ThreadLocalMap {
		 //Entry继承WeakReference
		  static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

				private static final int INITIAL_CAPACITY = 16;

				 private void setThreshold(int len) {
					threshold = len * 2 / 3;
				}

			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作为ThreadLocal的静态内部类,由ThreadLocal所持有,每个线程内部通过ThreadLocal来获取自己的ThreadLocalMap实例。结构如下图所示:

从上述代码我们可以看出ThreadLocalMap实际上没有继承Map接口,其只是一个可扩展的散列表结构。初始大小是16。大于等于数据的1/2 的时候会扩容为2倍的原数组的rehash。初始的hashCode值为0x61c88647。每创建一个Entry对象,hash值就会增加一个固定大小0x61c88647。同时,我们注意到,ThreadLocalMap的Entry是继承WeakReference,和HashMap很大的区别是,Entry中没有next字段,所以不存在链表的情况。那么没有链表结构,发生hash冲突了怎么办呢?要解答这个问题就需要看看ThreadLocalMap的set方法了。

ThreadLocalMap的set方法

  private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
			//1.根据ThreadLocal对象的hash值,定位到table中的位置i
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
				//判断Entry.key等于当前的ThreadLoacl对象key,则覆盖旧值,退出。
                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();
        }

前面我们提到了每个ThreadLocal对象都有一个hash值threadLocalHashCode,每创建一个Entry对象,hash值就增加一个固定的大小0x61c88647

1.根据ThreadLocal对象的hash值,定位到table中的位置i

2.如果table[i]的Entry不为null

2.1. 判断Entry.key等于当前的ThreadLoacl对象key,则覆盖旧值,退出。

2.2. 如果Entry.key为null,将执行删除两个null 槽之间的所有过期的stale的entry,
并把当前的位置i上初始化一个Entry对象,退出

2.3 继续查找下一个位置i++

3.如果找到了一个位置k,table[k]为null,初始化一个Entry对象。

ThreadLocalMap的getEntry方法

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

		 private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }
  1. 根据当前ThreadLocal的hashCode mod table.length,计算直接索引的位置i,如果e不为null并且key相同则返回e。
  2. 如果e为null,返回null
  3. 如果e不为空且key不相同,则查找下一个位置,继续查找比较,直到e为null退出
  4. 在查找的过程中如果发现e不为空,且e的k为空的话,删除当前槽和下一个null槽之间的所有过期entry对象。
    总结ThreadLocalMap:
  5. ThreadLocalMap的散列表采用开放地址,线性探测的方法处理hash冲突,在hash冲突较大的时候效率低下,因为ThreadLoaclMap是一个Thread的一个属性,所以即使在自己的代码中控制设置的元素个数,但还是不能控制其他代码的行为。
  6. ThreadLocalMap的set、get、remove操作中都带有删除过期元素的操作,类似缓存的lazy淘汰。

ThreadLocal的内存泄露

ThreadLocal可能导致内存泄露,为什么?先看看Entry的实现:

	  static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

通过之前的分析我们已经知道,当使用ThreadLocal保存一个value时,会在ThreadLoalMap中的数组插入一个Entry对象,按理来说key-value都可以以强引用保存在Entry对象中,但在ThreadLocalMap的实现中,key被保存到了WeakReference对象(弱引用)中,即ThreadLocalMap弱引用ThreadLocal。
Key的引用链是
ThreadLocalRef---->ThreadLocal
这就导致了一个问题,当一个ThreadLocal没有强引用时,threadLocal会被GC清理,会形成一个key为null的Map的引用。
但是value是强引用的,只有当当前线程结束了value的强引用才会结束,但线程迟迟未结束时,就会出现
ThreadRef---->Thread---->ThreadLocalMap—>Entry—>value这条强引用链条。
废弃threadLocal占用的内存会在三种情况下清理:

  1. thread结束,那么与之相关的threadlocal value会被清理
  2. GC后,thread.threadLocal(map) 的threadhold超过最大值时,会清理
  3. GC后,thread.threadlocals(maps)添加新的Entry时,hash算法没有命中既有Entry时,会清理

那么何时会“内存泄漏”?当Thread长时间不结束,存在大量废弃的ThreadLocal,而又不再添加新的ThreadLocal时。

如何避免内存泄露呢

在调用ThreadLocal的get()set()可能会清除ThreadLocalMap中key为null的Entry对象,这样对应的value就没有GC Roots可达了,下次GC的时候就可以被回收,当然如果调用remove方法,肯定会删除对应的Entry对象。

  ThreadLocal<String> threadLocal = new ThreadLocal<>();
        try {
            threadLocal.set("张三");
        } catch (Exception e) {
            threadLocal.remove();
        }

应用实例

public class DateUtil {
    private final static Map<String, ThreadLocal<SimpleDateFormat>> sdfMap = new HashMap<>();
	    public final static String Y2M2D2HMS_ = "yyyy/MM/dd HH:mm:ss";
	    private static SimpleDateFormat getsdf(final String pattern) {
        ThreadLocal<SimpleDateFormat> sdfThread = sdfMap.get(pattern);
        if (sdfThread == null) {
            //双重检验,防止sdfMap被多次put进去值,和双重锁单例原因是一样的
            synchronized (DateUtil.class) {
                // 只有Map中还没有这个pattern的sdf才会生成新的sdf并放入map
                // 这里是关键,使用ThreadLocal<SimpleDateFormat>替代原来直接new SimpleDateFormat
                sdfThread = sdfMap.get(pattern);
                if (sdfThread == null) {
                    sdfThread = ThreadLocal.withInitial(() -> new SimpleDateFormat(pattern));
                    sdfMap.put(pattern, sdfThread);
                }

            }
        }
        return sdfThread.get();
    }
	    /**
     * @param date    需要格式化的date
     * @param pattern 给定转换格式
     * @return java.lang.String 时间串
     * @description 按照指定pattern的方式格式化时间
     */
    public static String formatDate(Date date, String pattern) {
        return DateUtil.getsdf(pattern).format(date);
    }
}

SimpleDateFormat是线程不安全的类,同时创建一个SimpleDateFormat类又比较耗时,所以,我们可以将SimpleDateFormat类放在ThreadLocal包装起来。然后,根据日期格式化的类型作为key放入一个静态的map中。

实际应用二

 private static ThreadLocal<DecimalFormat> DECIMAL_FORMAT_THREAD_LOCAL = ThreadLocal.withInitial(() -> new DecimalFormat(DECIMAL_FORMAT));

    /**
     * 获取金额格式化的类
     * @return
     */
    public static DecimalFormat getDecimalFormat() {
        return DECIMAL_FORMAT_THREAD_LOCAL.get();
    }

我们可以将金额格式化的类DecimalFormat保存到ThreadLocal中。

总结

本文简单的介绍了ThreadLocal的应用场景,其主要用在需要每个线程独占的元素上,例如SimpleDateFormat。然后,就是介绍了ThreadLocal的实现原理,详细介绍了set()get()方法,介绍了ThreadeLocalMap的数据结构,最后就是说到了ThreadLocal的内存泄露以及避免的方式。

到此这篇关于Java ThreadLocal原理解析以及应用场景分析案例详解的文章就介绍到这了,更多相关Java ThreadLocal原理解析以及应用场景内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java ThreadLocal的使用场景总结

    使用场景1:本地变量 我们以多线程格式化时间为例,来演示 ThreadLocal 的价值和作用,当我们在多个线程中格式化时间时,通常会这样操作. ① 2个线程格式化 当有 2 个线程进行时间格式化时,我们可以这样写: import java.text.SimpleDateFormat; import java.util.Date; public class Test { public static void main(String[] args) throws InterruptedExcept

  • java中ThreadLocal的应用场景实例分析

    说到线程的安全,我们可以通过ThreadLocal来解决.但作为一种强大的变量,它的应用场景远不止如此.在各类的框架中,我们依然可以使用来对它们进行管理.同时在使用ThreadLocal时需要注意内存泄漏的问题.下面我们就这两点进行分析,并带来对应代码的展示. 1.各种框架中的应用 Spring框架的事务管理中使用ThreadLocal来管理连接,每个线程是单独的连接,当事务失败时不能影响到其他线程的事务过程或结果,还有大家耳闻目睹的ORM框架.Mybatis也是用ThreadLocal管理,S

  • java中ThreadLocal取不到值的两种原因

    1.两种原因 第一种,也是最常见的一种,就是多个线程使用ThreadLocal 第二种,类加载器不同造成取不到值,本质原因就是不同类加载器造成多个ThreadLocal对象 public class StaticClassLoaderTest { protected static final ThreadLocal<Object> local = new ThreadLocal<Object>(); //cusLoader加载器加载的对象 private Test3 test3;

  • Java单线程ThreadLocal串值问题解决方案

    ThreadLocal ThreadLocal 适用于变量在线程间隔离,而在方法或类间共享的场景. 代码 @RestController public class ThreadLocalController { private static final ThreadLocal<String> currentUid = ThreadLocal.withInitial(() -> null); @GetMapping("bad") public Map doBad(@Re

  • Java中的ThreadLocal功能演示示例

    除了使用synchronized同步符号外,Java中的ThreadLocal是另一种实现线程安全的方法.在进行性能测试用例的编写过程中,比较简单的办法就是直接使用synchronized关键字,修饰对象.方法以及类.但是使用synchronized同步,这可能会影响应用程序的可伸缩性以及运行效率.但是如果要在多个线程之间共享对象又要保障线程安全,则除了synchronized之外没有特别适合测试的方法. Java中的ThreadLocal是实现线程安全的另一种方法,它不满足同步要求,而是通过为

  • java中ThreadLocalRandom的使用详解

    在java中我们通常会需要使用到java.util.Random来便利的生产随机数.但是Random是线程安全的,如果要在线程环境中的话就有可能产生性能瓶颈. 我们以Random中常用的nextInt方法为例来具体看一下: public int nextInt() { return next(32); } nextInt方法实际上调用了下面的方法: protected int next(int bits) { long oldseed, nextseed; AtomicLong seed = t

  • Java ThreadLocal原理解析以及应用场景分析案例详解

    目录 ThreadLocal的定义 ThreadLocal的应用场景 ThreadLocal的demo TheadLocal的源码解析 ThreadLocal的set方法 ThreadLocal的get方法 ThreadLocalMap的结构 ThreadLocalMap的set方法 ThreadLocalMap的getEntry方法 ThreadLocal的内存泄露 如何避免内存泄露呢 应用实例 实际应用二 总结 ThreadLocal的定义 JDK对ThreadLocal的定义如下: The

  • Java struts2请求源码分析案例详解

    Struts2是Struts社区和WebWork社区的共同成果,我们甚至可以说,Struts2是WebWork的升级版,他采用的正是WebWork的核心,所以,Struts2并不是一个不成熟的产品,相反,构建在WebWork基础之上的Struts2是一个运行稳定.性能优异.设计成熟的WEB框架. 我这里的struts2源码是从官网下载的一个最新的struts-2.3.15.1-src.zip,将其解压即可.里面的目录页文件非常的多,我们只需要定位到struts-2.3.15.1\src\core

  • Java list与set中contains()方法效率案例详解

    list.contains(o) :遍历集合所有元素,用每个元素和传入的元素进行 equals 比较,如果集合元素有 n 个,则会比较 n 次,所以时间复杂度为 O(n) .方法源码如下: // ArrayList 中的方法 public boolean contains(Object o) { return indexOf(o) >= 0; } public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size;

  • Java 处理高并发负载类优化方法案例详解

    java处理高并发高负载类网站中数据库的设计方法(java教程,java处理大量数据,java高负载数据) 一:高并发高负载类网站关注点之数据库 没错,首先是数据库,这是大多数应用所面临的首个SPOF.尤其是Web2.0的应用,数据库的响应是首先要解决的. 一般来说MySQL是最常用的,可能最初是一个mysql主机,当数据增加到100万以上,那么,MySQL的效能急剧下降.常用的优化措施是M-S(主-从)方式进行同步复制,将查询和操作和分别在不同的服务器上进行操作.我推荐的是M-M-Slaves

  • Java 内置Http Server构建web应用案例详解

    一.概述 使用Java技术构建Web应用时, 我们通常离不开tomcat和jetty之类的servlet容器,这些Web服务器功能强大,性能强劲,深受欢迎,是运行大型Web应用的必备神器. 虽然Java的设计初衷就是用来开发大型应用的,然而有时候我们开发的程序只是简单的小型应用,对于功能的需求和性能的要求并不高, 可能仅仅就几百行甚至几十行代码,这个时候使用tomcat之类的Web服务器去运行就显得有点大材小用了. 比如说只是将数据库中的数据读出来转换成JSON,以Web服务的形式吐给调用方这样

  • Java基于装饰者模式实现的染色馒头案例详解

    本文实例讲述了Java基于装饰者模式实现的染色馒头案例.分享给大家供大家参考,具体如下: 一.模式定义 装饰者模式,是在不改变原类文件和使用继承的情况下,动态扩展一个对象功能,它是通过创建一个包装对象,也就是装饰来包装真实的对象. 装饰对象和真实对象有相同接口,这样客户端对象就可以和真实对象相同方式和装饰对象交互. 装饰对象包含一个真实对象的引用. 二.模式举例 1. 模式分析 我们借用黑心商贩制做染色馒头案例说明这一模式. 2. 装饰者模式静态类图 3. 代码示例 3.1 创建馒头接口--IB

  • Redis exists命令bug分析(案例详解)

    目录 1.复现条件版本: 2.源码分析 3.问题解决 本文基于社区版Redis 4.0.8 1.复现条件版本: 社区版Redis 4.0.10以下版本 使用场景:开启读写分离的主从架构或者集群架构(master只负责写流量,slave负责读流量) 案例: # 写入一条带过期时间10s的key 10.90.73.147:12345> set luxiu1 1 ex 10 OK 10.90.73.147:12345> get luxiu1 "1" 10.90.73.147:12

  • Java使用原型模式展现每日生活应用案例详解

    本文实例讲述了Java使用原型模式展现每日生活.分享给大家供大家参考,具体如下: 一.模式定义 用原型实例指定创建对象的种类,并且通过复制这些原型创建新的对象. 二.模式举例 1 模式分析 我们借用每日上班情景耒说明这一模式. 2 故事情节分析图 3 原型模式静态建模 4 代码示例 4.1 原型建立 package com.prototype.pojo; /** * 日常生活类 * * @author * */ public class DayLife implements Cloneable

  • Redis 中ZSET数据类型命令使用及对应场景总结(案例详解)

    目录 1.zadd添加元素 2.zrem 从有序集合key中删除元素 3.zscore 返回有序集合key中元素member的分值 4.zincrby 为有序集合key中元素增加分值 5.zcard获取有序集合key中元素总个数 6.zrange 正序获取分值范围内的元素 7.zrevrange 倒序获取集合元素 8.zrank获取有序集合中元素key的排名 9.zrangebyscore 获取有序集合中分数区间的元素 10.zcount 获取分值区间的元素数量 1.zadd添加元素 zadd

  • Java基于享元模式实现五子棋游戏功能实例详解

    本文实例讲述了Java基于享元模式实现五子棋游戏功能.分享给大家供大家参考,具体如下: 一.模式定义 享元模式,以共享的方式高效地支持大量的细粒度对象.通过复用内存中已存在的对象,降低系统创建对象实例的性能消耗.享元的英文是Flyweight,表示特别小的对象,即细粒度对象. 二.模式举例 1. 模式分析 我们借用五子棋游戏来说明这一模式. 2. 享元模式静态类图 3. 代码示例 3.1 创建抽象棋子一AbstractChessman package com.demo.flyweight.obj

随机推荐