ThreadLocal详解

最新推荐文章于 2023-08-25 15:12:54 发布
最新推荐文章于 2023-08-25 15:12:54 发布
阅读量271 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46008168/article/details/108920354
版权

在这里插入图片描述
在这里插入图片描述
第一种应用场景主要解决的是，工具类线程不安全，需要去解决工具类线程不安全的问题。
第二种应用场景主要解决的是，参数传递麻烦的问题。
在这里插入图片描述
下面进行的是SimpleDateFormat进行之路
在这里插入图片描述

package threadlocalpratice;

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

public class ThreadLocalNormalUsage00 {
    public String data(int second){
        //参数的单位是毫秒,从1970-01-01 00:00:00开始
        Date date = new Date(1000 * second);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        return simpleDateFormat.format(date);
    }

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

这是两个线程用SimpleDateFormat

package threadlocalpratice;

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

/**
 * 1000个打印日期的任务，用线程池来执行
 */
public class ThreadLocalNormalUsage01 {
    public static ExecutorService threadPool =  Executors.newFixedThreadPool(10);
    public String data(int second){
        //参数的单位是毫秒,从1970-01-01 00:00:00开始
        Date date = new Date(1000 * second);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        return simpleDateFormat.format(date);
    }

    public static void main(String[] args) {

        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            //将任务提交到线程池中
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String data = new ThreadLocalNormalUsage01().data(1000 + finalI);
                    System.out.println(data);
                }
            });
        }
        threadPool.shutdown();

    }
}

这是1000个线程，使用线程池的方法来提高效率。这里的话发现SimpleDateFormat工具类，在每个线程中都被创建出来，浪费资源。

package threadlocalpratice;

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

/**
 * 1000个打印日期的任务，用线程池来执行
 * 由于1000个线程共用一个simpleDateFormat对象，会浪费，
 * 所以把它写在类对象上。让1000个线程共用一个SimpleDateFormat对象
 * 发现共用一个SimpleDateFormat会导致线程不安全
 */
public class ThreadLocalNormalUsage02 {
    public static ExecutorService threadPool =  Executors.newFixedThreadPool(10);
    static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

    public String data(int second){
        //参数的单位是毫秒,从1970-01-01 00:00:00开始
        Date date = new Date(1000 * second);
        return simpleDateFormat.format(date);
    }

    public static void main(String[] args) {

        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            //将任务提交到线程池中
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String data = new ThreadLocalNormalUsage02().data(1000 + finalI);
                    System.out.println(data);
                }
            });
        }
        threadPool.shutdown();
    }
}

这里让1000个线程都共用一个SimpleDateFormat对象。

package threadlocalpratice;

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 simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

    public String data(int second) {
        //参数的单位是毫秒,从1970-01-01 00:00:00开始
        Date date = new Date(1000 * second);
        String s = null;
        //选取simpleDateFormat来作为同步监控器
        synchronized (simpleDateFormat) {
           s = simpleDateFormat.format(date);
        }
        return s;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            //将任务提交到线程池中
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String data = new ThreadLocalNormalUsage03().data(1000 + finalI);
                    System.out.println(data);
                }
            });
        }
        threadPool.shutdown();
    }
}

上面代码用加锁的方法来解决线程不安全的问题。但是，发现加锁的时候，效率比较低了。
在这里插入图片描述
给每一个线程都添加ThreadLocal 就是复制一份副本。

package threadlocalpratice;

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

/**
 * 1000个打印日期的任务，用线程池来执行
 * 由于1000个线程共用一个simpleDateFormat对象，会浪费，
 * 使用ThreadLocal方法，由于只有10个线程，所以，其实只要同一个simpleDateFormat对象
 * 复制9份就可以了
 *
 */
public class ThreadLocalNormalUsage05 {
    public static ExecutorService threadPool =  Executors.newFixedThreadPool(10);
     ThreadLocal<SimpleDateFormat> simpleDateFormat = new ThreadLocal(){
        @Override
        protected SimpleDateFormat initialValue(){
            return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        }
    };

    public String data(int second){
        //参数的单位是毫秒,从1970-01-01 00:00:00开始
        Date date = new Date(1000 * second);
        return simpleDateFormat.get().format(date);
    }

