Java并发笔记五——ThreadLocal

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量264 收藏
点赞数
分类专栏： Java并发笔记 文章标签： java 并发 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zerodshei/article/details/71194446
版权

线程范围内数据共享

package multiThread;

import java.util.concurrent.ThreadLocalRandom;

public class ThreadScopeSharedData {
    private static int data = 0;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                public void run() {
                    data = ThreadLocalRandom.current().nextInt();
                    System.out.println(Thread.currentThread().getName() +
                            " has put data " + data);
                    new A().get();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    new B().get();
                }
            }).start();
            Thread.sleep(1000);
        }
    }

    static class A {
        public void get() {
            System.out.println(
                    Thread.currentThread().getName() + " A : " + data);
        }
    }

    static class B {
        public void get() {
            System.out.println(
                    Thread.currentThread().getName() + " B : " + data);
        }
    }
}

/*
Thread-0 has put data -1657334192
Thread-0 A : -1657334192
Thread-1 has put data -2108767251
Thread-1 A : -2108767251
Thread-0 B : -2108767251    <-------
Thread-1 B : -2108767251
*/

加入map，将产生的数据与当前线程绑定后放入map

public class ThreadScopeSharedData {
    private static int data = 0;

    private static Map<Thread, Integer> map = new HashMap<>();
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                public void run() {
                    data = ThreadLocalRandom.current().nextInt();
                    map.put(Thread.currentThread(), data);
                    System.out.println(Thread.currentThread().getName() +
                            " has put data " + data);
                    new A().get();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    new B().get();
                }
            }).start();
            Thread.sleep(1000);
        }
        System.out.println("now the data is " + data);
    }

    static class A {
        public void get() {
            int data = map.get(Thread.currentThread());
            System.out.println(
                    Thread.currentThread().getName() + " A : " + data);
        }
    }

    static class B {
        public void get() {
            int data = map.get(Thread.currentThread());
            System.out.println(
                    Thread.currentThread().getName() + " B : " + data);
        }
    }
}

/*
Thread-0 has put data -563709465
Thread-0 A : -563709465
Thread-1 has put data -393013760
Thread-1 A : -393013760
Thread-0 B : -563709465   <-----------
Thread-1 B : -393013760
now the data is -393013760
*/

在单线程应用程序中可能会维持一个全局的数据库连接，并在程序启动的时候初始化这个连接对象，从而避免在调用每个方法时都要传递一个Connection对象。由于JDBC的连接对象不一定是线程安全的，因此，当多线程应用程序在没有协同的情况下使用全局变量时，就不是线程安全的。通过将JDBC的连接保存到ThreadLocal对象中，每个线程都会拥有属于自己的连接。

这种思想用在JavaEE里面的一个场景描述如下:银行转账业务，A,B,C用的是同一个Connection的不同线程开启一个事务，将事务上下文保存在静态的ThreadLocal对象中，可以很容易地实现这个功能。 

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalTest {
    private static ThreadLocal<Integer> x = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                public void run() {
                    int data = ThreadLocalRandom.current().nextInt();
                    x.set(data);
                    System.out.println(Thread.currentThread().getName() +
                            " has put data " + data);
                    new A().get();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    new B().get();
                }
            }).start();
            Thread.sleep(1000);
        }
        System.out.println("now the data is " + x.get());
    }

    static class A {
        public void get() {
            int data = x.get();
            System.out.println(
                    Thread.currentThread().getName() + " A : " + data);
        }
    }

    static class B {
        public void get() {
            int data = x.get();
            System.out.println(
                    Thread.currentThread().getName() + " B : " + data);
        }
    }
}

/*
Thread-0 has put data -1154183505
Thread-0 A : -1154183505
Thread-1 has put data 583017524
Thread-1 A : 583017524
Thread-0 B : -1154183505
Thread-1 B : 583017524    <-----------
now the data is null      <-----------主线程没有设定这个变量
*/

