ThreadLocal类及spring模拟多用户转账

最新推荐文章于 2024-04-08 13:16:07 发布
最新推荐文章于 2024-04-08 13:16:07 发布
阅读量198 收藏 1
点赞数 1
分类专栏： 面试 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42480555/article/details/118360633
版权

1.ThreadLocal类的作用

如果我们在多线程情况下不使用ThreadLoacl类：

public class MyDemo {
    private String content;
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public static void main(String[] args) {
        MyDemo myDemo = new MyDemo();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    myDemo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("-------------------------------------");
                    System.out.println(Thread.currentThread().getName() + "------->" + myDemo.getContent());
                }
            });
            t.setName("线程"+i);
            t.start();
        }
    }
}

运行结果：
在这里插入图片描述
可以看出当前线程可能取出了另外一个线程的数据。
ThreadLoal就是解决这种情况的，在多线程的场景下，通过提供线程内的局部变量，让每个线程都是相互独立的，不会相互干扰。

2.基本使用

常用方法

在这里插入图片描述
使用ThreadLocal类：

public class MyDemo {
    ThreadLocal<String> th = new ThreadLocal<>();
    private String content;
    public String getContent() {
//        return content;
        return th.get();
    }
    public void setContent(String content) {
        //this.content = content;
        th.set(content);
    }
    public static void main(String[] args) {
        MyDemo myDemo = new MyDemo();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    myDemo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("-------------------------------------");
                    System.out.println(Thread.currentThread().getName() + "------->" + myDemo.getContent());
                }
            });
            t.setName("线程"+i);
            t.start();
        }
    }
}

运行结果：
在这里插入图片描述

ThreadLocal内部实现

底层其实就是一个map集合，在调用set方法的时候，会自动将key值设置成当前线程对象，value则是你传进去的参数值。调用get方法的时候，会按照当前线程值作为key值获取到对应的value。

3.那么ThreadLocal和synchronized区别是什么呢

synchronizedThreadLocal
以时间换空间的方式，只提供一个变量锁，让不同的线程去排队访问。侧重于多个线程访问共享资源的同步以空间换时间的方式，为每个线程都提供了一个变量，从而实现互不干扰。侧重于多个线程让每个线程之间的数据相互隔离。

4.运用场景：事务管理

例如转账、简化就是进行加钱和减钱的操作。若同时有不同用户去转账，那么就需要去控制每个线程对应的数据，就是实现每个线程相互独立，互不干扰。
现在有个场景就是，多个用户去从druid连接池中获取connection连接，那么如果两个线程同时抢占一个连接怎么办呢？所以使用ThreadLocal类为每一个线程分配一个自己的连接对象。
那么我们就来实现一个简单转账小功能：
①导入依赖：

<dependencies>
	<!--mysql驱动-->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.47</version>
	</dependency>
	<!--druid连接池-->
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>1.1.15</version>
	</dependency>
	<!--dbUtils工具类-->
	<dependency>
		<groupId>commons-dbutils</groupId>
		<artifactId>commons-dbutils</artifactId>
		<version>1.6</version>
	</dependency>
	<!--spring核心-->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>5.1.5.RELEASE</version>
	</dependency>
	<!--junit-->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
	</dependency>
	<!--spring整合junit-->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>5.1.5.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
		<version>1.18.10</version>
	</dependency>
</dependencies>
<!--jdk版本锁定-->
<build>
	<plugins>
		<!-- 设置编译版本为1.8 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.1</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
				<encoding>UTF-8</encoding>
			</configuration>
		</plugin>
	</plugins>
</build>

②Account实体

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {

    private Integer id;
    private String name;
    private Double money;
}

③AccountDao接口和实现

public interface AccountDao {
    // 转出
    void outAccount(String outUser, Double money);
    // 转入
    void inAccount(String inUser, Double money);
}

在这里插入图片描述

