文章目录

ThreadLocal介绍

官方介绍

从java官方文档中的描述: ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问(通过get和set方法访问)时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的,用于关联线程和线程上下文。
我们可以得知ThreadLocal的作用是:提供线程内的局部变量,不同的线程之间不会相互干扰,这种变量在线程的生命周期内起作用,减少同一一个线程内多个函数或组件之间一些公共变量传递的复杂度。

总结:
1. 线程并发: 在多线程的场景下
2. 传递数据: 我们可以通过ThreadLocal在同一线程,不同组件中传递公共变量
3. 线程隔离: 每个线程的变量都是独立的，不会互相影响

基本使用

常用方法

使用案例

不适用ThreadLocal的情况:

/**
 * 需求:  线程隔离
 * 在多线程并发的场景下,每个线程中的变量都是互相独立的
 * 线程A: 设置(变量1)    获取(变量1)
 * 线程B: 设置(变量2)    获取(变量2)
 */
public class MyDemo {
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        MyDemo demo = new MyDemo();
        for (int i = 0; i < 5; i++) {
            /**
             * 每个线程: 存一个变量,过一会儿取出这个变量
             */
            new Thread(() -> {
                demo.setContent(Thread.currentThread().getName() + "的数据");
                System.out.println("--------------");
                System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
            },"线程"+i).start();
        }
    }
}

可以看到,出现了线程不安全的情况(显而易见)

我们使用ThreadLocal试试:

不管运行几次都不会出现问题:

ThreadLocal与synchronized关键字

synchronized同步方式

new Thread(() -> {
    synchronized(MyDemo.class){
        demo.setContent(Thread.currentThread().getName() + "的数据");
        System.out.println("--------------");
        System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
    }   
},"线程"+i).start();

这种方式当然也可以实现线程安全,但是对比TrheadLocal来说效率会降低. 即,把并行的线程改为了串行,吞吐量降低,于是效率降低

ThreadLocal与synchronized的区别

虽然ThreadLocal模式与synchronized关键字都用于处理多线程并发访问变量的问题,不过两者处理问题的角度和思路不同。

总结

在刚刚的案例中，虽然使用ThreadLocal和synchronized都能解决问题,但是使用Threadlocal更为合适,因为这样可以使程序拥有更高的并发性。

运用场景_事务案例

ThreadLocal具体能用在什么地方?

转账案例

场景构建

这里我们先构建一个简单的转账场景:有一个数据表account ,里面有两个用户Jack和Rose ,用户Jack给用户Rose转账。
案例的实现主要用mysq|数据库, JDBC和C3P0框架。

项目结构

config.xml
jdbc工具类
service

引入事务

案例中的转账涉及两个DML操作: 一个转出, 一个转入。这些操作是需要具备原子性的,不可分割。不然就有可能出现数据修改异常情况。

模拟一个异常

所以这里就需要操作事务,来保证转出和转入操作具备原子性,要么同时成功,要么同时失败。

jdbc中关于事务操作的api
开启事务的注意点

为了保证所有的操作在一个事务中,案例中使用的连接必须是同一个: service层开启事务的connection需要跟dao层访问数据库的connection保持一致
线程并发情况下，每个线程只能操作各自的connection

常规解决方案

常规解决方案的实现

传参加锁

常规解决方案的弊端

增加了代码的耦合度 (传参)
降低了程序的性能 (加锁)

使用ThreadLocal来解决上述事务问题

代码修改

获取连接修改

原本: 直接从连接池中获取连接

现在:

1. 直接获取当前线程绑定的连接对象
2. 如果连接对象是空的
  	1. 再去连接池中获取连接
  	2. 将此连接对象与当前线程绑定

使用完成后将connection与threadlocal解绑

为什么要解绑是为了防止内存泄漏,往下看

ThreadLocal方案的好处

从上述的案例中我们可以看到，在一些特定场景下 , ThreadLocal方案有两个突出的优势:

传递数据: 保存每个线程绑定的数据,在需要的地方可以直接获取,避免参数直接传递带来的代码耦合问题
线程隔离: 各线程之间的数据相互隔离却又具备并发性,避免同步方式带来的性能损失

ThreadLocal的内部结构

通过以上的学习,我们对ThreadLocal的作用有了-定的认识。现在我们一起来看一下Threadlocal的内部结构,探究它能够实现线程数据隔离的原理。

常见的误解(早期的设计)