一个ThreadLocal只能代表一个变量，放一个数据，如果有多个数据，则需要将多个数据封装成一个对象放入ThreadLocal中。 

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalObjectTest {
    private static ThreadLocal<Integer> x = new ThreadLocal<>();
    private static ThreadLocal<MyThreadLocalData> myThreadLocaldata = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                public void run() {
                    int data = ThreadLocalRandom.current().nextInt();
                    x.set(data);
                    System.out.println(Thread.currentThread().getName() +
                            " has put data " + data);
                    MyThreadLocalData myData = new MyThreadLocalData();
                    myData.setName("name" + data + ", age ");
                    myData.setAge(data);
                    myThreadLocaldata.set(myData);
                    new A().get();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    new B().get();
                }
            }).start();
            Thread.sleep(1000);
        }
    }

    static class A {
        public void get() {
            int data = x.get();
            System.out.println(
                    Thread.currentThread().getName() + " A : " + data);
            MyThreadLocalData myData = myThreadLocaldata.get(); 
            System.out.println(
                    Thread.currentThread().getName() + " A : " +  myData.getName() + myData.getAge());
        }
    }

    static class B {
        public void get() {
            int data = x.get();
            System.out.println(
                    Thread.currentThread().getName() + " B : " + data);
            MyThreadLocalData myData = myThreadLocaldata.get(); 
            System.out.println(
                    Thread.currentThread().getName() + " B : " + myData.getName() + myData.getAge());
        }
    }
}

class MyThreadLocalData {
    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
/*
Thread-0 has put data -73677040
Thread-0 A : -73677040
Thread-0 A : name-73677040, age -73677040
Thread-1 has put data 128646006
Thread-1 A : 128646006
Thread-1 A : name128646006, age 128646006
Thread-0 B : -73677040
Thread-0 B : name-73677040, age -73677040
Thread-1 B : 128646006
Thread-1 B : name128646006, age 128646006
*/

这样的代码太丑陋，所以对上面的例子程序进行改进。 

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalSingleTest {
    private static ThreadLocal<Integer> x = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                public void run() {
                    int data = ThreadLocalRandom.current().nextInt();
                    x.set(data);
                    System.out.println(Thread.currentThread().getName() +
                            " has put data " + data);
                    MyThreadLocalDataSingle.getThreadInstance().setName("name" + data + ", age ");
                    MyThreadLocalDataSingle.getThreadInstance().setAge(data);
                    new A().get();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    new B().get();
                }
            }).start();
            Thread.sleep(1000);
        }
    }

    static class A {
        public void get() {
            int data = x.get();
            System.out.println(
                    Thread.currentThread().getName() + " A : " + data);
            MyThreadLocalDataSingle myData = MyThreadLocalDataSingle.getThreadInstance();
            System.out.println(
                    Thread.currentThread().getName() + " A : " +  myData.getName() + myData.getAge());
        }
    }

    static class B {
        public void get() {
            int data = x.get();
            System.out.println(
                    Thread.currentThread().getName() + " B : " + data);
            MyThreadLocalDataSingle myData = MyThreadLocalDataSingle.getThreadInstance();
            System.out.println(
                    Thread.currentThread().getName() + " B : " + myData.getName() + myData.getAge());
        }
    }
}

class MyThreadLocalDataSingle {
    private static ThreadLocal<MyThreadLocalDataSingle> map = new ThreadLocal<>();

    private MyThreadLocalDataSingle() {}

