JDK源码解析---ThreadLocal

1.概述

维持线程封闭性除了Ad-hoc封闭和栈封闭,更规范的方法是使用ThreadLocal,这个类是java lang包下的一个类。他能使线程中的某个值与保存值的对象关联起来。ThreadLocal提供了get set等访问接口或方法,这些方法为每个使用该变量的线程都存有一份独立地副本,因此get总能返回由当前执行线程在调用set时设置的最新值。

2.属性

private final int threadLocalHashCode = nextHashCode(); //ThreadLocal实例hash值,用来区分不同实例

private static AtomicInteger nextHashCode =
    new AtomicInteger();//可以看作hash值的一个基值

private static final int HASH_INCREMENT = 0x61c88647;//hash值每次增加量

3.内部类 ThreadLocalMap

用于保存线程中的变量使用一个Enrty类型的数组 private Entry[] table;

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

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

Entry结构如上,并且是一个弱引用的对象。是因为当ThreadLocal指向null的时候,会出现key为空的Entry,对应的value是无法访问到的。便存在着内存泄漏的问题。所以将Enrty设置成弱引用可以避免内存泄漏的问题,这些对象只能存活到下一次垃圾回收之前。

3.1属性
private static final int INITIAL_CAPACITY = 16;//数组初始容量

private Entry[] table;//用于保存变量的数组

private int size = 0;//数组中变量的个数

private int threshold; // 阈值
3.2构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {//key value
    table = new Entry[INITIAL_CAPACITY];//根据初始容量构建一个Entry数组
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//计算存储的位置
    table[i] = new Entry(firstKey, firstValue);//构建一个保存value的Enrty
    size = 1;//当前数组内元素个数1个
    setThreshold(INITIAL_CAPACITY);//设置阈值为16
}

private ThreadLocalMap(ThreadLocalMap parentMap) {//构建一个新的ThreadLocalMap,继承自参数parenytMap
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];

    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}
3.3方法
private void setThreshold(int len) {//设置阈值
    threshold = len * 2 / 3;
}

/**
 * Increment i modulo len.
 */
private static int nextIndex(int i, int len) {//下一个索引
    return ((i + 1 < len) ? i + 1 : 0);
}

/**
 * Decrement i modulo len.
 */
private static int prevIndex(int i, int len) {//前一个索引
    return ((i - 1 >= 0) ? i - 1 : len - 1);
}

private Entry getEntry(ThreadLocal<?> key) {//根据key获得Entry,根据传入的key计算hash然后得到数组中的位置。找到了返回,没找到就继续往后找
    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)//当e对应的ThreadLocal和传入的参数key一样的时候返回Enrty
            return e;
        if (k == null)//若e指向的ThreadLocal为空,则将这个Entry对象清空
            expungeStaleEntry(i);
        else//若e指向的ThreadLocal与传入的参数不同,则获取i下一位对应的Entry
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

private void set(ThreadLocal<?> key, Object value) {//添加到数组中
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

  	//先寻找有没有已存在的key对应的元素
    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();
}

private void remove(ThreadLocal<?> key) {//移除key对应的Entry
    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;
        }
    }
}
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

            // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

            // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
        (e = tab[i]) != null;
        i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

4.set方法

public void set(T value) {
    Thread t = Thread.currentThread();//获取当前的线程
    ThreadLocalMap map = getMap(t);//根据当前的线程得到ThreadLocalMap
    if (map != null)//若不为空
        map.set(this, value);//则将ThreadLocal作为key,value作为value保存在map中
    else
        createMap(t, value);//否则新建一个Map
}

5.get方法

public T get() {
    Thread t = Thread.currentThread//获取当前线程
    ThreadLocalMap map = getMap(t);//获取当前线程的ThradLocalMap对象
    if (map != null) {//若不为空
        ThreadLocalMap.Entry e = map.getEntry(this);//从中获取key
        if (e != null) {//key不为空
            @SuppressWarnings("unchecked")
            T result = (T)e.value;//获得值
            return result;
        }
    }
    return setInitialValue();
}

6.remove方法

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

7.应用场景

  1. 框架中的应用。Spring采用ThreadLocal的方式,来保证单个线程中的数据库操作使用的是同一个数据库连接。
  2. 实际工作中的应用。我们知道SimpleDataFormat不是线程安全的。所以如果声明为全局变量会有并发安全隐患。一般会在使用这个类的方法里创建SimpleDataFormat对象,这样不会有并发隐患。但是方法内部的对象在方法执行完其生命周期就结束了,如果一个请求在调用链路的n个方法中都调用了SimpleDataFormat,是不是要创建n个对象?此时我们可以将其声明为ThreadLocal,一个线程在其生命周期内使用同一个SimpleDataFormat,不同对象之间使用各自的SimpleDataFormat对象,形成线程间的数据隔离,不会有并发安全隐患。然而这种场景,适用于一个线程有多个方法调用都用到了SimpleDataFormat,可以减少创建对象的次数。如果生命周期内只有一个方法使用了这个对象,在方法里创建就好了。
  3. 用于传递参数。项目中,一个线程横跨若干个方法调用,需要传递的对象,也就是上下文,它是一种状态,经常就是用户身份、任务信息等,就会存在过渡传参的问题。在线程最开始设置ThreadLocal对象,在线程生命周期的多个方法执行过程中,通过tl.get()就可以取出参数。这种方法可以避免通过方法入参传递变量。

8.内存泄漏问题

在这里插入图片描述

1.每次使用完ThreadLocal将tl设置为null 这样ThreadLocal只存在弱引用,下一次gc的时候就会将其回收掉。

2.当ThreadLocal对象被回收后,key指向的就是null 此时无法访问到对应的value,这就造成了内存泄漏的问题。所以需要显示的删除这个键值对。调用tl.remore()。

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jdk-11-windows是指Java开发工具包(Java Development Kit)的第11个版本,适用于Windows操作系统。JDK是使用Java语言进行开发的应用程序和软件的环境,它提供了许多工具和功能,可用于编写、编译和运行Java程序。 JDK-11包含了许多新的特性和改进,使得Java编程更加方便和高效。其中一项突出的特性是JVM(Java虚拟机)的性能改进,它可以提供更快速和更高效的执行速度。其他一些特性包括G1垃圾回收器的增强和适用于观察、诊断和监控Java程序的Java Flight Recorder和Java Mission Control工具等。 对于Windows用户来说,JDK-11提供了易于安装和使用的Windows平台上的开发环境。它包括了JRE(Java运行环境)和用于开发、调试和测试Java应用程序的工具集。通过JDK-11,开发人员可以利用Windows操作系统的优势和特性,进行快速、高效和可靠的Java开发。 此外,JDK-11还提供了许多与安全性和稳定性相关的改进。它包含了新的安全性特性,可以帮助开发人员保护他们的应用程序免受潜在的安全威胁。另外,JDK-11还包含了一些稳定性改进,可以提高应用程序的性能和可靠性。 总之,JDK-11-windows是适用于Windows操作系统的Java开发工具包的最新版本。它提供了许多新的特性和改进,使得Java开发更加方便、高效和安全。对于Windows用户来说,使用JDK-11可以提供更好的开发体验,使他们能够更轻松地创建出优秀的Java应用程序。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值