ThreadLocal相关知识

最新推荐文章于 2024-07-13 15:29:04 发布
最新推荐文章于 2024-07-13 15:29:04 发布
阅读量147 收藏
点赞数 1
分类专栏： Java 文章标签： java 多线程 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51392818/article/details/117160559
版权

ThreadLocal 的简单方法：

  • set() 将私有变量设置到线程中（也就是说每个线程有自己的变量）
  • get() 从线程中取私有变量的值
  • remove() 从线程中移除私有变量
public class ThreadLocalDemo68 {
    //创建线程的私有变量
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        //定义公共的任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    //得到线程名称
                    String tname = Thread.currentThread().getName();
                    System.out.println(tname +"设置值："+tname);
                    // 设置ThreadLocal
                    threadLocal.set(tname);
                    //执行打印
                    printThreadLocal();
                } finally {
                    //进行remove操作
                    threadLocal.remove();
                }

            }
        };

        Thread thread = new Thread(runnable,"线程1");
        thread.start();

        Thread thread1 = new Thread(runnable,"线程2");
        thread1.start();
    }
    private static void printThreadLocal() {
        //从Thread Local中获取值
        String result = threadLocal.get();
        System.out.println(Thread.currentThread().getName()+"取值："+result);
    }
}

线程1设置值：线程1
线程2设置值：线程2
线程1取值：线程1
线程2取值：线程2

ThreadLocal的高级方法：

  1. 用 initialValue 进行初始化
  2. withInitial 静态方法

用 initialValue 进行初始化的用法：


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

public class ThreadLocalDemo69 {

    //创建ThreadLocal的时候设置默认值
    //创建并设置默认值
    private static ThreadLocal<SimpleDateFormat> threadLocal =
            new ThreadLocal(){
                @Override
                //注意返回值的类型要和上面定义的创建的ThreadLocal的类型相同
                protected SimpleDateFormat initialValue() {
                    System.out.println("执行 initialValue 方法");
                    return new SimpleDateFormat("mm:ss");
                }
            };
            
    public static void main(String[] args) {
        //两个线程来演示

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Date date = new Date(1000);
                String s = threadLocal.get().format(date);
                System.out.println("线程1 时间格式化: "+ s);
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Date date = new Date(2000);
                String s = threadLocal.get().format(date);
                System.out.println("线程2 时间格式化: "+ s);
            }
        });
        t2.start();
    }
}


执行 initialValue 方法
执行 initialValue 方法
线程1 时间格式化: 00:01
线程2 时间格式化: 00:02

import java.util.Random;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo70 {
    private static ThreadLocal<Integer> threadLocal =
            new ThreadLocal() {
                @Override
                protected Integer initialValue() {
                    int num = new Random().nextInt(10);
                    System.out.println("执行了 initialValue 方法  生成了： "+num);
                    return num;
                }
            };
            
    public static void main(String[] args) {
        //一个线程池来进行演示

        //线程池里面只有一个线程
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,1,
                0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10));

        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                int num = threadLocal.get();
                System.out.println(Thread.currentThread().getName()+"得到值： "+num);
            }
        });

        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                int num = threadLocal.get();
                System.out.println(Thread.currentThread().getName()+"得到值： "+num);
            }
        });
    }
}


执行了 initialValue 方法  生成了： 2
pool-1-thread-1得到值： 2
pool-1-thread-1得到值： 2

可以发现，在线程池里面使用ThreadLocal方法的时候，当设置线程池里面线程的个数是1的时候，initialValue 方法只执行了一次，并且两取到的值相同，说明initialValue 是线程级别的方式，所以initialValue 的方法才只会执行一次。

withInitial 静态方法

import java.util.function.Supplier;

public class ThreadLocalDemo71 {

    //静态的高级的用法  withInitial
    //创建并初始化ThreadLocal
    private static ThreadLocal<String> threadLocal =
            ThreadLocal.withInitial(new Supplier<String>() {
                @Override
                public String get() {
                    System.out.println("执行了 withInitial 方法");
                    return Thread.currentThread().getName()+" Java";
                }
            });
            
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                String result = threadLocal.get();
                System.out.println("获取到的内容："+result);
            }
        };
        Thread t1 = new Thread(runnable,"线程1");
        t1.start();

        Thread t2 = new Thread(runnable,"线程2");
        t2.start();
    }
}