    // 仅仅和本线程有关，无需加synchronized关键字
    public static /*synchronized*/ MyThreadLocalDataSingle getThreadInstance() {
        MyThreadLocalDataSingle instance = map.get();
        if (instance == null) {
             instance = new MyThreadLocalDataSingle();
             map.set(instance);
        }
        return instance;
    }

    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

/*
Thread-0 has put data -1169633973
Thread-0 A : -1169633973
Thread-0 A : name-1169633973, age -1169633973
Thread-1 has put data 1917450343
Thread-1 A : 1917450343
Thread-1 A : name1917450343, age 1917450343
Thread-0 B : -1169633973
Thread-0 B : name-1169633973, age -1169633973
Thread-1 B : 1917450343
Thread-1 B : name1917450343, age 1917450343
*/

从概念上来看，可以讲ThreadLocal视为包含了Map对象，其中保存了特定于该线程的值，但是实现并非如此。这些特定于线程的值保存在Thread对象中，当线程终止后，这些值会作为垃圾回收。

zerods-seu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA线程安全及性能的优化笔记(五)——ThreadLocal
Java_supermanNO1的博客
04-13 460
本文转载自：JAVA线程安全及性能的优化笔记(五)——ThreadLocal 一、ThreadLocal原理 1. 线程程序介绍 早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。 2. Threadlocal变量 ThreadLocal很容易让人望文生...
实例讲解Java并发编程之ThreadLocal类
09-03
Java并发编程中的ThreadLocal类是一个非常重要的工具，它允许我们在多线程环境下为每个线程维护独立的变量副本，从而避免了线程间的数据共享和同步问题。ThreadLocal并不是一个线程，而是一个线程局部变量的容器。...
并发学习笔记——ThreadLocal
hduzjn的博客
11-16 424
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Java并发编程读书笔记——ThreadLocal
Crazer_cy的博客
03-25 305
1. ThreadLocal定义：线程变量，是一个以ThreadLocal对象为键，任意对象为值得存储结构。2. 作用：提供线程内得局部变量，在线程的生命周期内起作用，在本线程内随时可取，隔离其它的线程。下面写了一个简单的例子：/** * 是一个以ThreadLocal对象为键，任意对象为值得存储结构； * 一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上得一个值 */ ...
Java并发编程——ThreadLocal
zihonggege的博客
04-26 212
我们知道，在多线程访问同一个共享变量的情况下，为了保证不出现并发问题，我们往往需要对其进行同步操作，一般是通过加锁。那么，有没有一种方法，创建一个变量，使得每个线程对其进行访问都是访问自己线程的变量呢？ThreadLocal就可以实现这个操作。 何为ThreadLocal ThreadLocal是JDK提供的，位于java.lang包中，它提供了一...
Java学习笔记——并发之ThreadLocal
bingzhixi的博客
12-05 466
ThreadLocal是一种线程本地存储机制，可以为使用相同变量的每个不同线程都创建不同的存储。因此，如果你有5个线程都要使用变量x锁表示的对象，线程本地存储就会产生5个用于x的不同存储块。 1. ThreadLocal的用法     ThreadLocal在是泛型类，可以使用set方法设置变量的值，使用get方法获取变量值，示例代码如下： public class ThreadLoca
Java笔记——谈谈对ThreadLocal的理解
yang1060887552的专栏
10-08 194
1.什么是ThreadLocal？ ThreadLocal是Java为Thread提供的本地存储机制，可以在Thread通过ThreadLocal（set方法）缓存数据，缓存之后可以在线程执行时的任意执行点、任意时间点获取（get方法）缓存的数据。 Thread的ThreadLocal本地存储内存区相互隔离，并不共享；但是如果ThreadLocal关联的缓存数据为堆对象时，不同的Thread的ThreadLocal关联到同一个堆对象，这个时候如果有修改操作不是线程安全的。 2.ThreadLoca
《实战Java高并发程序设计》笔记——ThreadLocal
星辰之眼
12-24 116
文章目录一、简单的使用1.1 是什么1.2 示例1.3 解决方案二、实现原理2.1 set() 方法2.2 get() 方法2.3 ThreadLocal 导致内存泄漏三、对性能的帮助3.1 说明3.2 代码示例 一、简单的使用 1.1 是什么 ThreadLocal是一个线程的局部变量，只有当前线程可以访问，因为只有当前线程可以访问，所以是线程安全的。 1.2 示例 1、举例 多线程环境中使用SimpleDateFormat 解析日期 2、代码 public class SimpleDateFormat
Java并发编程的艺术笔记（四）——ThreadLocal的使用
weixin_30381317的博客
01-09 71
ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。目的就是为了让线程能够有自己的变量 可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。 /** * Sets the curren...
面试八股之线程篇5.3——Threadlocal——Threadlocal的内存泄露问题
做一个善良的人，做好自己的事，如果愿意，再发一份光。
05-30 766
详细讲解了ThreadLocal-内存泄露问题，强引用、弱引用之导致。
Java并发编程学习之ThreadLocal源码详析
08-27
Java并发编程学习之ThreadLocal源码详析 ThreadLocal是Java并发编程中的一种机制，用于解决多线程访问共享变量的问题。它可以使每个线程对共享变量的访问都是线程安全的，使得多线程编程变得更加简单。 ...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
java并发学习笔记
12-21
以上就是Java并发学习笔记的主要内容，这些知识点构成了Java并发编程的基础，理解和掌握它们对于编写高效、稳定的多线程程序至关重要。在实际开发中，需要结合具体场景灵活运用，确保程序的正确性和性能。
Java并发编实践之ThreadLocal变量.doc
09-30
Java并发编程实践中，ThreadLocal变量是一个非常重要的工具，它在JDK1.2版本就已经引入。ThreadLocal不是代表一个线程实例，而是一种线程局部变量的机制，它为每个线程提供了一个独立的变量副本，各个线程可以独立地...
C++ - 函数重载
jiaowenjie的专栏
08-06 309
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1070
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Spring事务
最新发布
c1tenj2的博客
08-07 416
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
【SpringBoot】数据验证之分组校验
Jacker
08-05 381
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
Java并发编程：线程池、ThreadLocal、锁机制与原子操作
"该文档是关于Java并发编程的学习笔记，涵盖了线程池、ThreadLocal、锁机制、原子类以及CAS的相关知识。" 一·线程池 线程池是Java并发编程中常用的一种优化手段，通过复用已存在的线程来减少创建和销毁线程的开销...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值