ThreadLocal相关知识点

最新推荐文章于 2024-06-29 11:59:11 发布
最新推荐文章于 2024-06-29 11:59:11 发布
阅读量257 收藏 2
点赞数 2
分类专栏： Java后端 文章标签： java-ee java 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50216991/article/details/124119102
版权

一.ThreadLocal的两大使用场景

典型场景1

每个线程需要一个独享的对象(通常是工具类，典型需要使用的类有SimpleDateFormat和Random)，这个对象的特点通常是工具类，这个工具类由于它本身不是线程安全的，所以有多个线程共享同一个静态工具类的话，会有很大风险的，所以需要用到ThreadLocal来帮我们每个线程都创建一个独享的对象，而线程和线程之间呢拥有的工具类是不同的示例，所以之间并不会影响。

第一个场景主要强调每个Thread内有自己的示例副本，不共享。举个例子，如果教材只有一本，一如果多个人一起做笔记，则教材会一团糟，这也就是我们说的线程安全问题。但是如果每个都复制一本教材，就不会出现此问题。

下面先来模拟两个线程分别使用自己的SimpleDateFormat，两个线程都打印日期：

package threadlocal;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 描述：     两个线程打印日期
 */
public class ThreadLocalNormalUsage00 {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                String date = new ThreadLocalNormalUsage00().date(10);
                System.out.println(date);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                String date = new ThreadLocalNormalUsage00().date(104707);
                System.out.println(date);
            }
        }).start();
    }

    //传入秒数，转化成日期格式
    public String date(int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return dateFormat.format(date);
    }
}

运行：
在这里插入图片描述
到这里，你可能还觉得比较圆满，功能都没有问题。

如果说延伸出30个线程，那就有30个线程和30个SimpleDateFormat，写法如下：

package threadlocal;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 描述：     10个线程打印日期
 */
public class ThreadLocalNormalUsage01 {

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 30; i++) {
            int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage01().date(finalI);
                    System.out.println(date);
                }
            }).start();
            Thread.sleep(100);
        }

    }

    //传入秒数，转化成日期格式
    public String date(int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return dateFormat.format(date);
    }
}

到这里，也是依旧能够正常运行的，但是写法有些丑陋。假设有10000个，甚至更多，那么开销将会非常大。但是当需求变成成千上万个时，那必然要用线程池，否则消耗太多内存。我们再对代码进行升级：

package threadlocal;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 描述：     1000个打印日期的任务，用线程池来执行
 */
public class ThreadLocalNormalUsage02 {

    //用一个固定数量的线程池
    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage02().date(finalI);
                    System.out.println(date);
                }
            });
        }
        threadPool.shutdown();
    }

    //传入秒数，转化成日期格式
    public String date(int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return dateFormat.format(date);
    }
}

但是在这里有一个非常致命的缺点，1000个任务，我们的线程只有10个，但是还是会创建1000个SimpleDateFormat对象。相当于这些对象创建了又销毁，创建了又销毁，因为我们是在date方法里面创建的SimpleDateFormat对象。

那假如我们把SimpleDateFormat单独写出来，只写一个的话，又会如何？

package threadlocal;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 描述：     1000个打印日期的任务，用线程池来执行
 */
public class ThreadLocalNormalUsage03 {

    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
    static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage03().date(finalI);
                    System.out.println(date);
                }
            });
        }
        threadPool.shutdown();
    }

    public String date(int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        return dateFormat.format(date);
    }
}

运行后，问题就来了。会发现出现了相同的时间，这明显是不正确的。
在这里插入图片描述
那，这是为什么呢？
这实际上是因为当所有线程都公用一个SimpleDateFormat对象的时候，它发生了线程安全问题。
在这里插入图片描述
在这里，所有的线程都指向了SimpleDateFormat对象，而且这个对象本身并不是线程安全的，所以在不同的线程在共同使用这同一个对象的时候，就已经发生了线程安全问题。那么改这么办呢？我们其实可以加锁来解决这个问题。

package threadlocal;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 描述：     加锁来解决线程安全问题
 */