执行了 withInitial 方法
执行了 withInitial 方法
获取到的内容：线程1 Java
获取到的内容：线程2 Java

上面的静态的 withInitial 和 initialValue 的作用看起来没有什么区别，那么为什么还要有 withInitial 方法呢？

withInitial 在JDK1.8以后可以使用简单的初始化方式，如下：

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo72 {

    //withInitial  简单初始化版本
    //使用lamda表达式

    //创建并初始化ThreadLocal
    private static ThreadLocal<String> threadLocal =
            ThreadLocal.withInitial(()->"Java");

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,1,
                0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10));

        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                String result = threadLocal.get();
                System.out.println("得到结果 "+result);
            }
        });

        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                String result = threadLocal.get();
                System.out.println("得到结果 "+result);
            }
        });
    }
}

得到结果 Java
得到结果 Java

面试题：ThreadLocal 的初始化方法在什么情况下不执行
  答：当ThreadLocal中出现set方法之后，所有类型的初始化方法就不会执行了。
  原因：ThreadLocal在执行get方法的时候，才会去判断并调用初始化方法
ThreadLocal 的 get 方法的源码如下：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

下面举个例子来说明一下：

public class ThreadLocalDemo73 {

    //创建并初始化ThreadLocal
    private static ThreadLocal<String> threadLocal =
            new ThreadLocal() {
                @Override
                protected String initialValue() {
                    System.out.println("执行了 initialValue 方法");
                    return Thread.currentThread().getName()+" Java";
                }
            };
            /*ThreadLocal.withInitial(new Supplier<String>() {
                @Override
                public String get() {
                    System.out.println("执行了 withInitial 方法");
                    return Thread.currentThread().getName()+" Java";
                }
            });*/
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                /**
                 * 当ThreadLocal中既有set方法，又有初始化方法的时候，所有的初始化方法都不会执行！！！！
                 */
                threadLocal.set(Thread.currentThread().getName()+" 你好");
                String result = threadLocal.get();
                System.out.println("线程1 获取到的内容："+result);
            }
        };
        Thread t1 = new Thread(runnable,"线程1");
        t1.start();

        Thread t2 = new Thread(runnable,"线程2");
        t2.start();
    }
}

线程1 获取到的内容：线程2 你好
线程1 获取到的内容：线程1 你好

面试题：ThreadLocal只能存储一个值，但是为什么底层还要用ThreadLocalMap来实现存值取值？？
    因为ThreadLocalMap里面存储的是所有的线程的值，而不是一个线程的值。

ThreadLocal还是锁？
就看创建实例对象之后的复用率，复用率高就是ThreadLocal

ThreadLocal 经典使用场景：

  • 1.解决线程不安全的问题
  • 2.线程级别的数据传递（可以实现一定程度的解耦）

ThreadLocal缺陷：

  • 1.不可继承性（子线程不能继承主线程的私有变量）
  • 2.脏数据（一个程序的任务执行当中，读取了其他任务的数据）
  • 3.内存溢出

不可继承性演示：

public class ThreadLocalDemo76 {
    static ThreadLocal threadLocal = new ThreadLocal();

    public static void main(String[] args) {
        //在主线程里面设置值
        threadLocal.set("Java");
        
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("获取值："+threadLocal.get());
            }
        });
        t1.start();
    }
}

在子线程里面获取不到主线程的值

获取值：null

解决不可继承性的问题的方法： InheritableThreadLocal()

public class ThreadLocalDemo77 {
    //创建可以继承的ThreadLocal
    private static ThreadLocal threadLocal = new InheritableThreadLocal();

    public static void main(String[] args) {
        //在主线程里面设置值
        threadLocal.set("Java");

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("获取值："+threadLocal.get());
            }
        });
        t1.start();
    }
}

获取值：Java

下面的代码不能实现在线程2里面得到线程1设置的值，因为线程1和线程2不是父子类关系，而上面的main函数和t1线程是父子类关系，所以使用 InheritableThreadLocal 实现的 ThreadLocal 可以得到父类的值。


