美文网首页
多线程对spring数据库事务影响

多线程对spring数据库事务影响

作者: 定金喜 | 来源:发表于2020-06-06 23:01 被阅读0次

1.spring事务的配置

以mysql为例：

package com.renlijia.config;

import com.alibaba.druid.filter.Filter;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.wall.WallConfig;
import com.alibaba.druid.wall.WallFilter;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;
import org.springframework.transaction.support.TransactionTemplate;

import javax.annotation.Resource;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
  * @author well
  * @date 2019-05-07
  */
@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
@EnableTransactionManagement
@MapperScan(basePackages = {"com.renlijia.mybatis.dao"})
public class DruidConfig implements TransactionManagementConfigurer {

    private Logger logger = LoggerFactory.getLogger(DruidConfig.class);

    private String url;

    private String username;

    private String password;

    private String driverClassName = "com.mysql.jdbc.Driver";

    private int initialSize = 5;

    private int minIdle = 5;

    private int maxActive = 200;

    private int maxWait = 30000;

    private int timeBetweenEvictionRunsMillis = 60000;

    private int minEvictableIdleTimeMillis = 300000;

    private String validationQuery = "SELECT 1 FROM DUAL";

    private boolean testWhileIdle = true;

    private boolean testOnBorrow = false;

    private boolean testOnReturn = false;

    private boolean poolPreparedStatements = true;

    private int maxPoolPreparedStatementPerConnectionSize = 20;

    private String filters = "stat,wall";

    private String connectionProperties = "druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000";

    @Resource
    private WallFilter wallFilter;

    @Bean(name = "sqlSessionFactory")
    @Primary
    public SqlSessionFactoryBean createSqlSessionFactoryBean(DataSourceTransactionManager transactionManager) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(transactionManager.getDataSource());
        sqlSessionFactoryBean.setConfigLocation(new ClassPathResource("sqlmap-config.xml"));
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath*:/mybatis/**/*.xml"));
        sqlSessionFactoryBean.setVfs(SpringBootVFS.class);
        sqlSessionFactoryBean.setTypeAliasesPackage("com.renlijia.mybatis.model");
        return sqlSessionFactoryBean;
    }

    @Bean
    @Primary
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    @Primary
    @Override
    public DataSourceTransactionManager annotationDrivenTransactionManager() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setInitialSize(initialSize);
        dataSource.setMinIdle(minIdle);
        dataSource.setMaxActive(maxActive);
        dataSource.setMaxWait(maxWait);
        dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        dataSource.setValidationQuery(validationQuery);
        dataSource.setTestWhileIdle(testWhileIdle);
        dataSource.setTestOnBorrow(testOnBorrow);
        dataSource.setTestOnReturn(testOnReturn);
        dataSource.setPoolPreparedStatements(poolPreparedStatements);
        dataSource.setConnectionProperties(connectionProperties);
        dataSource.setConnectionInitSqls(Arrays.asList("SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci;"));
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);

        //配置数据库批量更新，需要WallConfig设置multiStatementAllow=true
        List<Filter> proxyFilters = new ArrayList<>();
        proxyFilters.add(wallFilter);
        dataSource.setProxyFilters(proxyFilters);

        try {
            dataSource.setFilters(filters);
        } catch (SQLException e) {
            logger.error("druid configuration initialization filter", e);
        }
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "wallConfig")
    WallConfig wallFilterConfig() {
        WallConfig wc = new WallConfig();
        wc.setMultiStatementAllow(true);
        return wc;
    }

    @Bean(name = "wallFilter")
    @DependsOn("wallConfig")
    WallFilter wallFilter(WallConfig wallConfig) {
        WallFilter wfilter = new WallFilter();
        wfilter.setConfig(wallConfig);
        return wfilter;
    }

    @Bean
    public TransactionTemplate transactionTemplate(DataSourceTransactionManager transactionManager) {
        return new TransactionTemplate(transactionManager);
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public void setMaxWait(int maxWait) {
        this.maxWait = maxWait;
    }

    public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }

    public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }

    public void setFilters(String filters) {
        this.filters = filters;
    }

    public void setConnectionProperties(String connectionProperties) {
        this.connectionProperties = connectionProperties;
    }
}

2.编写测试例子

package com.renlijia.concurrent;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.renlijia.mybatis.dao.PersonDAO;
import com.renlijia.mybatis.model.PersonDO;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author: ding
 * @Date: 2020-06-06 14:11
 */
@RestController
public class Controller {

    @Resource
    private PersonDAO personDAO;

    @Resource
    private TransactionTemplate transactionTemplate;

    private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR;


    static {
        // 初始化线程池
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("track-log-%d").build();
        THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(5, 10, 0L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(200), threadFactory, new ThreadPoolExecutor.AbortPolicy());
    }

