面试题：由ThreadLocal引发的惨案

最新推荐文章于 2024-05-01 03:11:03 发布
最新推荐文章于 2024-05-01 03:11:03 发布
阅读量401 收藏 1
点赞数
分类专栏： Java 文章标签： java ThreadLocal 和Synchronized区别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuihongyan518/article/details/114794079
版权

ThreadLocal在面试中经常被问到，下面我们就ThreadLocal进行一下认识和了解。

从以下几个问题去了解ThreadLocal：

1、ThreadLocal是什么？

2、ThreadLocal应用场景？

3、ThreadLocal怎么用，以及ThreadLocal和Synchronized关键词有啥区别？

4、ThreadLocal源码分析？

5、ThreadLocal内存泄漏问题？

 

问题1：什么是ThreadLocal？

官方介绍：ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。

简单来说：ThreadLocal就是线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

 

从上述中我们可以得出ThreadLocal的作用：提供线程内的局部变量，不同线程之间互不干扰。这种变量在线程的生命周期内起作用，减少同一线程内多个函数或组件之间一些公共变量传递的复杂度。

总结:

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

 

问题2、ThreadLocal应用场景？

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

问题3：ThreadLocal怎么用？

  • 3.1 ThreadLocal的常用方法

在使用之前,我们先来认识几个ThreadLocal的常用方法

方法声明描述
ThreadLocal() 创建ThreadLocal对象
public void set( T value)设置当前线程绑定的局部变量
public T get() 获取当前线程绑定的局部变量
public void remove() 移除当前线程绑定的局部变量

 

  • 3.2 应该示例
package com.threadlocal;

import java.util.stream.IntStream;

/**
 * 需求线程隔离：
 * 再多线程并发场景下，每个线程中的变量都是隔离的
 * 线程0，设置变量（0），获取变量0；
 * 线程1，设置变量（1），获取变量1；
 * 线程2，设置变量（2），获取变量2；
 * ......
 */
public class MyDemo {

    private String content;

    public MyDemo() {
    }

    public MyDemo(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

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

    public static void main(String[] args) {
        MyDemo myDemo = new MyDemo();

        //使用java8的lambda stream新建5个线程
        IntStream.range(0, 5).forEach(
                thread -> new Thread(() -> {
                    //每个线程存一个变量，然后再取这个变量
                    myDemo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println(Thread.currentThread().getName() + "--->" + myDemo.getContent());
                }).start()
        );
    }
}

运行结果：

 执行结果是很明显线程之间没有实现数据的隔离，线程0获取到了线程1的数据。这时我们考虑到的就是使用ThreadLocal实现并发情况下数据的相互隔离。

其中上面讲的ThreadLocal中的set()方法就是‘将变量绑定到当前线程中’；而get()方法就是‘获取当前线程绑定的变量’

将上面的示例改写成ThreadLocal的形式：

class MyDemo02 {

    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    private String content;

    public String getContent() {
        return threadLocal.get();
    }

    public void setContent(String content) {
        threadLocal.set(content);
    }

    public static void main(String[] args) {

        MyDemo02 myDemo02 = new MyDemo02();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    myDemo02.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("-------------------------");
                    System.out.println(Thread.currentThread().getName() + "--->" + myDemo02.getContent());
                }
            }).start();
        }
    }
}

运行结果：

从结果我们可以看到，每一个线程都有各自的local值，这就是TheadLocal的基本使用，是不是非常的简单。

那么为什么会在数据库连接的时候使用的比较多呢？

 

 

上面是一个数据库连接的管理类，我们使用数据库的时候首先就是建立数据库连接，然后用完了之后关闭就好了，这样做有一个很严重的问题，如果有1个客户端频繁的使用数据库，那么就需要建立多次链接和关闭，我们的服务器可能会吃不消，怎么办呢？如果有一万个客户端，那么服务器压力更大。

这时候最好使用ThreadLocal，因为ThreadLocal在每个线程中对连接会创建一个副本，且在线程内部任何地方都可以使用，线程之间互不影响，这样一来就不存在线程安全问题，也不会严重影响程序执行性能。是不是很好用。

  • 3.3 ThreadLocal Synchronized的区别

上面的程序可以改写成synchronized实现的方式，不过使用synchronized相当于加锁，在高并发情况下，只有获取锁的线程才能继续执行，未获取锁的线程只能循环等待尝试获取锁，导致程序失去了并发性

/**
 * 使用synchronized
 */
class MyDemo03 {

    private String content;


    public String getContent() {
        return content;
    }

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

    public static void main(String[] args) {
        MyDemo03 myDemo03 = new MyDemo03();

        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (MyDemo03.class) {
                        myDemo03.setContent(Thread.currentThread().getName() + "的数据");
                        System.out.println("-------------------------");
                        System.out.println(Thread.currentThread().getName() + "--->" + myDemo03.getContent());
                    }

                }
            }).start();
        }
    }
}

 执行结果：

