07-ThreadLocal有哪些使用场景？【Java面试题总结】

news2024/11/28 11:38:41

ThreadLocal有哪些使用场景？

7.1 多线程场景下共享变量问题

ThreadLocal是线程本地变量，可以存储共享变量副本，每一个独立线程都有与共享变量一模一样的副本。ThreadLocal在当前线程下共享变量是全局共享的，各个线程之间是相互独立的。

ThreadLocal在多线程场景下解决共享变量问题代码案例：

public class SharedVariableExample {
    private static ThreadLocal<Integer> sharedVariable = new ThreadLocal<>();

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 3; i++) {
            final int value = i; // 保存当前值，确保每个线程的值不同
            executorService.submit(() -> {
                sharedVariable.set(value); // 将值设置到ThreadLocal中
                try {
                    processValue(); // 处理共享变量
                } finally {
                    sharedVariable.remove(); // 在任务完成后清除ThreadLocal的值
                }
            });
        }

        executorService.shutdown();
    }

    private static void processValue() {
        int value = sharedVariable.get(); // 从ThreadLocal中获取值
        System.out.println("Thread " + Thread.currentThread().getName() + ": Value = " + value);
    }
}

执行结果如下，每个线程都有自己独立的共享变量副本，并且在当前线程下任务一个地方值都是一样的(一个线程下，可能存在多个方法，多个方法即当前线程下共享变量全局共享)

image-20230902140513702

7.2 保存系统上下文信息

在多线程环境中，有时需要在线程之间传递数据，但不希望通过方法参数或全局变量来传递。ThreadLocal可以在当前线程中存储数据，其他线程可以通过ThreadLocal获取该数据。

使用ThreadLocal实现保存上下文信息代码案例如下

新建User类

public class User {
    private String username;

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

    public String getUsername() {
        return username;
    }
}

新建RequestContext类，用于保存信息到ThreadLocal中

public class RequestContext {
    private static ThreadLocal<RequestContext> contextHolder = new ThreadLocal<>();

    private String requestId;
    private User currentUser;

    private RequestContext(String requestId, User currentUser) {
        this.requestId = requestId;
        this.currentUser = currentUser;
    }

    public static void setCurrentContext(String requestId, User currentUser) {
        RequestContext context = new RequestContext(requestId, currentUser);
        contextHolder.set(context);
    }

    public static RequestContext getCurrentContext() {
        return contextHolder.get();
    }

    public String getRequestId() {
        return requestId;
    }

    public User getCurrentUser() {
        return currentUser;
    }
}

新建UserService处理请求

public class UserService {
    public void processRequest() {
        RequestContext context = RequestContext.getCurrentContext();
        String requestId = context.getRequestId();
        User currentUser = context.getCurrentUser();

        System.out.println("Processing request: " + requestId + "  ,Current user: " + currentUser.getUsername());
    }
}

模拟两个请求，分别由不同的两个用户发起的请求。UserService类和RequestContext类本身没有直接的关系，从程序运行结果来看，信息确实从RequestContext透传到了UserService中，说明ThreadLocal起到了中间作用，可以用来保存系统上下文信息。

public class Main {
    public static void main(String[] args) {
        // 模拟请求1
        User user1 = new User("Alice");
        RequestContext.setCurrentContext("request-1", user1);

        UserService userService = new UserService();
        userService.processRequest();

        // 模拟请求2
        User user2 = new User("Bob");
        RequestContext.setCurrentContext("request-2", user2);

        userService.processRequest();
    }
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

7.3 管理数据库连接

public class ConnectionManager {
    private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<>();

    public static Connection getConnection() throws SQLException {
        // 从ThreadLocal获取连接
        Connection connection = connectionHolder.get();

        // 如果连接不存在，则创建新连接并保存到ThreadLocal
        if (connection == null || connection.isClosed()) {
            connection = createConnection();
            connectionHolder.set(connection);
        }

        return connection;
    }

    private static Connection createConnection() throws SQLException {
        // 创建数据库连接
        String url = "jdbc:mysql://localhost:3306/dev";
        String username = "root";
        String password = "root";
        return DriverManager.getConnection(url, username, password);
    }