    @RequestMapping("/concurrent/multithread")
    public String multiThreadTest(){

        transactionTemplate.execute((status)->{
            PersonDO personDO = new PersonDO();
            personDO.setName("黄晓明");
            personDO.setAge(35);
            personDAO.insert(personDO);

            THREAD_POOL_EXECUTOR.execute(()->{
                PersonDO personDO2 = new PersonDO();
                personDO2.setName("周迅");
                personDO2.setAge(48);
                personDAO.insert(personDO2);
            });

            PersonDO personDO3 = new PersonDO();
            personDO3.setName("刘德华");
            personDO3.setAge(55);
            personDAO.insert(personDO3);
            throw new RuntimeException();
        });

        return null;
    }
}

此例子中直接抛出RuntimeException会导致该线程所对应的事务回滚，所以黄晓明和刘德华这两条数据不会插入到数据库，但是因为建立一个线程池THREAD_POOL_EXECUTOR执行了一个新的线程插入了一条周迅的数据，该数据成功入库没有回滚，所以得出结论，事务只对当前线程有效，我们从源码进行分析。

3.源码分析

获取数据连接
org.mybatis.spring.transaction.SpringManagedTransaction#openConnection

private void openConnection() throws SQLException {
        this.connection = DataSourceUtils.getConnection(this.dataSource);
        this.autoCommit = this.connection.getAutoCommit();
        this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("JDBC Connection [" + this.connection + "] will" + (this.isConnectionTransactional ? " " : " not ") + "be managed by Spring");
        }
    }

跟踪代码到org.springframework.transaction.support.TransactionSynchronizationManager#doGetResource

@Nullable
    private static Object doGetResource(Object actualKey) {
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            return null;
        } else {
            Object value = map.get(actualKey);
            if (value instanceof ResourceHolder && ((ResourceHolder)value).isVoid()) {
                map.remove(actualKey);
                if (map.isEmpty()) {
                    resources.remove();
                }

                value = null;
            }

            return value;
        }
    }

resources定义为：
private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal("Transactional resources");
resources为ThreadLocal类型，ThreadLocal类型只针对当前线程有效，所以当在事务中新建一个线程后，获取的数据库连接不同，而事务不能跨连接，所以上述场景只有主线程的事务会回滚。如果需要新的线程回滚，则在新线程里也加事务，代码改为：

package com.renlijia.concurrent;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.renlijia.mybatis.dao.PersonDAO;
import com.renlijia.mybatis.model.PersonDO;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author: ding
 * @Date: 2020-06-06 14:11
 */
@RestController
public class Controller {

    @Resource
    private PersonDAO personDAO;

    @Resource
    private TransactionTemplate transactionTemplate;

    private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR;


    static {
        // 初始化线程池
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("track-log-%d").build();
        THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(5, 10, 0L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(200), threadFactory, new ThreadPoolExecutor.AbortPolicy());
    }

    @RequestMapping("/concurrent/multithread")
    public String multiThreadTest(){

        transactionTemplate.execute((status)->{
            PersonDO personDO = new PersonDO();
            personDO.setName("黄晓明");
            personDO.setAge(35);
            personDAO.insert(personDO);


            THREAD_POOL_EXECUTOR.execute(()->{
               transactionTemplate.execute((transactionStatus)->{
                    PersonDO personDO2 = new PersonDO();
                    personDO2.setName("周迅");
                    personDO2.setAge(48);
                    personDAO.insert(personDO2);
                    return true;
                });
            });

            PersonDO personDO3 = new PersonDO();
            personDO3.setName("刘德华");
            personDO3.setAge(55);
            personDAO.insert(personDO3);
            throw new RuntimeException();
        });

        return null;
    }
}

参考文章：
https://www.cnblogs.com/dongying/p/4142476.html

相关文章

  • 多线程对spring数据库事务影响

    1.spring事务的配置 以mysql为例： 2.编写测试例子 此例子中直接抛出RuntimeException...

  • spring事务的实现原理

    spring实现事务的原理 Spring事务 的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring...

  • Spring事务之编程式事务

    一.Spring对编程式事务的支持 Spring中的事务分为物理事务和逻辑事务；物理事务：就是底层数据库提供的事务...

  • 面试问题总结

    1.spring对mybatis的事务管理是怎么支持的 一、事务的基本原理 Spring事务的本质其实就是数据库对...

  • Spring中实现事务方式

    Spring 中实现事务的方式 Spring 并不直接支持事务，只有当数据库支持事务时，Spring 才支持事务，...

  • Spring 事务实现分析

    1. Spring 事务简介 Spring 本身并不实现事务，Spring事务 的本质 还是 底层数据库 对事务的...

  • Spring框架原理分析

    Spring 事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring 是无法提供事务功能的。真正...

  • JAVA-每日一面 2022-01-19

    Spring 事务底层原理 a、划分处理单元——IOC 由于 spring 解决的问题是对单个数据库进行局部事务处...

  • Spring基础目录/知识图谱

    目录 Spring IOC Spring Bean 面向切面编程 Spring和数据库 Spring数据库事务管理...

  • 升职加薪的必备良品之玩转Spring事务源码

    今日内容： 1.什么是数据库的事务? 2.为什么说Spring的事务就是数据库的事务? 3. 实现Spring事务...

网友评论

      本文标题：多线程对spring数据库事务影响

      本文链接：https://www.haomeiwen.com/subject/hroxtktx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|多线程对spring数据库事务影响|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！