通常,如果我们不去看源代码的话,我猜ThreadlLocal是这样子设计的:每个ThreadLocal类都创建一个Map ,然后用线程的ID threadID 作为Map的key , 要存储的局部变量作为Map的value , 这样就能达到各个线程的局部变量隔离的效果。这是最简单的设计方法, JDK最早期的ThreadLocal就是这样设计的。

现在的设计

但是, JDK后面优化了设计方案,在JDK8中ThreadLocal的设计是:每个Thread维护一个ThreadlocalMap , 这个Map的key是ThreadLocal实例本身，value 才是真正要存储的值object。具体的过程是这样的:

每个Thread线程内部都有一个Map (ThreadLocalMap)
Map里面存储ThreadLocal对象( key )和线程的变量副本( value )
Thread内部的Map是由ThreadLocal维护的,由ThreadLocal负责向map获取和设置线程的变量值。
对于不同的线程,每次获取副本值时,别的线程并不能获取到当前线程的副本值,形成了副本的隔离,互不干扰。

这样设计的好处

两个好处:

每个Map存储的Entry数量变少 (并不是所有的Thread都会使用ThreadLocal)
当Thread销毁的时候,ThreadLocalMap也会随之销毁,减少内存的使用

ThreadLocal的核心源码方法

基于ThreadLocal的内部结构,我们继续分析它的核心方法源码,更深入的了解其操作原理。除了构造方法之外. ThreadLocal对外暴露的方法有以下4个:

以下是这4个方法的详细源码分析

set方法

源码片段:

/**
     * 设置当前线程对应的ThreadLocal的值
     * @param value 将要保存在当前线程对应的ThreadLocal的值
     */
    public void set(T value) {
        //获取当前线程对象
        Thread t = Thread.currentThread();
        //获取此线程对象中维护的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        //判断map是否存在
        if (map != null) {
            //存在调用map.set()设置这个实体entry
            map.set(this, value);
        } else {
            //1. 当前线程Thread不存在ThreadlocalMap对象
			//2. 则调用createMap进行ThreadLocalMap对象的初始化
			//3. 并将t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
        }
    }