从结果可以看出, 加锁确实可以解决这个问题，但是在这里我们强调的是多线程数据隔离的问题，并不是多线程共享数据的问题, 在这个案例中使用synchronized关键字是不合适的。

说白了，synchronized可以实现隔离线程的需求，由于处理中需要加锁才能实现资源的共享，导致线程只能排队执行，降低了程序在高并发环境下的执行效率。所以使用ThreadLocal在多线程环境下实现数据的隔离性具有更高的并发性能

总结：

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

 synchronizedThreadLocal
原理同步机制采用“以时间换空间”的方式，只提供了一份变量，让不同的线程排队访问ThreadLocal采用’以空间换时间’的方式, 为每一个线程都提供了一份变量的副本,从而实现同时访问而相不干扰
侧重点多个线程之间访问资源的同步多线程中让每个线程之间的数据相互隔离

以时间换空间 -> 即加锁方式，某个区域代码或变量只有一份节省了内存，但是会形成很多线程等待现象，因此浪费了时间而节省了空间。（牺牲时间访问冲突）
以空间换时间 -> 为每一个线程提供一份变量，多开销一些内存，但是线程不用等待，可以一起执行而相互之间没有影响。（牺牲空间来解决冲突）

总之，ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。

问题4、ThreadLocal源码分析？

  截止到现在相信ThreadLocal对于大家来说已经不再陌生了，接下来就让我深究ThreadLocal的源码是如何设计的。

  在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的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量。
  • 当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。

☆ ThreadLocal常用的方法有这几个：

方法声明描述
ThreadLocal() 创建ThreadLocal对象
public void set( T value)设置当前线程绑定的局部变量
public T get() 获取当前线程绑定的局部变量
public void remove() 移除当前线程绑定的局部变量
  1. 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 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
	/**
     *创建当前线程Thread对应维护的ThreadLocalMap 
     *
     * @param t 当前线程
     * @param firstValue 存放到map中第一个entry的值
     */
	void createMap(Thread t, T firstValue) {
        //这里的this是调用此方法的threadLocal
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

剖析：从源码中我们可以看到 首先获取当前线程t，然后调用getMap(t) 方法传入当前线程t 获取ThreadLocalMap；然后再判断ThreadLocalMap 存在，则将当前线程对象t作为key，要存储的对象作为value存到ThreadLocalMap里面；如果不存在就使用createMap(Thread t, T firstValue)方法初始化一个。

 

到这相信你会有几个疑惑了，ThreadLocalMap是什么，getMap方法又是如何实现的。带着这些问题，继续往下看。先来看ThreadLocalMap。

 

static class ThreadLocalMap {

    static class Entry extends WeakReference<ThreadLocal<?>> {//这个弱引用是关键点
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    .....//省略大部分代码
}

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

我们可以看到ThreadLocalMap其实就是ThreadLocal的一个静态内部类，里面定义了一个Entry来保存数据，而且还是继承的弱引用。在Entry内部使用ThreadLocal作为key，使用我们设置的value作为value。

调用当期线程t，返回当前线程t中的成员变量threadLocals。而threadLocals其实就是ThreadLocalMap。

  2. get()方法源码：

    /**
     * 返回当前线程中保存ThreadLocal的值
     * 如果当前线程没有此ThreadLocal变量，
     * 则它会通过调用{@link #initialValue} 方法进行初始化值
     *
     * @return 返回当前线程对应此ThreadLocal的值
     */
    public T get() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        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();
}

源码剖析：首先获取当前线程t，然后调用getMap()方法获取一个ThreadLocalMap，如果map不为null，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entry e，然后在判断e 是否为空，如果e不为null，则返回e.value；

​ 如果Map为空或者e为空，则通过initialValue() 函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map。

那么初始化setInitialValue()是什么样的呢？

 

   /**
     * 初始化
     *
     * @return the initial value 初始化后的值
     */
    private T setInitialValue() {
        // 调用initialValue获取初始化的值
        // 此方法可以被子类重写, 如果不重写默认返回null
        T value = initialValue();
        // 获取当前线程对象
        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);
        // 返回设置的值value
        return value;
    }

源码剖析：首先是对Value初始化，然后获取当前线程t， 然后再调用getMap()方法获取ThreadLocalMap，如果map不为空，则将当前线程t作为key，初始化的value为值存储ThreadLocalMap中；如果为空则使用createMap()方法初始化一个。

在setInitialValue()方法中，有一个initialValue()方法进行值得初始化，那么initialValue()源码是什么样的呢？我们来看一下