@Repository
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private QueryRunner queryRunner;

    @Override
    public void outAccount(String outUser, Double money) {
        try {
            String sql = "update account set money = money - ? where name = ?";
            //可以手动控制事务
            queryRunner.update(connectionHolder.getConnection,sql, money,outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void inAccount(String inUser, Double money) {
        try {
            String sql = "update account set money = money + ? where name = ?";
            //可以手动控制事务
            queryRunner.update(connectionHolder.getConnection,sql, money,inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

★ConnectionHolder工具类，目的就是实现线程内对象的共享

@Component
public class ConnectionHolder {

    @Autowired
    private DataSource dataSource;

    private static final ThreadLocal<Connection> TL = new ThreadLocal<>();

    // 向线程内绑定 conn
    public void setConnection() {
        try {
            TL.set(dataSource.getConnection());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 从线程内获得 conn
    public Connection getConnection() {
        if (TL.get() == null) {
            setConnection();
        }
        return TL.get();
    }

    // 解除线程绑定 conn
    public void removeConnection() {
        TL.remove();
    }
}

★TransactionManager事务管理类，目的就是将service重复的事务代码抽取到工具类

@Component
public class TransactionManager {

    @Autowired
    private ConnectionHolder connectionHolder;

    // 开启事务
    public void begin(){
        // 将connection绑定到当前线程内
        connectionHolder.setConnection();
        // 从线程内获取conn
        Connection connection = connectionHolder.getConnection();
        try {
            // 开启事务
            connection.setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }



    // 提交事务
    public void commit(){
        // 从线程内获取conn
        Connection connection = connectionHolder.getConnection();
        try {
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    // 回滚事务
    public void rollback(){
        // 从线程内获取conn
        Connection connection = connectionHolder.getConnection();
        try {
            connection.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    // 释放资源
    public void release(){
        // 从线程内获取conn
        Connection connection = connectionHolder.getConnection();
        connectionHolder.removeConnection(); //线程解除
        try {
            connection.close();// 释放资源
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

④AccountService接口和实现

public interface AccountService {
    // 转账
    void transfer(String outUser, String inUser, Double money);
}

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Autowired
    private DataSource dataSource;

    @Autowired
    private ConnectionHolder connectionHolder;

    @Autowired
    private TransactionManager transactionManager;

    @Override
    public void transfer(String outUser, String inUser, Double money) {

        try {
            // 开启事务
            transactionManager.begin();

            // 业务操作 start
            accountDao.outAccount(outUser, money); // 转出

          //  int i = 1 / 0; // 制造bug

            accountDao.inAccount(inUser, money); // 转入
            // 业务操作 end

            // 提交事务
            transactionManager.commit();
        } catch (Exception e) {
            e.printStackTrace();
            // 回滚事务
            transactionManager.rollback();
        } finally {
            // 释放资源
            transactionManager.release();
        }

    }
}

⑤ spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="
       	http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
       	http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--开启注解组件扫描-->
    <context:component-scan base-package="com.itheima"/>
    
    <!--加载第三方properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    
    <!--第三方连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    
    <!--第三方queryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"/>
    </bean>
</beans>

⑥ 测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class AccountTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void test01() throws Exception {
        accountService.transfer("tom", "jack", 200d);
    }
}
ITLepeng
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发容器ThreadLocal实现银行转账功能
陌心的博客
10-14 245
ThreadLocal 在面试中经常提到，关于ThreadLocal使用不当造成OOM以及在特殊场景下，通过ThreadLocal可以轻松实现一些看起来复杂的功能，都说明值得花时间研究其原理。 ThreadLocal 不是 Thread，是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，对数据存储后，只有在线程中才可以获取到存储的数据，对于其他线程来说是无法获取到数据。可能这才是...
DBUtils以及相关案例 ThreadLocal概述 转账业务案例
不再的blog
02-11 308
一、DBUtils介绍 apache 可以仔细看下这篇博文:https://www.cnblogs.com/xdp-gacl/p/4007225.html 什么是dbutils，它的作用 DBUtils是java编程中的数据库操作实用工具，小巧简单实用。 DBUtils封装了对JDBC的操作，简化了JDBC操作。可以少写代码。 1.对于数据表的读操作，他可以把结果转换成List，A...
ThreadLocal来实现转账-----事务
quansiwen5307的博客
10-17 162
1、实体类 package bank; public class Account { private String cardNo; private String password; private String name; private double balance; public String getCardNo() { return cardNo; } public void setCardNo(String cardNo) { this.cardNo = cardNo; }
使用spring模拟转账，并实现异常事务回滚
最新发布
m0_68467925的博客
04-08 658
3）转账过程中发生异常（事务回滚），输出false，数据表数据不变。Service层是业务逻辑的核心。DAO层负责数据库操作。定义了金额操作的方法。结果异常，输出false，数据表内容不变。结果正常，输出true，数据表内容变化。使用配置类配置数据源、模板、事务回滚。pom.xml导入依赖。
Spring 事务管理 —— 模拟转账案例(基于注解的事务控制)
qq_44706044的博客
02-02 437
domain 不变 dao： package com.fy.dao.impl; import com.fy.dao.AccountDao; import com.fy.domain.Account; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core...
Spring+mybatis模拟银行转账
欢迎来到我的博客，一起学习Java！
09-11 1318
实体类： package com.bjsxt.pojo; import java.io.Serializable; public class Account implements Serializable { private int id; private String cno; private String pwd; private int ...
Java多线程编程中ThreadLocal类的用法及深入
12-24
早在 JDK 1.2 的时代，java.lang.ThreadLocal 就诞生了，它是为了解决多线程并发问题而设计的，只不过设计得有些难用，所以至今没有得到广泛使用。其实它还是挺有用的，不相信的话，我们一起来看看这个例子吧。 一个...
Java ThreadLocal类应用实战案例分析
08-25
主要介绍了Java ThreadLocal类应用,结合具体案例形式分析了java ThreadLocal类的功能、原理、用法及相关操作注意事项,需要的朋友可以参考下
Java 中ThreadLocal类详解
09-02
什么是ThreadLocal？顾名思义它是local variable（线程局部变量）。它的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突...
实例讲解Java并发编程之ThreadLocal类
09-03
主要介绍了实例讲解Java并发编程之ThreadLocal类,本文给出了模拟ThreadLocal、实用ThreadLocal等代码实例,需要的朋友可以参考下
java用ThreadLocal,事务的转账案例
qq_37951370的博客
12-07 160
页面内容 一。DruidUtil 工具类 public class DruidUtil { private static DataSource dataSource; private static ThreadLocal threadLocal=new ThreadLocal();//threadLocal线程只存一个值且与其他线程独立 static { try { //1. 创建Properties对象 Proper
Spring事务案例：模拟银行转账
机械工程跑路哥
02-01 1523
Spring事务作用：在【数据层】或【业务层】保证一些列数据库的操作同时成功、失败；
小demo（续）----------转账思想的简单实现（加入事务机制、ThreadLocal，异常处理优化）
cCENDD的博客
07-23 150
上篇博文链接：点击传送 此篇博文是对上篇博文中代码进行的改造 主要是加入了事务机制，简单来说就是将用到数据库的部分进行了事务的统一处理，使得用到的都是同一个事务（要把自动提交事务关闭，手动地进行提交，加入了ThreadLocal也保证了事务的统一性） 加入了ThreadLocal：ThreadLocal是一种基于当前线程安全的存取机制。我们把值存到ThreadLocal对象中时，只要当前线程还在，那么ThreadLocal对象中的值就还在。 数据库部分 与上篇博文中的数据库无异 前端页面部分 与上篇博文
Java多线程高并发之ThreadLocal详解
weixin_40780670的博客
09-17 772
在java多线程编程中，ThreadLocal是一个经常被大家提及的知识点，比如ThreadLocal的作用是什么？常用的使用场景有哪些?实现原理是什么等等，只有彻底理解透彻，才能游刃有余地应对，本篇文章就从这几个方面分析理解ThreadLocal： 1、ThreadLocal是什么 2、ThreadLocal的作用是什么 3、ThreadLocal源码分析 4、ThreadLocal内存泄漏问题 一、ThreadLocal是什么 ThreadLoal 变量，线程局部变量，可以这样理解：里面的对象是线程独
spring使用编程式事务管理实现银行中两个账户转账
qq_40135955的博客
03-12 995
spring使用编程式事务管理实习银行中两个账户转账 (不推荐使用，事务操作侵入业务逻辑代码) Spring 提供的事务模版类：org.springframework.transaction.support.TransactionTemplate 事务管理器：org.springframework.jdbc.datasource.DataSourceTransactionManager ...
Spring简单转账功能实现（事务管理）
qq_42337039的博客
07-31 546
编写properties文件 jdbc.driverClass = com.mysql.jdbc.Driver jdbc.jdbcUrl = jdbc:mysql://localhost:3306/spring jdbc.user = root jdbc.password = 123456 dao层编写 package com.xf.dao; /** * @author xfgg */ public interface AccountDao { /* 汇款 */ p
Java多线程----很多人问的ThreadLocal实现原理和过程（源码分析）
何义竏
07-07 302
Java线程—ThreadLocal 辨析ThreadLocal 用法（如有错误，欢迎指正！）与Synchonized 的比较ThreadLocal 实现ThreadLocal 解析get()---返回当前线程所对应的线程局部变量---get( )---getMap()---threadLocals---ThreadLocalMapset()---设置当前线程的线程局部变量的值---set()---getMap()---createMap()---ThreadLocalMap()---threadLocal
使用SpringBootAlibaba+Seata实现转账功能
https://hibernation0814.github.io/
05-06 335
目录 Seata的概念讲解及搭建 分布式事务 Seata简介 Seata的搭建 seata端数据库创建 业务端创建数据 修改配置 代码实现生成订单和转账功能 实现Seata seata使用 1.启动seata 2.配置文件 Seata的概念讲解及搭建 分布式事务 #概念 指的就是一个操作单元，在这个操作单元中的所有操作最终要保持一致的行为，要么所有操作都成功，要么所有的操作都被撤销。 指的就是一个操作单元，在这个操作单元中的所有操作最终要保持一致的行为，要么所有操作
spring（转账为例）四种实现方式一
m0_56125938的博客
04-05 446
Spring事务管理的四种方式（以银行转账为例） 一、事务的作用 将若干的数据库操作作为一个整体控制,一起成功或一起失败。 原子性：指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 一致性：指事务前后数据的完整性必须保持一致。 隔离性：指多个用户并发访问数据库时，一个用户的事务不能被其他用户的事务所干扰，多个并发事务之间数据要相互隔离。 持久性：指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，即时数据库发生故障也不应该对其有任何影响。 Spring提供了以下方法控制事务 a.
多线程06_张孝祥-ThreadLocal类及应用技巧
08-25
对于多线程编程，ThreadLocal类是一个非常有用的工具。它提供了线程本地变量的机制，使得每个线程都可以独立地存储和获取自己的变量副本。这在一些场景下非常有用，下面是一些ThreadLocal类的应用技巧： 1. 线程上...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值