public class ThreadLocalNormalUsage04 {

    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
    static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage04().date(finalI);
                    System.out.println(date);
                }
            });
        }
        threadPool.shutdown();
    }

    public String date(int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        String s = null;
        synchronized (ThreadLocalNormalUsage04.class) {
            s = dateFormat.format(date);
        }
        return s;
    }
}

下面来介绍一下更好的解决方案—ThreadLocal来实现一下这个功能：

package threadlocal;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 描述：     利用ThreadLocal，给每个线程分配自己的dateFormat对象，保证了线程安全，高效利用内存
 */
public class ThreadLocalNormalUsage05 {

    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage05().date(finalI);
                    System.out.println(date);
                }
            });
        }
        threadPool.shutdown();
    }

    public String date(int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
//        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat dateFormat = ThreadSafeFormatter.dateFormatThreadLocal2.get();
        System.out.println(
                Thread.currentThread().getName() + ThreadSafeFormatter.dateFormatThreadLocal);
        SimpleDateFormat simpleDateFormat = ThreadSafeFormatter.dateFormatThreadLocal.get();
        System.out.println(Thread.currentThread().getName() + simpleDateFormat.toString());
        System.out.println(
                Thread.currentThread().getName() + System.identityHashCode(simpleDateFormat));

        return dateFormat.format(date);
    }
}

class ThreadSafeFormatter {

	//写法1
    public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };
	//写法2
    public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal2 = ThreadLocal
            .withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
}

典型场景2

每个线程内需要保存全局变量(例如拦截器中获取用户信息)，可以让不同方法直接使用，避免参数传递的麻烦。
在这里插入图片描述
在这里插入图片描述
下面来演示场景二的用法：

package threadlocal;

/**
 * 描述：     演示ThreadLocal用法2：避免传递参数的麻烦
 */
public class ThreadLocalNormalUsage06 {

    public static void main(String[] args) {
        new Service1().process("");

    }
}

class Service1 {

    public void process(String name) {
        User user = new User("超哥");
        UserContextHolder.holder.set(user);
        new Service2().process();
    }
}

class Service2 {

    public void process() {
        User user = UserContextHolder.holder.get();
        ThreadSafeFormatter.dateFormatThreadLocal.get();
        System.out.println("Service2拿到用户名：" + user.name);
        new Service3().process();
    }
}

class Service3 {

    public void process() {
        User user = UserContextHolder.holder.get();
        System.out.println("Service3拿到用户名：" + user.name);
        UserContextHolder.holder.remove();
    }
}
// 定义ThreadLocal
class UserContextHolder {

    public static ThreadLocal<User> holder = new ThreadLocal<>();


}

class User {

    String name;

    public User(String name) {
        this.name = name;
    }
}

我们新建很多的Service类来模拟User对象参数传递。

二.ThreadLocal的作用和主要方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