/**
  * 返回当前线程对应的ThreadLocal的初始值
  
  * 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
  * 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
  * 通常情况下，每个线程最多调用一次这个方法。
  *
  * <p>这个方法仅仅简单的返回null {@code null};
  * 如果程序员想ThreadLocal线程局部变量有一个除null以外的初始值，
  * 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
  * 通常, 可以通过匿名内部类的方式实现
  *
  * @return 当前ThreadLocal的初始值
  */
protected T initialValue() {
    return null;
}

 

其实很简单哈哈哈哈。此方法的作用是 返回该线程局部变量的初始值。

（1） 这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。

（2）这个方法缺省实现直接返回一个null。

（3）如果想要一个除null之外的初始值，可以重写此方法。（备注： 该方法是一个protected的方法，显然是为了让子类覆盖而设计的）

3.remove()方法

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

剖析：方法很简单就是获取当前线程t， 然后调用getMap()方法获取ThreadLocalMap，并且判断map是否为空，如果不是空就直接调用ThreadLocalMap的remove()方法直接移除当前ThreadLocal对象对应的entry。

那么 下面看一下ThreadLocalMap中remove()方法的源码:

private void remove(ThreadLocal<?> key) {
    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;
        }
    }
}

 

源码就介绍到这里。

问题5、ThreadLocal内存泄漏问题？

这个问题是ThreadLocal最需要注意的问题，稍后会专门设计一篇博客讲述ThreadLocal内存泄漏的问题。详情见ThreadLocal之内存泄漏

文章如有错误之处欢迎指正，如果该文章对你有帮助，麻烦给予关注，点赞！！！

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