    public static void closeConnection() throws SQLException {
        // 关闭连接并从ThreadLocal中移除
        Connection connection = connectionHolder.get();
        if (connection != null && !connection.isClosed()) {
            connection.close();
        }
        connectionHolder.remove();
    }
}

public class DatabaseService {
    public void performDatabaseOperation() throws SQLException {
        Connection connection = ConnectionManager.getConnection();

        // 使用连接执行数据库操作
        // ...

        // 操作完成后关闭连接
        ConnectionManager.closeConnection();
    }
}

public class Main {
    public static void main(String[] args) throws SQLException {
        // 创建多个线程模拟并发访问
        Thread thread1 = new Thread(() -> {
            try {
                DatabaseService service = new DatabaseService();
                service.performDatabaseOperation();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                DatabaseService service = new DatabaseService();
                service.performDatabaseOperation();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

一个请求对应一个数据库连接，一个请求下的所有对数据库的操作都是基于该连接进行的。这样可以在一定程度上避免频繁的创建和销毁数据库连接，从而提高性能。

7.4 基于ThreadLocal实现事务功能

使用ThreadLocal实现事务注解的原理是通过在每个线程中维护一个事务上下文对象，将事务状态与当前线程绑定起来。当需要开启事务时，通过注解或编程方式将事务上下文对象与当前线程进行关联，以便在整个事务执行过程中使用相同的事务上下文对象。

首先，定义一个事务上下文对象，用于存储事务相关的信息，例如事务状态、连接对象等。

public class TransactionContext {
    private Connection connection;
    private boolean inTransaction;

    // 省略构造方法和其他属性的访问方法

    public Connection getConnection() {
        return connection;
    }

    public void setConnection(Connection connection) {
        this.connection = connection;
    }

    public boolean isInTransaction() {
        return inTransaction;
    }

    public void setInTransaction(boolean inTransaction) {
        this.inTransaction = inTransaction;
    }
}

接下来，定义一个事务管理器类，使用ThreadLocal来存储和获取当前线程的事务上下文对象。

package com.spring6.learn.ThreadLocal.test6;

import java.sql.Connection;
import java.sql.SQLException;

public class TransactionManager {
    private static ThreadLocal<TransactionContext> transactionContextHolder = new ThreadLocal<>();

    public static void beginTransaction() {
        TransactionContext context = new TransactionContext();
        transactionContextHolder.set(context);
        context.setInTransaction(true);
    }

    public static void commitTransaction() {
        TransactionContext context = transactionContextHolder.get();
        if (context != null && context.isInTransaction()) {
            Connection connection = context.getConnection();
            try {
                connection.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            context.setInTransaction(false);
            closeConnection(connection);
        }
    }

    public static void rollbackTransaction() {
        TransactionContext context = transactionContextHolder.get();
        if (context != null && context.isInTransaction()) {
            Connection connection = context.getConnection();
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            context.setInTransaction(false);
            closeConnection(connection);
        }
    }

    public static Connection getCurrentConnection() {
        TransactionContext context = transactionContextHolder.get();
        if (context != null) {
            return context.getConnection();
        }
        return null;
    }

    public static void setCurrentConnection(Connection connection) {
        TransactionContext context = transactionContextHolder.get();
        if (context == null) {
            context = new TransactionContext();
            transactionContextHolder.set(context);
        }
        context.setConnection(connection);
    }

    private static void closeConnection(Connection connection) {
        try {
            if (connection != null && !connection.isClosed()) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

public class TransactionManagerTest {
    private Connection connection;

    @Before
    public void setUp() throws SQLException {
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mysql", "root", "root");
        TransactionManager.setCurrentConnection(connection);
        TransactionManager.beginTransaction();
    }

    @After
    public void tearDown() throws SQLException {
        TransactionManager.rollbackTransaction();
        TransactionManager.setCurrentConnection(null);
        if (connection != null && !connection.isClosed()) {
            connection.close();
        }
    }

    @Test
    public void testTransaction() throws SQLException {
        // 在事务中插入一条数据
        String insertQuery = "INSERT INTO mytable (name) VALUES (?)";
        try (PreparedStatement statement = connection.prepareStatement(insertQuery)) {
            statement.setString(1, "John Doe");
            statement.executeUpdate();
        }

        // 在事务中查询数据
        String selectQuery = "SELECT COUNT(*) FROM mytable";
        try (PreparedStatement statement = connection.prepareStatement(selectQuery)) {
            ResultSet resultSet = statement.executeQuery();
            if (resultSet.next()) {
                int count = resultSet.getInt(1);
                assertEquals(1, count); // 验证插入的数据是否存在
            }
        }
    }
}

TransactionManager.beginTransaction();
}

@After
public void tearDown() throws SQLException {
    TransactionManager.rollbackTransaction();
    TransactionManager.setCurrentConnection(null);
    if (connection != null && !connection.isClosed()) {
        connection.close();
    }
}

@Test
public void testTransaction() throws SQLException {
    // 在事务中插入一条数据
    String insertQuery = "INSERT INTO mytable (name) VALUES (?)";
    try (PreparedStatement statement = connection.prepareStatement(insertQuery)) {
        statement.setString(1, "John Doe");
        statement.executeUpdate();
    }

    // 在事务中查询数据
    String selectQuery = "SELECT COUNT(*) FROM mytable";
    try (PreparedStatement statement = connection.prepareStatement(selectQuery)) {
        ResultSet resultSet = statement.executeQuery();
        if (resultSet.next()) {
            int count = resultSet.getInt(1);
            assertEquals(1, count); // 验证插入的数据是否存在
        }
    }
}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/968195.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

虚拟内存相关笔记

虚拟内存相关笔记

虚拟内存是计算机系统内存管理的一个功能&#xff0c;它允许程序认为它们有比实际物理内存更多的可用内存。它使用硬盘来模拟额外的RAM。当物理内存不足时&#xff0c;操作系统将利用磁盘空间作为虚拟内存来存储数据。这种机制提高了资源的利用率并允许更大、更复杂的应用程序的…
阅读更多...
ICCV 2023 | TUM谷歌提出md4all：挑战性条件下的单目深度估计

ICCV 2023 | TUM谷歌提出md4all：挑战性条件下的单目深度估计

点击下方卡片&#xff0c;关注“CVer”公众号 AI/CV重磅干货&#xff0c;第一时间送达 点击进入—>【深度估计】交流群 Robust Monocular Depth Estimation under Challenging Conditions 作者列表: Stefano Gasperini, Nils Morbitzer, HyunJun Jung, Nassir Navab, Federi…
阅读更多...
【小作文】【信】

【小作文】【信】

【邀请信】【22&#xff0c;1邀请教授参加比赛】 【投诉信】【12,2投诉产品质量问题】
阅读更多...
一般不用buildroot来编译uboot和kernel

一般不用buildroot来编译uboot和kernel

Buildroot 是一个流行的嵌入式 Linux 系统构建工具&#xff0c;它可以帮助开发者自动化地构建完整的嵌入式 Linux 系统&#xff0c;包括文件系统、内核以及各种用户空间应用程序。虽然 Buildroot 在构建嵌入式系统方面非常强大且易于使用&#xff0c;但一般情况下&#xff0c;它…
阅读更多...
STM32WB55开发(1)----套件概述

STM32WB55开发(1)----套件概述

STM32WB55开发----1.套件概述 所用器件视频教学样品申请优势支持协议系统控制和生态系统访问功能示意图系统框图跳线设置开发板原理图 所用器件 所使用的器件是我们自行设计的开发板&#xff0c;该开发板是基于 STM32WB55 系列微控制器所构建。STM32WBXX_VFQFPN68 不仅是一款评…
阅读更多...
Linux学习之NAS服务器搭建

Linux学习之NAS服务器搭建

NAS是Network Attached Storage的缩写&#xff0c;也就是网络附属存储。可以使用自己已经不怎么使用的笔记本搭建一台NAS服务器。 fdisk -l可以看一下各个磁盘的状态。 可以看到有sda、sdb、sdc和sdd等四块硬盘。 lvs、vgs和pvs结合起来看&#xff0c;sdb和sdc没有被使用。 …
阅读更多...
MYSQL_

MYSQL_

文章目录 ①. 索引的概述②. 二叉树和红黑树③. Hash建立索引结构④. B树的数据结构⑤. MyISAM存储引擎索引实现⑥. InnoDB索引实现(聚集)⑦. 联合索引的设定 ①. 索引的概述 ①. 索引是帮助MySQL高效获取数据的排好序的数据结构 ②. mysql数据库的实现原理通过b树实现的,b树的…
阅读更多...
docker安装redis,并挂载配置文件

docker安装redis,并挂载配置文件

1&#xff1a;下载镜像&#xff0c;不添加版本 默认下载最新的 docker pull redis下载成功后如图所示 2&#xff1a;下载redis配置文件&#xff0c;我是在docker中下载的&#xff0c;也可以使用文件上传工具将配置文件上传到自己指定的目录。 首先需要安装wget&#xff0c;否…
阅读更多...
第一章 USB应用笔记之USB初步了解

第一章 USB应用笔记之USB初步了解

USB应用笔记之USB初步了解 文章目录 USB应用笔记之USB初步了解前言USB的优点&#xff1a;USB版本发展USB速度以及电气接口USB传输过程USB开发抓包工具&#xff1a;USB传输方式1.控制传输特点:2.中断传输的特点3. 批量传输的特点4.实时传输&#xff08;同步传输&#xff09;的特…
阅读更多...
同步与互斥

同步与互斥

硬件指令 实现互斥&#xff1a;硬件指令&#xff0c;硬件实现的原子操作&#xff0c;不会被打断 tsl指令和xchg指令 当前指令执行完&#xff0c;才会检测中断 If the signal comes while an instruction is being executed, it is held until the execution of the instructi…
阅读更多...
Feign负载均衡写法

Feign负载均衡写法

Feign主要为了面向接口编程 feign是web service客户端&#xff0c;是接口实现的&#xff0c;而ribbon是通过微服务名字访问通过RestTemplate调用的&#xff0c;如下&#xff1a; 在Feign的实现下&#xff0c;我们只需要创建一个接口并使用注解的方式来配置它&#xff08;类似…
阅读更多...
仿京东 项目笔记2（注册登录）

仿京东 项目笔记2（注册登录）

这里写目录标题 1. 注册页面1.1 注册/登录页面——接口请求1.2 Vue开发中Element UI的样式穿透1.2.1 ::v-deep的使用1.2.2 elementUI Dialog内容区域显示滚动条 1.3 注册页面——步骤条和表单联动 stepsform1.4 注册页面——滑动拼图验证1.5 注册页面——element-ui组件Popover…
阅读更多...
开开心心带你学习MySQL数据库之第三篇上

开开心心带你学习MySQL数据库之第三篇上

学校的项目组有必要加入吗? 看你的初心. ~~如果初心是通过这个经历能够提高自己的技术水平 ~~是可以考虑的 ~~如果初心是通过这个经历提高自己找工作的概率 ~~这个是不靠谱的,啥用没有 ~~如果初心是通过这个体验更美好的大学生活 ~~靠谱的 秋招,应届生,找工作是非常容易的!!! …
阅读更多...
《开发实战》13 | 用好Java 8的日期时间类，少踩一些“老三样”的坑

《开发实战》13 | 用好Java 8的日期时间类，少踩一些“老三样”的坑

13 | 用好Java 8的日期时间类&#xff0c;少踩一些“老三样”的坑 初始化日期时间 如果要初始化一个 2019 年 12 月 31 日 11 点 12 分 13秒这样的时间&#xff0c;Date date new Date(2019, 12, 31, 11, 12, 13);输出的时间是 3029 年 1 月 31 日 11 点 12 分 13 秒&#xf…
阅读更多...
时间语义与窗口

时间语义与窗口

时间语义 在Flink中&#xff0c;时间语义分为两种 &#xff1a; 处理时间和事件时间。时间语义与窗口函数是密不可分的。以窗口为单位进行某一段时间内指标统计&#xff0c;例如想要统计8点-9点的某个页面的访问量&#xff0c;此时就需要用到了窗口函数&#xff0c;这里的关键…
阅读更多...
【倒着考虑】CF Edu 21 D

【倒着考虑】CF Edu 21 D

Problem - D - Codeforces 题意&#xff1a; 思路&#xff1a; 这道题需要倒着步骤考虑&#xff0c;就是先去假设已经分为了两部分&#xff0c;这左右两部分的和相等&#xff0c;然后去想上一个步骤 倒着一个步骤后&#xff0c;可以发现这样的性质&#xff1a; Code&#xf…
阅读更多...
2023谷歌开发者大会直播大纲「终稿」

2023谷歌开发者大会直播大纲「终稿」

听人劝、吃饱饭，奉劝各位小伙伴，不要订阅该文所属专栏。 作者：不渴望力量的哈士奇(哈哥)，十余年工作经验, 跨域学习者，从事过全栈研发、产品经理等工作，现任研发部门 CTO 。荣誉：2022年度博客之星Top4、博客专家认证、全栈领域优质创作者、新星计划导师，“星荐官共赢计…
阅读更多...
【小沐学Python】UML类图的箭头连线关系总结（python+graphviz）

【小沐学Python】UML类图的箭头连线关系总结（python+graphviz）

文章目录 1、简介1.1 类图1.2 Graphviz 2、Graphviz2.1 安装2.2 命令行测试2.3 python测试 3、关系3.1 实现3.2 泛化3.3 关联3.4 依赖3.5 聚合3.6 组合 结语 1、简介 UML&#xff08;unified modeling language&#xff0c;统一建模语言&#xff09;是一种常用的面向对象设计的…
阅读更多...
java-参数传递机制

java-参数传递机制

java参数传递机制都是值传递。 基本类型参数传输都是数据值。 传递到方法中的值是拷贝后的值。 引用类型参数传输的都是地址值。 如果是数组的参数传递&#xff0c;那么是引用传递&#xff08;本质上还是值传递&#xff0c;但是由于数组的值传递是传递数组的内存地址&#xf…
阅读更多...
如何使用『Nginx』配置后端『HTTPS』协议访问

如何使用『Nginx』配置后端『HTTPS』协议访问

前言 本篇博客主要讲解如何使用 Nginx 部署后端应用接口 SSL 证书&#xff0c;从而实现 HTTPS 协议访问接口&#xff08;本文使用公网 IP 部署&#xff0c;读者可以自行替换为域名&#xff09; 申请证书 须知 请在您的云服务平台申请 SSL 证书&#xff0c;一般来说证书期限…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023