    public static void main(String[] args) throws InterruptedException {
        HashSet set = new HashSet();
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            //将任务提交到线程池中
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    String data = new ThreadLocalNormalUsage05().data(1000 + finalI);
                    System.out.println(data);
                    set.add(data);
                }
            });
        }
        threadPool.shutdown();
        Thread.sleep(2000);
        System.out.println(threadPool.isTerminated());
        System.out.println(set.size());
    }
}

在这里插入图片描述
ThreadLocal 用途二：
在这里插入图片描述
在这里插入图片描述
传参的过程过于麻烦。不合适。
目标：每个线程内需要保存全局变量，可以让不同方法直接使用，避免参数传递的麻烦。
在这里插入图片描述
假设用UserMap
在这里插入图片描述
但是，这个方法也有问题：
当多线程同时工作时，我们需要保证线程安全，可以用synchronized,也可以用ConcurrentHashMap,但是，无论使用什么，都会对性能有所影响。
用ThreadLocal 不会影响性能
在这里插入图片描述
在这里插入图片描述

package threadlocalpratice;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 演示ThreadLocal的应用场景2，进行数据的传输
 */
public class ThreadLocalUsage06 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {

            int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    new Service1( " " + finalI).process();
                }
            });
        }
        threadPool.shutdown();

    }
}

class Service1 {
    User user;
    public Service1(String name){
         user = new User(name);
    }

    public void process() {

        //对对象中的数据进行设置
        UserContextHolder.holder.set(user);
        new Service2().process();
        new Service3().process();
    }
}

class Service2{
    public void process(){
        //这时候就可以得到User了
        User user = UserContextHolder.holder.get();
        System.out.println( user.name +" Service2拿到的user " + user.name);
    }
}
class Service3{
    public void process(){
        //这时候就可以得到User了
        User user = UserContextHolder.holder.get();
        System.out.println( user.name + " Service3拿到的user " + user.name);
    }
}
class UserContextHolder {
    //使用方式2时，不需要进行初始化
    public static ThreadLocal<User> holder = new ThreadLocal<>();
}