public class ThreadLocalDemo78 {
    //创建可以继承的ThreadLocal
    private static ThreadLocal threadLocal = new InheritableThreadLocal();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set("Java");
                System.out.println("线程1设置值");
            }
        });
        t1.start();
        t1.join();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2获取值："+threadLocal.get());
            }
        });
        t2.start();
        t2.join();
    }
}


线程1设置值
线程2获取值：null

注意事项：即使使用了 InheritableThreadLocal 也不能实现并列线程之间的数据传递（数据设置和获取）

ThreadLocal 脏读：在一个线程中读取到了不属于自己的信息。（两个任务共用一个线程的时候会发生脏读现象）

/**
 * 未发生脏读的演示代码
 */
public class ThreadLocalDemo79 {
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                MyThreadLocal myThreadLocal = new MyThreadLocal();
                myThreadLocal.show();
            }
        },"线程1");
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                MyThreadLocal myThreadLocal = new MyThreadLocal();
                myThreadLocal.show();
            }
        },"线程2");
        t2.start();
    }

    static class MyThreadLocal{
        private static boolean flag = false;
        public void show() {
            String name = Thread.currentThread().getName();
            if (!flag) {
                //第一次执行
                threadLocal.set(name);
                System.out.println(name +" 设置了： "+name);
                flag = true;
            }
            System.out.println(name+" 得到了："+threadLocal.get());
        }
    }
}

线程2 设置了： 线程2
线程1 设置了： 线程1
线程2 得到了：线程2
线程1 得到了：线程1

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 发生脏读的演示
 * 线程池演示
 */
public class ThreadLocalDemo80 {
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,1,
                0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10));

        for (int i = 0; i < 2; i++) {
            executor.submit(new MyThreadLocal());
        }
    }

    static class MyThreadLocal extends Thread{
        private static boolean flag = false;

        @Override
        public void run() {
            String name = this.getName();
            //String name = Thread.currentThread().getName();
            if (!flag) {
                //第一次执行
                threadLocal.set(name);
                System.out.println(name+" 设置了： "+name);
                flag = true;
            }
            System.out.println(name +"得到了："+threadLocal.get());
        }
    }
}

Thread-0 设置了： Thread-0
Thread-0得到了：Thread-0
Thread-1得到了：Thread-0

问题出现了，只设置了一次，但是得到了两次结果

脏读产生的原因：线程复用线程，和线程相关的静态属性也进行复用了，所以就导致了脏读。
如何避免脏数据：

  • 1.避免使用静态变量
  • 2.使用完之后，进行remove操作（可以解决所有的问题）

内存溢出：当一个线程使用完资源之后，没有释放资源，或者说释放资源不及时就会造成内存溢出。（ 前置条件：配合使用线程池才会出现内存溢出）

下面进行代码演示：
设置最大的运行内存，设置5M大小的运行内存
在这里插入图片描述
在这里插入图片描述

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo81 {
    private static ThreadLocal<MyThreadLocal> threadLocal = new ThreadLocal<>();

    /**
     * 使用线程池的方式来进行演示
     */
    //创建大对象
    static class MyThreadLocal{
        private byte[] bytes = new byte[1024*1024];  //1M大小
    }

    public static void main(String[] args) {
        //创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,10,
                0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10));

        for (int i = 0; i < 5; i++) {
            //循环5次就足以检测到内存溢出，因为每一次创建的时候还有许多额外的内存占用的程序
            executor.excute(new Runnable() {
                @Override
                public void run() {
                    //在ThreadLocal里面每一次设置1M大小的值
                    threadLocal.set(new MyThreadLocal());
                    System.out.println(Thread.currentThread().getName()+"线程名设置了值。");
                }
            });
        }
    }
}

pool-1-thread-4线程名设置了值。
pool-1-thread-5线程名设置了值。
pool-1-thread-1线程名设置了值。
Exception in thread "pool-1-thread-3" Exception in thread "pool-1-thread-2" java.lang.OutOfMemoryError: Java heap space
	at thread.thread0522.ThreadLocalDemo81$MyThreadLocal.<init>(ThreadLocalDemo81.java:15)
	at thread.thread0522.ThreadLocalDemo81$1.run(ThreadLocalDemo81.java:29)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
