ThreadLocal 速解

已于 2023-01-14 20:16:32 修改
阅读量117 收藏
点赞数 1
分类专栏： JAVA 文章标签： java Powered by 金山文档
于 2023-01-14 19:38:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyf24/article/details/128688312
版权

ThreadLocal 概述

  • ThreadLocal类用来提供线程内部的局部变量，不同的线程之间不会相互干扰

  • 这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量

  • 在线程的生命周期内起作用，可以减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度

  • 可把ThreadLocal当成是JavaWeb中的域

使用

常用方法

方法名

描述

ThreadLocal()

创建ThreadLocal对象

public void set( T value)

设置当前线程绑定的局部变量

public T get()

获取当前线程绑定的局部变量

public T remove()

移除当前线程绑定的局部变量，该方法可以帮助JVM进行GC

protected T initialValue()

返回当前线程局部变量的初始值

作用举例：

分析以下Dao层代码存在什么问题：

其中，DBUtil.getConnection();始终都是获取返回获取的新的Connection对象。

package com.powernode.bank.mvc;

import com.powernode.bank.utils.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class AccountDao {
    /**
     * 插入账户信息
     * @param act  账户信息
     * @return 1表示插入成功
     */
    public int insert(Account act) {
        Connection conn = null;
        PreparedStatement ps = null;
        int count = 0;
        try {
            conn = DBUtil.getConnection();
            String sql = "insert into t_act(actno, balance) values(?,?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, act.getActno());
            ps.setDouble(2, act.getBalance());
            count = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(conn, ps, null);
        }
        return count;
    }

    /**
     * 根据主键删除账户
     * @param id 主键
     * @return
     */
    public int deleteById(Long id){
        Connection conn = null;
        PreparedStatement ps = null;
        int count = 0;
        try {
            conn = DBUtil.getConnection();
            String sql = "delete from t_act where id = ?";
            ps = conn.prepareStatement(sql);
            ps.setLong(1, id);
            count = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(conn, ps, null);
        }
        return count;
    }

    /**
     * 更新账户
     * @param act
     * @return
     */
    public int update(Account act) {
        Connection conn = null;
        PreparedStatement ps = null;
        int count = 0;
        try {
            conn = DBUtil.getConnection();
            String sql = "update t_act set balance = ? , actno = ? where id = ?";
            ps = conn.prepareStatement(sql);
            ps.setDouble(1, act.getBalance());
            ps.setString(2, act.getActno());
            ps.setLong(3, act.getId());
            count = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(conn, ps, null);
        }
        return count;
    }

    /**
     * 根据账号查询账户
     * @param actno
     * @return
     */
    public Account selectByActno(String actno){
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        Account act = null;
        try {
            conn = DBUtil.getConnection();
            String sql = "select id,balance from t_act where actno = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, actno);
            rs = ps.executeQuery();
            if (rs.next()) {
                Long id = rs.getLong("id");
                Double balance = rs.getDouble("balance");
                // 将结果集封装成java对象
                act = new Account();
                act.setId(id);
                act.setActno(actno);
                act.setBalance(balance);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(conn, ps, rs);
        }
        return act;
    }

    /**
     * 获取所有的账户
     * @return
     */
    public List<Account> selectAll() {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<Account> list = new ArrayList<>();
        try {
            conn = DBUtil.getConnection();
            String sql = "select id,actno,balance from t_act";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                // 取出数据
                Long id = rs.getLong("id");
                String actno = rs.getString("actno");
                Double balance = rs.getDouble("balance");
                // 封装对象
                /*Account account = new Account();
                account.setId(id);
                account.setActno(actno);
                account.setBalance(balance);*/
                Account account = new Account(id, actno, balance);
                // 加到List集合
                list.add(account);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(conn, ps, rs);
        }
        return list;
    }

}

如上述Dao层（数据访问）类中，该类具有一系列对数据库进行操作的方法，我们会在Service层（业务逻辑层）中对其进行方法的调用，由于该类需要Connection对象来进行prepareStatement方法的调用，问题就在于：DBUtil.getConnection();始终都是获取返回获取的新的Connection对象，而我们是在Service层调用Connection响应的方法进行事务的控制，这就导致了二者不是相同的Connection对象，无法进行事务的控制。

改进：（通过传参来使得Service层与Dao层的Connection对象相同）

public class AccountDao {

    /**
     * 插入账户信息
     * @param act  账户信息
     * @return 1表示插入成功
     */
    public int insert(Account act, Connection conn) {
        PreparedStatement ps = null;
        int count = 0;
        try {
            String sql = "insert into t_act(actno, balance) values(?,?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, act.getActno());
            ps.setDouble(2, act.getBalance());
            count = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(null, ps, null);
        }
        return count;
    }

    /**
     * 根据主键删除账户
     * @param id 主键
     * @return
     */
    public int deleteById(Long id, Connection conn){
        PreparedStatement ps = null;
        int count = 0;
        try {
            String sql = "delete from t_act where id = ?";
            ps = conn.prepareStatement(sql);
            ps.setLong(1, id);
            count = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(null, ps, null);
        }
        return count;
    }

    /**
     * 更新账户
     * @param act
     * @return
     */
    public int update(Account act, Connection conn) {
        PreparedStatement ps = null;
        int count = 0;
        try {
            System.out.println(conn);
            String sql = "update t_act set balance = ? , actno = ? where id = ?";
            ps = conn.prepareStatement(sql);
            ps.setDouble(1, act.getBalance());
            ps.setString(2, act.getActno());
            ps.setLong(3, act.getId());
            count = ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(null, ps, null);
        }
        return count;
    }

    /**
     * 根据账号查询账户
     * @param actno
     * @return
     */
    public Account selectByActno(String actno, Connection conn){
        PreparedStatement ps = null;
        ResultSet rs = null;
        Account act = null;
        try {
            System.out.println(conn);
            String sql = "select id,balance from t_act where actno = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, actno);
            rs = ps.executeQuery();
            if (rs.next()) {
                Long id = rs.getLong("id");
                Double balance = rs.getDouble("balance");
                // 将结果集封装成java对象
                act = new Account();
                act.setId(id);
                act.setActno(actno);
                act.setBalance(balance);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(null, ps, rs);
        }
        return act;
    }

    /**
     * 获取所有的账户
     * @return
     */
    public List<Account> selectAll(Connection conn) {
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<Account> list = new ArrayList<>();
        try {
            String sql = "select id,actno,balance from t_act";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                // 取出数据
                Long id = rs.getLong("id");
                String actno = rs.getString("actno");
                Double balance = rs.getDouble("balance");
                // 封装对象
                /*Account account = new Account();
                account.setId(id);
                account.setActno(actno);
                account.setBalance(balance);*/
                Account account = new Account(id, actno, balance);
                // 加到List集合
                list.add(account);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(null, ps, rs);
        }
        return list;
    }

}

但这样代码不美观且麻烦。

由于在Service层中调用Dao层，两者属于同一个线程，使用我们可以使用ThreadLocal，来实现不传参的情况下获取到的是同一个Connection。

hreadLocalMap 模拟实现

  • JDK8 之前的设计
    每个ThreadLocal都创建一个ThreadLocalMap，用线程作为ThreadLocalMap的key，要存储的局部变量作为ThreadLocalMap的value，这样就能达到各个线程的局部变量隔离的效果

public class DBUtil {

    // 静态变量特点：类加载时执行，并且只执行一次。
    // 全局的大Map集合
    private static MyThreadLocal<Connection> local = new MyThreadLocal<>();

    /**
     * 每一次都调用这个方法来获取Connection对象
     * @return
     */
    public static Connection getConnection(){
        Connection connection = local.get();
        if (connection == null) {
            // 第一次调用：getConnection()方法的时候，connection一定是空的。
            // 空的就new一次。
            connection = new Connection();
            // 将new的Connection对象绑定到大Map集合中。
            local.set(connection);
        }
        return connection;
    }

}
import java.util.HashMap;
import java.util.Map;

/**
 * 自定义一个ThreadLocal类
 */
public class MyThreadLocal<T> {

    /**
     * 所有需要和当前线程绑定的数据要放到这个容器当中
     */
    private Map<Thread, T> map = new HashMap<>();

    /**
     * 向ThreadLocal中绑定数据
     */
    public void set(T obj){      
        map.put(Thread.currentThread(), obj);     
    }

    /**
     * 从ThreadLocal中获取数据
     * @return
     */
    public T get(){
        return map.get(Thread.currentThread());
    }

    /**
     * 移除ThreadLocal当中的数据
     */
    public void remove(){
        map.remove(Thread.currentThread());
    }
}

Thread是lang包下的。lang包下的都不需要导直接可以用。

由于每一次都是调用DBUtil的getConnection方法来获取Connection对象，而DBUtil的getConnection方法调用MyThreadLocal.get();方法，所以我们所需要Connection的类、DBUtil类、MyThreadLocal类都是同一线程，而MyThreadLocal类通过Map使得线程与Connection对象是一一对应的，只要线程相同，那么Connection对象相同。

基于ThreadLocal改进的DBUtil

package com.powernode.bank.utils;

import java.sql.*;
import java.util.ResourceBundle;


public class DBUtil {

    private static ResourceBundle bundle = ResourceBundle.getBundle("resources/jdbc");
    private static String driver = bundle.getString("driver");
    private static String url = bundle.getString("url");
    private static String user = bundle.getString("user");
    private static String password = bundle.getString("password");

    // 不让创建对象，因为工具类中的方法都是静态的。不需要创建对象。
    // 为了防止创建对象，故将构造方法私有化。
    private DBUtil(){}

    // DBUtil类加载时注册驱动
    static {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    // 这个对象实际上在服务器中只有一个。
    private static ThreadLocal<Connection> local = new ThreadLocal<>();

    /**
     * 这里没有使用数据库连接池，直接创建连接对象。
     * @return 连接对象
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        Connection conn = local.get();
        if (conn == null) {
            conn = DriverManager.getConnection(url, user, password);
            local.set(conn);
        }
        return conn;
    }

    /**
     * 关闭资源
     * @param conn 连接对象
     * @param stmt 数据库操作对象
     * @param rs 结果集对象
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs){
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
                // 思考一下：为什么conn关闭之后，这里要从大Map中移除呢？
                // 根本原因是：Tomcat服务器是支持线程池的。也就是说一个人用过了t1线程，t1线程还有可能被其他用户使用。从而拿到一个已经关闭了的Connection，引发系统错误
                // 也就是说当close之后，这个connection对象就已经失效了，存在里边儿也没有意义了;如果还有下一个新的且相同线程进行进来，那么如果不remove，那么会访问到已经失效的connection
                local.remove();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }

}

关闭Connection对象的时候记得把它从ThreadLocal的Map集合中移除。

秦矜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 连接数据库公共类,常用公共类代码一之数据库的连接
weixin_34392511的博客
03-14 599
在项目中，我们经常会写到一些公共的代码，来让开发人员调用，减少代码重复，下面，我就将一些常用到的公共类贴出来和大家分享！！一、数据库的连接，常用的方式有直接将那些要连接的参数放到java类中、将连接参数放到Properties文件中或者放到XML文件中，下面一一为大家描述1、直接连接：[java] 普通的配置方式public static Connection getConnecti...
理解ThreadLocal
12-25
ThreadLocal 详解 ThreadLocal 是 Java 中一个非常重要的类，它为解决多线程程序的并发问题提供了一种新的思路。ThreadLocal 并不是一个 Thread，而是 Thread 的局部变量，它为每个使用该变量的线程提供独立的变量...
2024.3.19@spring框架学习笔记
qq_39551449的博客
03-20 393
Spring在这两种动态代理中灵活切换，如果是代理接口，会默认使用JDK动态代理，如果要代理某个类，这个类没有实现接口，就会切换使用CGLIB。//获取目标方法的签名。--spring容器在扫描类的时候，查看该类上是否有@Aspect注解，如果有，则给这个类生成代理对象. -->--spring容器在扫描类的时候，查看该类上是否有@Aspect注解，如果有，则给这个类生成代理对象. -->--spring容器在扫描类的时候，查看该类上是否有@Aspect注解，如果有，则给这个类生成代理对象. -->
Java之路（十一）：DAO优化
Cherry
05-01 356
DAO的重构 1.PreparedStatement（预编译处理语句） Statement接口只能实现静态SQL语句，我们使用PreparedStatement。 PreparedStatement是Statement子接口，表示预编译语句对象，通过占位符?来拼接SQL 创建预编译语句对象 @Test public void testSaveByPreparedStat...
jdbc批量插入的4种方式
顺其自然~专栏
10-11 2436
Mysql批量插入数据。
JDBC封装-Java（新手）
L的博客
04-11 203
JDBC封装-Java（新手） JDBC的封装，自己总结的自己总结的自己总结的 dao （代码分层）命名规范： 　　　　1、com.XXX.dao 　　 存放dao相关的类型 例如 StudentDAOImpl 处理 数据库的链接 存取数据 　　　　2、com.XXX.serv...
线程局部副本ThreadLocal之正解
坚持住啊
06-01 198
 本文将介绍ThreadLocal的用法，并且指出大部分人对ThreadLocal的误区。 先来看一下ThreadLocal的API： 1、构造方法摘要 ThreadLocal()：创建一个线程本地变量。 2、方法摘要 void set(T value)：将此线程局部变量的当前线程副本中的值设置为指定值。T get()：返回此线程局部变量的当前线程副本中的值。void remove()：移除此线程局部变量当前线程的值。protected T initialValue()：返回此线程局部变量...
并发基础（十） 线程局部副本ThreadLocal之正解
好好学java
07-25 525
什么是ThreadLocal ThreadLocal是线程局部变量，所谓的线程局部变量，就是仅仅只能被本线程访问，不能在线程之间进行共享访问的变量。在各个Java web的各种框架中ThreadLocal几乎已经被用烂了，spring中有使用，mybatis中也有使用，hibernate中也有使用，甚至我们写个分页也用ThreadLocal来传递参数……这也从侧面说明了ThreadLocal十分...
ThreadLocal
12-21
ThreadLocal是Java编程语言中的一个类，用于在多线程环境中提供线程局部变量。它是一种特殊类型的变量，每个线程都有自己的副本，互不影响，从而实现线程间数据隔离。ThreadLocal通常被用来解决线程共享数据时可能...
ThreadLocal相关
06-19
ThreadLocal 相关知识点 ThreadLocal 是 Java 语言中的一种机制，用于提供线程内部的局部变量。在多线程环境下，ThreadLocal 变量可以保证各个线程的变量相对独立于其他线程内的变量。这种机制可以帮助开发者在多...
ThreadLocal.pdf
04-13
ThreadLocal
ThreadLocal详解.md
10-31
学习ThreadLocal，了解其中的原理，以及学习其中的优点！避免坑点！！
配置Java开发环境
Broken_x的博客
07-10 1608
Java开发环境配置
java集合工具类
药的博客
07-12 447
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 563
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 304
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 549
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 304
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

秦矜

对你有帮助的话，请我吃颗糖吧~

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

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

打赏作者

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

抵扣说明：

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

余额充值