class User {
    String name;

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

总结
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
ThreadLocal的好处：
在这里插入图片描述
在这里插入图片描述
源码分析：
在这里插入图片描述
在这里插入图片描述
每一个Thread线程中，都会有一个ThreadLocalMap类， 里面会存储很多ThreadLocal 为什么需要map因为一个线程中可能会有多个ThreadLocal。
ThreadLocal:方法
在这里插入图片描述
下面在源码中进行查看，再没重写之前默认返回为null，重写后，调用get方法时就会执行该方法。
在这里插入图片描述
在这里插入图片描述
如果第一次调用get方法时，就会调用InitialValue。如果，之前调用了set方法，那么就不会去调用initialValue方法了。
原因如下：
在这里插入图片描述
由于map中不为null 因为你给它设置了值，所以，它就不会执行setInitialValue方法了。而拿到的result是set设置进行的。
在这里插入图片描述
在这里插入图片描述

分析get方法：
在这里插入图片描述
t代表当前线程：
在这里插入图片描述
getMap返回的是当前线程的threadLocals，这个threadLocals代表的是每个线程都有的ThreadLocalMap
在这里插入图片描述
如果map为空，就是没有set过 那么就是执行setInitialValue方法，这个方法代表的就是初始化InitialValue。如果map不为空（已经初始化过或者set过）。注意，这个map以及map中的key和value都是保存在线程中的，而不是保存在ThreadLocal中。
如果不为null 就以当前的ThreadLocal作为key（this）去找value，然后来进行返回。
下面分析的是set方法
在这里插入图片描述
相比之下，set就简单得多了：如果map不为空，那么就直接加入。如果为空，就新建，新建如下：在这里插入图片描述
remove：方法
在这里插入图片描述
这里先获取ThreadLocal中的ThreadLocalMap 如果这个map不为空，就进行删除，但是，它不会把所有的都删除，它会把删除this，这个this代表的是调用它的ThreadLocal这个key所代表的key-value键值对。只能删除一个。
在这里插入图片描述
ThreadLocalMap类是Thread里面的一个成员变量。threadLocals ,类型是ThreadLocalMap
在这里插入图片描述
其有一个属性是：
在这里插入图片描述
这个可以认为是一个map，键值对：
键：ThreadLocal
值：实际需要的成员变量，比如uesr或者simpleDateFormat对象
但是，它和map有一点不同，hashmap碰到冲突会用链表的方法，或者红黑树，而它是进行找空的值，而进行填入。
总结一下
在这里插入图片描述
在每一个Thread中，都是会有一个ThreadLocalMap,里面会有一个个键值对。存入的key是ThreadLocal 类型，值的话，所有类型都可以。但调用get时，如果在ThreadLocalMap中没有，就会根据初始化函数进行创建。
ThreadLocal注意点
1.内存泄漏
在这里插入图片描述
在这里插入图片描述
这个key ThreadLocal代表的是弱引用。
而 value = v 代表的就是强引用；
在这里插入图片描述
但是，
在这里插入图片描述
因为value和Thread之间是强引用。所以，比如说我创建了十个对象，可以已经不用了，但是，还在内存中。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
就是说，随着时间的增加，弱引用会被垃圾回收栈回收，但是，强引用会一直都在。这个value会一直在内存中。
在这里插入图片描述
在线程关闭之前要进行线程回收。不在使用的时候，主动调用remove（）方法
在这里插入图片描述
ThreadLocal 碰到的空指针问题
package threadlocalpratice;

public class ThreadLocalNPE {
ThreadLocal longThreadLocal = new ThreadLocal<>();
public void set(){
longThreadLocal.set(Thread.currentThread().getId());
}
public long get(){
return longThreadLocal.get();
}

public static void main(String[] args) {
    ThreadLocalNPE threadLocalNPE = new ThreadLocalNPE();
    //这行语句会导致空指针异常，理论上，ThreadLocalNPE.longThreadLocal.get返回的是null。不会返回空指针异常的
    System.out.println(threadLocalNPE.get());

    Thread thread = new Thread(
            new Runnable() {
                @Override
                public void run() {
                    threadLocalNPE.set();
                    long l = threadLocalNPE.get();
                    System.out.println(l);
                }
            }
    );
    //子线程的id
    thread.start();
}

}
这里会导致空指针异常：
原因如下：
在这里插入图片描述
longThreadLocal.get()返回的是null，是Long类型的，但是想给他转化为long类型，所以，才导致了空指针类型报错。解决措施：只要把long改成Long即可，就不会有装箱拆箱问题了。
注意点：
在这里插入图片描述
在这里插入图片描述

weixin_46008168
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PyQt5多线程的执行和停止
03-18
实现三个线程同时执行，且可以单独关闭和运行，通过进度条实现可视化演示。
freemarker处理boolean的方法
xingtuyang的专栏
07-13 1万+
今天发现 freemarker的${}尽然不能显示boolean,太烂了hasNext:hasPrev:这么玩
Freemarker语法及使用方法
weixin_43768579的博客
04-14 530
1. 取值(插值)指令及适用类型： (1) ${var} 适用类型：java中常用的八大基本类型以及我们的String引用类型，但是，freemarker中boolean类型显示时true==yes false==no 示例： 在后台文件中定义变量 ...
freemarker 输出 Boolean 类型
justinytsoft的博客
09-19 1万+
Boolean类型不能使用isXxx，需要使用getXxx，因为Freemarker使用java会对isXxx映射返回boolean基本型，但是freemarker不支持基本类型boolean，会抛异常。 freemarker中输出时可以使用这种方式输出${xxx?string("true","flase")}当xxx为true时显示字符串true,否则为字符串false，当然true,fals
Java并发——ThreadLocal总结
BASK2311的博客
12-24 746
并发问题，有时候，可以用ThreadLocal方式来避免。ThreadLocal，顾名思义，就是线程自己的，独享的，就像线程栈是线程独享的一样。
ThreadLocal详解.md
10-31
学习ThreadLocal，了解其中的原理，以及学习其中的优点！避免坑点！！
java中ThreadLocal详解
07-27
详解java底层实现原理，ThreadLocal底层实现的数据结构，为什么不会导致内存泄露
04、导致JVM内存泄露的ThreadLocal详解-ev
最新发布
03-07
04、导致JVM内存泄露的ThreadLocal详解_ev04、导致JVM内存泄露的ThreadLocal详解_ev04、导致JVM内存泄露的ThreadLocal详解_ev04、导致JVM内存泄露的ThreadLocal详解_ev04、导致JVM内存泄露的ThreadLocal详解_ev04、...
2、导致JVM内存泄露的ThreadLocal详解
02-28
导致JVM内存泄露的ThreadLocal详解 为什么要有ThreadLocal ThreadLocal的使用 实现解析 引发的内存泄漏分析 错误使用ThreadLocal导致 线程不安全分析
Java并发编程学习八：ThreadLocal
weixin_41402069的博客
08-02 664
Java并发编程学习系列
freemarker
qq_35987023的博客
08-25 544
在 FreeMarker 中，可以使用list指令结合内置变量index和内置变量size来判断当前循环是否为最后一次循环。下面是一个示例程序，演示如何在 FreeMarker 中使用list指令和ifsize>在上述示例程序中，item_index表示当前循环的迭代次数。items?size表示列表的元素个数。我们使用判断当前循环是否为列表的最后一次循环，如果是，则输出 “The last item is: item”。除了使用if指令来判断最后一次循环，还可以使用if。
freeMarker读取布尔值，布尔值判断
热门推荐
无知人生，记录点滴
07-12 2万+
最近用到freeMarker， 也用到了布尔值，看到一篇文章中这样描述：在后台逻辑里，定义了布尔类型的变量 将该变量放进ModelMap model Boolean isAct = false； model.addAttribute("isACt", isAct); 在前端页面读取该值： &lt;input type="text" id="isAct" value="${isAct?string...
freemarker 基本语法
Mrzhang0419的专栏
06-10 1434
java里标准字符串比较需要 .equals() 方法，在freemarkder中进行了简化，字符串的比较方法和数字做到完全一样     xxx       xxx
freemarker判断布尔类型
l912943297的博客
05-18 7453
&lt;#if (booleanVal?string('yes', 'no'))=='yes'&gt;&lt;/#if&gt;
「图解」ThreadLocal 在并发问题中的应用
老男孩的架构路
07-14 247
前言到底什么是线程的不安全？为什么会存在线程的不安全？线程的不安全其实就是多个线程并发的去操作同一共享变量没用做同步所产生意料之外的结果。那是如何体现出来的呢？我们看下面的一个非常经典的例子:两个操作员同时操作同一个银行账户，A操作员存钱，100B操作员取钱50。我们看一下流程。两个操作员同时处理，没用做同步这个时候我们发现银行账户最终余额剩余950元，在我们想的最终结果银行账户应该剩余1000+100-50=1050元，在执行过程中我们没有加锁，最终导致了运行结果偏离预期。那么如何解决的？一般的解决措施就
不同请求获取到了相同的ThreadLocal值引起的问题
qq_29273683的博客
08-17 2602
问题：两个不同的请求，在获取ThreadLocal里保存的值时，获取到了相同的值。 原因：这两个请求共用了一个线程。 1、http1.1协议中的keep-alive是默认开启的，同一个会话中，有限的请求是共用一个长连接的。 2、tomcat默认使用线程池，所以一个线程的生命周期不能对等于一个请求的生命周期，线程池中的线程是可以被复用的。 解决方案： 1、保证每次都用新
看完就学会了FreeMarker 数据类型--乐字节Java
dirft_din的博客
07-03 553
FreeMarker 数据类型 Freemarker 模板中的数据类型由如下几种： 布尔型：等价于 Java 的 Boolean 类型，不同的是不能直接输出，可转换为字符串输出 日期型：等价于 java 的 Date 类型，不同的是不能直接输出，需要转换成字符串再输出 数值型：等价于 java 中的 int,float,double 等数值类型 有三种显示形式：数值型(默认)、货币型、百分比型 字符型：等价于 java 中的字符串，有很多内置函数 sequence 类型：等价于 java

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值