害恶细君
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
有关ThreadLocal的面试题你真的懂了吗
08-25
"ThreadLocal相关知识点总结" ThreadLocal是Java中的一种机制，用于在多线程环境中保存线程上下文信息，并且提供了一种解决多线程程序并发问题的思路。下面是对ThreadLocal的主要知识点的总结： 1. ThreadLocal的...
从面试中的问题分析ThreadLocal
08-25
"ThreadLocal知识点详解" ThreadLocal是一个本地线程副本变量工具类，主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个...
ThreadLocal相关
weixin_30834783的博客
08-14 52
一.概述： 　　ThreadLocal是用于解决不同线程在共享同一个，且值一旦初始化就不会改变的共享变量时，可能会出现的线程安全问题。它的解决思路就是，为不同的线程保存一个共享变量的副本，这样每个线程在使用的时候，实际上使用的是保存在自己内部的共享变量的副本，自然相互之间不会有影响。这样做的好处就是，当某个变量在某个线程里面需要重复使用多次的时候，而又不希望每次都去创建一个新的（毕竟浪费时间），...
java小名_面试题----java
weixin_39898550的博客
02-22 63
ThreadLock不同的线程，可以使用同一个ThreadLocal，同一个线程需要使用不同的ThreadLoca简单使用static final ThreadLocal sThreadLocal = new ThreadLocal();sThreadLocal.set()sThreadLocal.get()threadlocal的作用负责访问和维护ThreadLocalMap.ThreadLoc...
ThreadLocal 相关
xiao_Hebut的博客
03-26 143
一、ThreadLocal简介 多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变...
threadLocal
03-20
以上内容涵盖了从ThreadLocal原理到其在实际开发中的应用，以及相关的多线程、并发编程、HTTP通信等知识点。通过阅读和理解这些资料，开发者可以深化对ThreadLocal的理解，并将其有效地应用于项目中。
JAVA核心知识点整理(有效)
03-28
1. 目录 1. 2. 目录 .........................................................................................................................................................1 JVM ........................
ThreadLocal 相关知识点
斜月&三星
02-09 183
1.ThreadLocal 是什么？ ThreadLocal 是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，适用于各个线程不共享变量值的操作。 2. ThreadLocal 工作原理是什么？ TreadLocal 原理：每个线程的内部都维护了一个 Thread...
java之ThreadLocal相关
菜鸟园管理者
06-12 127
ThreadLocal 记录线程本地变量，生命周期与线程的生命周期相同 set()方法 public void set(T value) { // 获取的当前线程 Thread t = Thread.currentThread(); // 获取当前线程的ThreadLocalMap ThreadLocalMap map = getMap(t); // 将当前threadLocal实例作为key，值作为val存入map
ThreadLocal相关面试
高新富的博客
05-19 189
文章目录1.ThreadLocal是什么？2.ThreadLocal的工作原理？3.如何解决ThreadLocal的内存泄漏问题4.案例 1.ThreadLocal是什么？ 1.其实ThreadLocal跟Synchronized一样，都是一个为了解决变量变化问题，类似给变量加锁； 2.实际上使用了ThreadLocal，相当于对对本地线程中的变量或者变量对象的引用copy一份，这样就使得各个线程中 的变量和对象互不影响；这样各个线程在高并发场景下，适合各个线程不共享变量值的操作; 3.ThreadLo
ThreadLocal相关知识点总结学习
仰望星空
12-13 130
ThreadLocal实现原理
ThreadLocal 详解
热门推荐
ant的博客
04-19 2万+
ThreadLocal 概述 ThreadLocal类用来提供线程内部的局部变量，不同的线程之间不会相互干扰 这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量 在线程的生命周期内起作用，可以减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度 使用 常用方法 方法名 描述 ThreadLocal() 创建ThreadLocal对象 public void set( T value) 设置当前线程绑定的局部变量 publ
【JavaEE进阶】Spring AOP使用篇
m0_73648729的博客
06-27 819
创建一个注解类(和创建Class文件一样的流程, 选择Annotation就可以了)代码简单说明, 了解即可, 不做过多的解释1. @Target 标识了 Annotation 所修饰的对象范围, 及该注解可以用在什么地方.常用取值:ElementType.TYPE: 用于描述类, 接口(包括注解类型)或 enum 声明ElementType.METHOD: 描述方法ElementType.PARAMETER: 描述参数ElementType.TYPE_USE: 可以标注任意类型。
【JavaEE】Spring Boot 统一功能处理
m0_74105656的博客
06-25 644
拦截器,统一结果返回,统一异常处理
配置系统PATH环境变量
最新发布
weixin_44626980的博客
06-29 428
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
Java面试题:Redis为什么速度快
qq_55630615的博客
06-25 634
因为Redis是纯内存操作,执行速度非常快,性能的瓶颈是网络延迟而非执行速度I/O多路复用模型主要就是实现了高效的网络请求。
ThreadLocal面试题
05-24
ThreadLocal 是一个 Java 中的类，它提供了一种线程本地存储的机制。...对于这些问题，建议你提前做好准备，掌握相关的知识点和面试技巧，以便在面试中能够流利地回答问题，并且表达自己的观点和思路。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

害恶细君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值