java.lang.OutOfMemoryError: Java heap space
	at thread.thread0522.ThreadLocalDemo81$MyThreadLocal.<init>(ThreadLocalDemo81.java:15)
	at thread.thread0522.ThreadLocalDemo81$1.run(ThreadLocalDemo81.java:29)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)

内存溢出的原因：

  • 1.因为线程池是长生命周期的（使用结束以后不会释放内存）
  • 2.ThreadPoll -> Thread -> ThreadLocal -> ThreadLocalMap -> Entry[ ] key,value(在下面的例子里面 每个value是1mb资源) ，垃圾回收器就不会回收value资源（因为value是强引用）

Java引用的4种类型：

  • 1.强引用： Object obj = new Object(); （使用 = 进行初始化） 即使发生OOM也不会进行垃圾回收。
  • 2.软引用：它的应用关系仅次于强引用，如果内存够用，那么垃圾回收器不会考虑回收此引用，将要发生OOM的时候才会回收此引用
  • 3.弱引用：不管内存是否够用，下一次回收的时候，都会将此引用的对象回收掉
  • 4.虚引用：创建即回收 存在的意义：可以触发一个垃圾回收的回调函数。

面试题：为什么ThreadLocal 会将key设置为弱引用？
答：ThreadLocal 为了更大程度的避免OOM。

如何解决内存溢出？
答：使用完成之后remove()

代码演示如下：

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo83 {
    private static ThreadLocal<MyThreadLocal> threadLocal = new ThreadLocal<>();

    //创建大对象
    static class MyThreadLocal{
        private byte[] bytes = new byte[1024*1024];  //1M大小
    }

    public static void main(String[] args) throws InterruptedException {
        //创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,10,
                0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10));

        for (int i = 0; i < 5; i++) {
            Thread.sleep(300);   //设置任务的时候慢一点，否则就算用remove进行移除也还是会报错
            
            //循环5次就可以检测到内存溢出，因为每一次创建的时候还有许多额外的内存占用的程序
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        //在ThreadLocal里面每一次设置1M大小的值
                        threadLocal.set(new MyThreadLocal());
                        System.out.println(Thread.currentThread().getName()+"线程名设置了值。");
                    } finally {
                        //移除变量，防止OOM
                        threadLocal.remove();
                    }
                }
            });
        }
    }
}

哈希冲突的解决方案不同：

  1. HashMap：链表法（JDK8以后是 链表+红黑树）

        链表升级为红黑树的条件：1.链表的长度大于8     
                        2.数组的长度大于64
    红黑树降级为链表：链表的长度小于6之后  

从链表升级为红黑树的原因：加速查询性能

  2. ThreadLocalMap：开放寻址法（开放定址法，从冲突的地方开始向后寻找）（数据量小的使用场景）