zuihongyan518
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
有关ThreadLocal的面试题你真的懂了吗
08-25
主要介绍了面试题ThreadLocal,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
ThreadLocal高频面试题
公号：黎杜编程
08-11 3186
前言无论是工作还是面试中，我们都会跟ThreadLocal打交道，今天就跟大家聊聊ThreadLocal的八个关键知识点哈~ThreadLocal是什么?为什么要使用ThreadLocal一个ThreadLocal的使用案例ThreadLocal的原理为什么不直接用线程id作为ThreadLocalMap的key为什么会导致内存泄漏呢？是因为弱引用吗？Key为什么要设计成...
ThreadLocal详解（附面试题）
2401_84103549的博客
05-01 675
是JDK java.lang 包下的一个类，ThreadLocal 为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量，并且不会和其他线程的局部变量冲突，实现了线程间的数据隔离。ThreadLocal 的应用场景主要有以下几个方面:保存线程上下文信息，在需要的地方可以获取线程间数据隔离数据库连接。
ThreadLocal常见面试题
@开弓没有回头箭的博客
08-07 802
ThreadLocal 的原理是在Thread内部有一个ThreadLocalMap的集合对象，他的key是ThreadLocal，value就是你要存储的变量副本，不同线程的 ThreadLocalMap 是隔离开的，如果ThreadLocal 变量是非 static 的话，就会使得每次生成实例都要生成不同的 ThreadLocal 对象，虽然这样程序不会有什么异常，但是会造成内存资源的浪费。但是ThreadLocal 变量定义成staic也有一定的缺点，就是在线程池的情况下更容易造成内存泄露。
ThreadLocal经典面试题【11题】
weixin_45985053的博客
08-21 573
ThreadLocal经典面试题【11题】
面试题 - ThreadLocal详解
秋夫人
09-30 1万+
目录（jdk1.8） 一、什么是ThreadLocal 二、ThreadLocal怎么用 三、ThreadLocal的原理 四、ThreadLocal源码分析 1.ThreadLocal的内部属性 2.ThreadLocal 之 set() 方法 3.ThreadLocal 之 get() 方法 4.TreadLocal的remove方法 5.内部类ThreadLocalMap的基本结构和源码分析 5.1先看成员和结构部分 5.2接着看ThreadLocalMap的构造函数 5.
从面试中的问题分析ThreadLocal
08-25
Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。 ThreadLocal类的核心方法 ------------------------- ### 1. get()方法 get()方法用于获取当前线程的副本变量值。该...
大公司的Java面试题集
最新发布
05-06
6. **数据结构与算法**：虽然Java面试不侧重算法题，但基础的数据结构如数组、链表、栈、队列、树（二叉树、红黑树）等需要掌握。对于常见的排序和查找算法，如冒泡排序、快速排序、二分查找等，面试者应能够手写...
2021最新Java面试题合集.zip
02-22
Java作为一门广泛使用的编程语言，其面试题涵盖了众多领域，包括基础、并发编程、网络、虚拟机、大数据处理以及各种框架。以下是对这些面试题集合的详细解析： 1. **BIO, NIO, AIO, Netty面试题 35道**： - **BIO*...
2023最新Java面试题
07-30
本资源“2023最新Java面试题”旨在帮助求职者应对各种Java相关职位的面试挑战，涵盖了许多关键领域的知识点。 一、集合框架 Java集合框架是存储和管理对象的重要工具。面试中可能会涉及到ArrayList、LinkedList、...
面试之ThreadLocal
jike11231的博客
05-22 3030
在面试环节中，考察"ThreadLocal"的理解十分必要。常用的提问方式如下： “知道ThreadLocal吗？” “讲讲你对ThreadLocal的理解” 当然了，也有面试官会慢慢引导到这个话题上，比如提问“在多线程环境下，如何防止自己的变量被其它线程篡改”等等。 这篇文章主要从以下几个角度来分析理解 1、ThreadLocal是什么 2、ThreadLocal源码分析 3、ThreadLocal内存泄漏问题及解决方案 一、ThreadLocal是什么 ThreadLocal即本地线程变量，它填充的变量
ThreadLocal面试题
weixin_47871772的博客
08-20 230
答：ThreadLocal是Java中的一个类，它的作用是为每个线程提供一个独立的变量副本。这样，每个线程都可以独立地改变自己的副本，而不会影响其他线程的副本。数据库连接池：在多线程环境下，每个线程都需要访问数据库，使用ThreadLocal可以避免多个线程共享同一个数据库连接，提高性能。事务管理：在分布式系统中，多个服务之间需要协同完成一个事务。使用ThreadLocal可以为每个服务创建一个独立的事务上下文，避免事务冲突。用户会话管理：在Web应用中，每个用户请求都会创建一个新的会话。
深挖ThreadLocal
热门推荐
逆风奔跑。。不要去考虑什么天赋异禀，一切都来自经历和渴望。
04-22 42万+
ThreadLocal是什么 早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。 ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它
ThreadLocal常见面试题剖析
Venus's Blog
05-30 4万+
ThreadLocalMap 和HashMap区别 HashMap 的数据结构是数组+链表 ThreadLocalMap的数据结构仅仅是数组 HashMap 是通过链地址法解决hash 冲突的问题 ThreadLocalMap 是通过开放地址法来解决hash 冲突的问题 HashMap 里面的Entry 内部类的引用都是强引用 ThreadLocalMap里面的Entry 内部类中的key 是弱引用，value 是强引用 链地址法 这种方法的基本思想是将所有哈希地址为i的元素构成一个称为同义词链的单链表，并
ThreadLocal夺命11连问
lisu061714112的专栏
05-15 1257
前言 前一段时间，有同事使用ThreadLocal踩坑了，正好引起了我的兴趣。 所以近期，我抽空把ThreadLocal的源码再研究了一下，越看越有意思，发现里面的东西还真不少。 我把精华浓缩了一下，汇集成了下面11个问题，看看你能顶住第几个？ 1. 为什么要用ThreadLocal? 并发编程是一项非常重要的技术，它让我们的程序变得更加高效。 但在并发的场景中，如果有多个线程同时修改公共变量，可能会出现线程安全问题，即该变量最终结果可能出现异常。 为了解决线程安全问题，JDK出现了很多技术手段，比如：使
ThreadLocal详解（附面试题），java面试常考的编程题
2401_84411018的博客
04-18 1137
外链图片转存中…(img-7c5Ee3lP-1713428605461)]
threadLocal 面试题总结
qq_36098514的博客
04-08 3584
文章目录 目录 系列文章目录 文章目录 前言 一、ThreadLocal是什么？ 二、Thread，ThreadLocal，ThreadLocalMap这三者是什么关系 1.类之间的关系 2.既然这个Entry的key为一个弱引用的threadLocal，那会有什么问题 3.那么作者是怎么解决这个问题的呢 总结 前言 3月份在面试中总结的java基础多线程ThreadLocal面试题，在这里总结一下 提示：以下是本篇文章正文内容，下面案例可供参考 ...
Java编程中的ThreadLocal
servepeople的博客
08-13 297
java.lang.ThreadLocal类 它是线程的局部变量 每一个使用ThreadLocal变量的线程，都会持有其一个副本。线程间的副本不会冲突 每个线程都保持一个对其线程局部变量副本(ThreadLocal对象)的隐式引用 通过ThreadLocal存取的数据,总是与当前线程相关,从而为多线程环境提供了一种隔离机制 实现的思路很简单，在ThreadLocal类中有一个Map...
面试题——ThreadLocal相关
qq_41423755的博客
12-11 81
ThreadLocal，即线程本地。如果创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个，多个线程操作这个变量的时候，实际是操作自己本地内存里面的变量，从而起到线程隔离的作用，避免了线程安全问题。
"Java面试题：SpringMVC原理与ThreadLocal应用
Java面试题.docx中介绍了SpringMVC的运行原理，包括以下几个步骤：客户端请求首先提交到DispatcherServlet，然后由DispatcherServlet控制器查询HandlerMapping，找到并分发到指定的Controller中，Controller调用业务...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值