/**
     * 获取当前线程Thread对应维护的ThreadLocalMap
     *
     * @param  t 	the current thread 
     * @return 		the map 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

/**
     * 创建当前线程Thread对应维护的ThreadLocalMap
     * @param t				 the current thread
     * @param firstValue	 存放到map中第一个entry的值
     */
    void createMap(Thread t, T firstValue) {
        //这里的this是调用此方法的threadlocal
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

代码执行流程

A. 首先获取当前线程,并根据当前线程获取一个Map
B. 如果获取的Map不为空,则将参数设置到Map中(当前ThreadLocal的引用作为key )
C. 如果Map为空,则给该线程创建Map ,并设置初始值

get方法

源码片段

/**
     * 返回当前线程中保存ThreadLoca1的值
	 * 言如果当前线程没有此ThreadLoca1变量，
	 * 则它会通过调用{@link #initialvalue} 方法进行初始化值
	 * @return 返回当前线程对应此ThreadLocal的值

     */
    public T get() {
        //获取当前线程对象
        Thread t = Thread.currentThread();
        //获取此线程对象中维护的Thr eadL ocalMap对象
        ThreadLocalMap map = getMap(t);
        //如果此map存在
        if (map != null) {
            //以当前的ThreadLocal为key,调用getEntry获取对应的存储实体e
            ThreadLocalMap.Entry e = map.getEntry(this);
            //对e进行判空
            if (e != null) {
                @SuppressWarnings("unchecked")
                //获取存储实体e对应的value值
				//即为我们想要的当前线程对应此Threadlocal的值
                T result = (T)e.value;
                return result; 
            }
        }
        /*
			初始化:有两种情况有执行当前代码
			第一种情况: map不存在,表示此线程没有维护的ThreadLocalMap对象
			第二种情况: map存在，但是没有与当前ThreadLocal关联的entry
		*/
        return setInitialValue();
    }

/**
     * 初始化
     * @return		 the initial value 初始化后的值
     */
    private T setInitialValue() {
        //调用initialvalue获取初始化的值
		//此方法可以被子类重写，如果不重写默认返回nu11
        T value = initialValue();
        //获取当前线程对象
        Thread t = Thread.currentThread();
        //获取此线程对象中维护的Thr eadLoca lMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //判断map是否存在,存在则调用map.set设置此实体entry
            map.set(this, value);
        } else {
            //1. 当前线程Thread不存在ThreadlocalMap对象
			//2. 则调用createMap进行ThreadLocalMap对象的初始化
			//3. 并将t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        //
        return value;
    }

代码执行流程

A. 首先获取当前线程,根据当前线程获取一个Map
B. 如果获取的Map不为空,则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entry e ,否则转到D
C. 如果e不为null ,则返回e.value ,否则转到D
D. Map为空或者e为空,则通过initialValue函数获取初始值value ,然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map

总结: 先获取当前线程的ThreadLocalMap变量,如果存在则返回值.不存在则创建并返回初始值

remove方法

源码

/**
   	 * 删除当前线程中保存的ThreadLoca1对应的实体entry
     */
     public void remove() {
         //获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
         //如果map存在
         if (m != null) {
             //存在则调用map.remove
			 //以当前ThreadLoca1为key删除对应的实体entry
             m.remove(this);
         }
     }

代码执行流程

A. 首先获取当前线程,并根据当前线程获取一个Map
B. 如果获取的Map不为空,则移除当前ThreadLocal对象对应的entry

initialValue方法

源码

/**
 * 返回当前线程对应的ThreadLocal的初始值
 
 * 此方法的第一次调用发生在 ，当线程通过get方法访问此线程的ThreadLocal值时
 * 除非线程先调用了set方法，在这种情况下，initialvalue才不会被这个线程调用。
 * 通常情况下，每个线程最多调用一次这个方法。

 * method, in which case the {@code initialValue} method will not
 * be invoked for the thread.  Normally, this method is invoked at
 * most once per thread, but it may be invoked again in case of
 * subsequent invocations of {@link #remove} followed by {@link #get}.
 *
 * <p>这个方法仅仅简单的返回nu11 {@code nu11};
 * 如果程序员想ThreadLocal线程局部变量有一个除nu11以外的初始值，
 * 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
 * 通常，可以通过匿名内部类的方式实现
 *
 * @return 当前ThreadLocal的初始值
 */
protected T initialValue() {
    return null;
}

此方法的作用是返回该线程局部变量的初始值。
(1) 这个方法是一个延迟调用方法 , 以上面的代码我们得知,在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。
(2) 这个方法缺省实现直接返回一个nu11。
(3) 如果想要一个除null之外的初始值,可以重写此方法。( 备注:该访法是一个protected的方法,显然是为了让子类覆盖而设计的)

ThreadLocalMap源码分析

在分析ThreadLocal方法的时候,我们了解到ThreadLocal的操作实际上是围绕ThreadLocalMap展开的。
ThreadLocalMap的源码相对比较复杂我们从以下三个方面进行讨论。

基本结构

ThreadLocalMap是ThreadLocal的内部类,没有实现Map接口,用独立的方式实现了Map的功能,其内部的Entry也是独立实现。

成员变量

		/**
         * 初始容量,必须是2的整数次幂
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * 存放数据的table, Entry类在下面分析
         * 同样,数组长度必须是2的整数次幂
         */
        private Entry[] table;

        /**
         * 数组里面entrys的个数,可以用于判断table当前使用量是否超过阈值
         */
        private int size = 0;

        /**
         * 进行扩容的阈值,表使用量大于它的时候进行扩容
         */
        private int threshold; // Default to 0

跟HashMap类似, INITIAL CAPACITY代表这个Map的初始容量;

table是一个Entry 类型的数组.用于存储数据;

size代表表中的存储数目;

threshold 代表需要扩容时对应size的阈值。

存储结构-Entry

/**
* Entry继承WeakReference ,并且用ThreadLocal作为key. 
* 如果key为null(entry.get() == null) ， 意味着key不再被引用，
* 因此这时候entry也可以从tab1e中清除。
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

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

在ThreadLocalMap中,也是用Entry来保存K-V结构数据的。不过Entry中的key只能是ThreadLocal对象,这点在构造方法中已经限定死了。
另外, Entry继承WeakReference ,也就是key ( ThreadLocal )是弱引用,其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

弱引用和内存泄漏

有些程序员在使用ThreadLocal的过程中会发现有内存泄漏的情况发生,就猜测这个内存泄漏跟Entry中使用了弱引用的key有关系。这个理解其实是不对的。
我们先来回顾这个问题中涉及的几个名词概念,再来分析问题。

内存泄漏

Memory overflow: 内存溢出,没有足够的内存提供申请者使用。
Memory leak: 内存泄漏是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放,造成系统内存的浪费,导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积终将导致内存溢出。

弱引用

Java中的引用有4种类型:强、软、弱、虚。当前这个问题主要涉及到强引用和弱引用:
强引用( “Strong” Reference) , 就是我们最常见的普通对象引用，只要还有强引用指向一个对象,就能表明对象还“活着”,垃圾回收器就不会回收这种对象。
弱引用( WeakReference) ,垃圾回收器一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。

如果key使用强引用

假设ThreadLocalMap中的key使用了强引用,那么会出现内存泄漏吗?

此时ThreadLocal的内存图(实线表示强引用)如下:

假设在业务代码中使用完ThreadLocal , threadLocal Ref被回收了。
但是因为threadLocalMap的Entry强引用了threadLocal ,造成threadLocal无法被回收。
在没有手动删除这个Entry以及CurrentThread依然运行的前提下.始终有强引用链threadRef-> currentThread-> threadLocalMap->entry ,Entry就不会被回收(Entry中包括了ThreadLocal实例和value)，导致Entry内存泄漏。

也就是说, ThreadLocalMap中的key使用了强引用，是无法完全避免内存泄漏的。

假设ThreadLocalMap中的key使用了弱引用,那么会出现内存泄漏吗?

同样假设在业务代码中使用完ThreadLocal , threadLocal Ref被回收了。
于ThreadLocalMap只持有ThreadLocal的弱引用.没有任何强引用指向threadlocal实例，所以threadlocal就可以顺利被gc回收.此时Entry中的key=null.
但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下,也存在有强引用链threadRef->currentThread->threadLocalMap-> entry ->value ,value不会被回收,而这块value永远不会被访问到了.导致value内存泄漏。

也就是说, ThreadLocalMap中的key使用了弱引用，也有可能内存泄漏。

出现内存泄漏的真实原因?

比较以上两种情况,我们就会发现,内存泄漏的发生跟ThreadLocalMap中的key是否使用弱引用是没有关系的。
那么内存泄漏的的真正原因是什么呢?

细心的同学会发现,在以上两种内存泄漏的情况中.都有两个前提:

没有手动删除这个Entry
CurrentThread依然运行

第一点很好理解，只要在使用完ThreadLocal ,调其remove方法删除对应的Entry ,就能避免内存泄漏。
第二点稍微复杂一点,由于ThreadLocalMap是Thread的一个属性,被当前线程所引用,所以它的生命周期跟Thread一样长。那么在使用完ThreadLocal的使用,如果当前Thread也随之执行结束, ThreadLocalMap自然也会被gc回收,从根源上避免了内存泄漏。

综上, ThreadLocal内存泄漏的根源是:由于ThreadLocalMap的生命周期跟Thread一样长.如果没有手动删除对应key就会导致内存泄漏。

那为什么要用弱引用

根据刚才的分析,我们知道了:无论使用ThreadLocalMap中的key使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。

要避免内存泄漏有两种方式:

使用完ThreadLocal ,调用其remove方法删除对应的Entry
使用完ThreadLocal ,当前Thread也随之运行结束

相对第一种方式，第二种方式显然更不好控制,特别是使用线程池的时候,线程结束是不会销毁的。

也就是说,只要记得在使用完ThreadLocal及时的调用remove ,无论key是强弓|用还是弱引用都不会有问题。那么为什么key要用弱引用呢?

事实上，在ThreadLocalMap中的set/getEntry方法中,会对key为null (也即是ThreadLocal为null )进行判断,如果为null的话,那么是会对value置为null的。

这就意味着使用完Thread ocal , CurrentThread依然运行的前提下,就算忘记调用remove方法,弱引用比强引可以多一层保障: 弱引用的ThreadLocal会被回收,对应

的value在下一次ThreadLocalMap调用set,get,remove中的任一方法的时候会被清除,从而避免内存泄漏。

hash冲突的解决

hash冲突的解决是Map中的一个重要内容。我们以hash冲突的解决为线索,来研究一下ThreadLocalMap的核心源码。

首先从ThreadLocal的set()方法入手

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //调用了ThreadLocalMap的set方法
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }


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

    void createMap(Thread t, T firstValue) {
        //调用了ThreadLocalMap的构造方法
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

这个方法我们刚才分析过,其作用是设置当前线程绑定的局部变量:
A. 首先获取当前线程,并根据当前线程获取一个Map

B. 如果获取的Map不为空,则将参数设置到Map中(当前ThreadLocal的引用作为key)

(这里调用了ThreadLocalMap的set方法)

C. 如果Map为空,则给该线程创建Map,并设置初始值

(这里调用了ThreadLocalMap的构造方法)

这段代码有两个地方分别涉及到ThreadLocalMap的两个方法我们接着分析这两个方法。

构造方法 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

/**
* firstKey: 本ThreadLocal实例
* firstValue: 要保存的线程本地变量
* one when we have at least one entry to put in it.
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //初始化table
    table = new Entry[INITIAL_CAPACITY];
    //计算索引(重点)
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //设置值
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    //设置阈值
    setThreshold(INITIAL_CAPACITY);
}

构造函数首先创建一个长度为16的Entry数组,然后计算出firstKey对应的索引, 然后存储到table中,并设置size和threshold

重点分析:int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

关于firstKey.threadLocalHashCode

private final int threadLocalHashCode = nextHashCode();

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

//原子Integer类,线程安全的方式进行加减,适合高并发情况下使用
private static AtomicInteger nextHashCode =
        new AtomicInteger();

//特殊的hash值
private static final int HASH_INCREMENT = 0x61c88647; //十六进制

这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_ JINCREMENT，HASH INCREMENT =0x61c88647，这个值跟斐波那契数列(黄金分割数)有关,其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里也就是Entry[] table中,这样做可以尽量避免hash冲突。

关于& (INITIAL_CAPACITY - 1)

就和hashmap中计算下标的方式一样,保证每次都是2的n次方容量大小就可以通过与运算得到下标,理解为优化版的%运算就可

ThreadLocalMap中的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();
		//ThreadLocal对应的key存在,直接覆盖之前的值
        if (k == key) {
            e.value = value;
            return;
        }
		//key为null时,但是值不为null,说明之前的ThreadLocal对象已经被回收了
        //当前数组中的Entry是一个陈旧的(stable)的元素
        if (k == null) {
            //用新元素替换陈旧的元素,这个方法进行了不少的垃圾清理动作,防止内存泄漏
            replaceStaleEntry(key, value, i);
            return;
        }
    }
	//ThreadL oca1对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry.
    tab[i] = new Entry(key, value);
    int sz = ++size;
    /**
     * cleanSomeSlots用于清除那些e.get()==nu11的元表，
	 * 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置nu11.
	 * 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行
	 * rehash (执行一次全表的扫描清理工作)
     */
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

/**
 * 获取环形数组的下一个索引
 */
private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

代码执行流程

首先还是根据key计算出索引i,然后查找i位置上的Entry
若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值
若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry
不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一
个Entry ,并且插入，同时size增加1。

最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz是否>=threshold达到了rehash的条件,达到的话就会调用rehash函数执行一次全表的扫描清理。

重点分析 ThreadLocalMap使用线性探测法来解决哈希冲突的。

该方法一次探测下一个地址,直到有空的地址后插入,若整个空间都找不到空余的地址,则产生溢出。

举个例子,假设当前table长度为16 ,也就是说如果计算出来key的hash值为14 ,如果table[14]上已经有值，并且其key与当前key不一致,那么就发生了hash冲突,这个时候将14加1得到15 ,取table[15]进行判断,这个时候如果还是冲突会回到0 ,取table[0],以此类推,直到可以插入。

(是不是很熟悉?其实就是操作系统课上讲的解决hash冲突的一种方法)

按照上面的描述,可以把Entry[] table看成一个环形数组。

无内鬼,来点ThreadLocal!

文章目录

ThreadLocal介绍

官方介绍

基本使用

常用方法

使用案例

ThreadLocal与synchronized关键字

synchronized同步方式

ThreadLocal与synchronized的区别

总结

运用场景_事务案例

转账案例

场景构建

引入事务

常规解决方案

常规解决方案的实现

常规解决方案的弊端

使用ThreadLocal来解决上述事务问题

代码修改

获取连接修改

使用完成后将connection与threadlocal解绑

ThreadLocal方案的好处

ThreadLocal的内部结构

常见的误解(早期的设计)

现在的设计

这样设计的好处

ThreadLocal的核心源码方法

set方法

get方法

remove方法

initialValue方法

ThreadLocalMap源码分析

基本结构

弱引用和内存泄漏

内存泄漏

弱引用

如果key使用强引用

出现内存泄漏的真实原因?

那为什么要用弱引用

hash冲突的解决

首先从ThreadLocal的set()方法入手

构造方法 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

ThreadLocalMap中的set()方法