赚钱买phone
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ThreadLocal探究
qq_49684062的博客
05-20 272
什么是ThreadLocal?? ThreadLocal又叫本地线程变量，在多线程并发执行的过程中，我们可以将某个变量存入ThreadLocal中，那么这个变量就可以看作专属于是该线程的本地变量，并且不受其他线程的干扰，从而达到对变量的安全访问，这是一种典型的空间换时间的做法，在某些情况下，使用ThreadLocal保证变量的线程安全，比使用锁机制更加简单并且有更高的执行效率。 ThreadLocal中有三个重要的成员方法 set(T value); 设置当前线程在线程本地变量实例中绑定的值 get()
ThreadLocal的理解
YangzaiLeHeHe的博客
07-29 368
目录 一、使用 二、相关细节 三、最佳实践 ThreadLocal可以实现将一个线程需要使用的变量和自身进行绑定，但是一个ThreadLocal只能绑定一个变量，需要存储多个Object对象就需要多个ThreadLocal。 谈一下对于ThreadLocal的理解： 1、用在什么地方？ 2、相关细节（源码及原理） 3、最佳实践 一、使用 ThreadLocal是用来处理并...
Java8-ThreadLocal的Lambda构造方式：withInitial
Roger_CoderLife的博客
11-14 8694
Java8中ThreadLocal对象提供了一个Lambda构造方式，实现了非常简洁的构造方法：withInitial。这个方法采用Lambda方式传入实现了 Supplier 函数接口的参数。写法如下： 代码实例 /**  * 当前余额  */ private ThreadLocal&lt;Integer&gt; balance = ThreadLocal.withInitial(() -...
ThreadLocal详解，源码级的详解，快来学
理想万岁万万岁的博客
12-13 331
先看一下的官方解释。我们可以通过实例隐式地给线程设置局部变量，即该实例可以在每一个线程内部创建一个变量的副本。而该实例我们就可以通过全局共享变量的方式创建。如下图所示很多文章中将解释为多线程环境中保证线程安全的一个类，但这种说法其实是十分片面的。从官方解释上来看，的功能仅仅是为了给多个线程设置局部变量，这和线程安全是没有关系的，线程安全针对的是全局的共享变量。从类路径来看，位于java.lang包，而非包。从其使用方法来看，无论是set()方法、get()方法、remove()方法，都。
ThreadLocal解析
zz1x2c3的博客
01-05 560
本文是源码解析是基于JDK 13 1. 什么是ThreadLocal？   ThreadLocal顾名思义即是线程本地变量。ThreadLocal变量与普通变量不同，它使得每个访问它的线程都保存着属于自己独立初始化的变量副本，每个线程对ThreadLocal变量的读写是隔离的，互不影响。在多线程场景下，ThreadLocal通过线程隔离达到被多个线程同时访问但又线程安全的目的。 2. Thread...
ThreadLocal
qq_45852612的博客
06-03 544
ThreadLocal：线程级别的私有变量 ThreadLocal使用： 1.set（T）：将变量存放在线程中。 2.get（T）：从线程中取得私有变量 3.remove（）：从线程中移除私有变量。
对ThreadLocal的深入理解
unstoppable_t的博客
05-26 598
ThreadLocal一级目录ThreadLocal是什么ThreadLocal使用三级目录 一级目录 ThreadLocal是什么 讲ThreadLocal之前，我们先回顾一下线程不安全的解决方案： 1.给对象加锁（synchronized加锁或Lock加锁） 2.让线程拥有私有变量，不让多个线程修改一个变量 对于2这种方式而言，但是设置私有变量的方法有一个缺陷，当任务数量比较多时，每一次任务执行都会创建私有变量，这会导致大量占用内存，浪费空间。 因而Java中有一种比较高效的解决线程安全的方案：Th
ThreadLocal相关
06-19
ThreadLocal 相关知识点 ThreadLocal 是 Java 语言中的一种机制，用于提供线程内部的局部变量。在多线程环境下，ThreadLocal 变量可以保证各个线程的变量相对独立于其他线程内的变量。这种机制可以帮助开发者在多...
深入学习java ThreadLocal的源码知识
08-25
这个Entry数组的键是ThreadLocal对象本身（弱引用），而值是线程相关的对象。这样设计的原因是，一个线程可能有多个ThreadLocal实例，每个实例对应不同的变量副本。 ThreadLocal的`set`方法是将值与当前线程关联的...
有关ThreadLocal的面试题你真的懂了吗
08-25
"ThreadLocal相关知识点总结" ThreadLocal是Java中的一种机制，用于在多线程环境中保存线程上下文信息，并且提供了一种解决多线程程序并发问题的思路。下面是对ThreadLocal的主要知识点的总结： 1. ThreadLocal的...
深入解析Java中ThreadLocal线程类的作用和用法
09-02
ThreadLocal为解决多线程程序的并发问题提供了一种新的思路,ThreadLocal并不是一个Thread，而是Thread的局部变量,本文就来深入解析Java中ThreadLocal线程类的作用和用法.
ThreadLocal简单Demo
10-17
**线程局部变量(ThreadLocal)** 在Java编程中，`ThreadLocal`是...以上就是关于`ThreadLocal`及其内部类`ThreadLocalMap`的基础知识，它们在多线程编程中起到关键作用，帮助开发者实现高效、安全的线程局部变量管理。
从面试中的问题分析ThreadLocal
08-25
"ThreadLocal知识点详解" ThreadLocal是一个本地线程副本变量工具类，主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个...
ThreadLocal 关键源码阅读及思考
Happy博客
08-22 157
前言 使用 ThreadLocal 类来定义变量能确保每个线程访问的是该变量的副本，这样就能避免多线程访问一个变量时产生的线程安全问题。 使用步骤 创建 ThreadLocal 对象 普通创建方式 ThreadLocal<Long> createdTime = new ThreadLocal<>(); 带有初始值的创建方式 方式一 ThreadLocal<Long> createdTime = ThreadLocal.withInitial(() -> Sy
ThreadLocal 使用手册 | 建议收藏
Java技术攻略的博客
03-16 340
如果你只是简单地使用一个普通的变量，有可能一个线程会在另一个线程有机会使用它之前就覆盖了该变量的值。类允许程序员创建只有创建这些变量的线程才能访问的变量。这可以确保在任何时候只有一个线程获得访问权，确保在使用那些有可能出现争用问题的区域内的变量时，多个线程的并发访问不会产生冲突。为了使 Java 中的一个变量的值在任何给定的时间点上都能跨越不同的线程，开发人员必须使用 Java 编程语言提供的同步机制，如。，每个线程都有自己的变量副本，所以不存在一个线程在另一个线程有机会使用它之前就覆盖了该值的风险。
ThreadLocal知识小结
qq_45661125的博客
05-25 266
ThreadLocal什么是ThreadLocal ？ThreadLocal 使⽤ThreadLocal 的使用场景ThreadLocal 注意事项ThreadLocal实现原理 什么是ThreadLocal ？ 问题引入： 线程安全的解决方案有两种加锁和创建私有变量，但加锁后任务会排队执行，消耗大量时间，每次任务会创建新的私有变量会消耗大量的资源，那么有没有一种更好的方法呢，肯定是有的啦，ThreadLocal是现成的本地变量，每一个线程会创建一个私有变量。 SimpleDateFormat 是线程不安全
ThreadLocal常用方法浅析、使用场景及注意事项
贵公子丶笔记
04-13 517
1. ThreadLocal详解 JDK1.2版本起，Java就提供了java.lang.ThreadLocal，ThreadLocal为每个使用线程都提供独立的变量副本，可以做到线程间的数据隔离，每个线程都可以访问各自内部的副本变量。 线程上下文ThreadLocal又称为"线程保险箱"，ThreadLocal能够将指定的变量和当前线程进行绑定，线程之间彼此隔离，持有不同的对象实例，从而避免了数据资源的竞争。 2. ThreadLocal的使用场景 在进行对象跨层传递的时候，可以考虑ThreadL
ThreadLocal学习笔记
m0_62811136的博客
10-12 287
但是，也要值得注意的是，现在很多线程创建都是线程池的模式，也就是说可能线程创建出来后，会被一直重复使用，不会短时间内死去（所以ThreadLocalMap指向的对象也不会gc），这时需要注意若是 ThreadLocal 对象的强引用是否有置为null的操作，或者说创建 ThreadLocal的线程死掉了。1、一般ThreadLocal创建出来时，一般都是强引用，而且是共享资源，这时ThreadLocalMap里面的key是不会有gc的场景的，除非创建ThreadLocal这个线程也没了。
java学习----递归
最新发布
qq_56798493的博客
07-13 148
【代码】java学习----递归。
ThreadLocal是javaSE的知识吗
04-22
是的，ThreadLocal是Java SE中的一个类，用于实现线程局部变量。它提供了一种简单的方式，让每个线程都可以独立地访问自己的变量副本，而不会受到其他线程的干扰。 ThreadLocal的主要作用是为每个线程提供一个独立的变量副本，这样每个线程都可以独立地修改自己的副本，而不会影响其他线程的副本。这在多线程编程中非常有用，特别是在并发访问共享资源时，可以避免线程间的数据竞争和冲突。 使用ThreadLocal时，每个线程通过get()方法获取自己的变量副本，并通过set()方法设置自己的变量副本。每个线程都可以独立地修改自己的变量副本，而不会影响其他线程的副本。另外，ThreadLocal还提供了remove()方法用于删除当前线程的变量副本。 需要注意的是，ThreadLocal并不是用来解决共享变量的并发访问问题的，它只是提供了一种线程间隔离变量的机制。在使用ThreadLocal时，需要注意及时清理资源，避免内存泄漏问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值