记-数据库事务隔离级别

最新推荐文章于 2024-02-01 17:25:21 发布
最新推荐文章于 2024-02-01 17:25:21 发布
阅读量548 收藏 1
点赞数
分类专栏： 问题汇总 数据库 文章标签： 数据库 事务隔离级别 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ory001/article/details/133126179
版权

记-数据库事务隔离级别

一、MySQL数据库默认隔离级别

MySQL数据库默认事务隔离级别为REPEATABLE-READ，大型互联网公司一般建议改成READ-COMMITTED，通过降低间隙锁概率，以提升事务性能。（顺便提一句，Oracle数据库默认事务隔离级别是READ-COMMITTED）

  • 查看数据库事务隔离级别
show variables like '%tx_isolation%';

注： 使用DBeaver数据库连接工具查询事务隔离级别时，要确认是否修改过工具的默认事务隔离级别，若修改过DBeaver数据库连接工具的默认事务隔离级别，查询结果可能和预期的不一致。因此建议使用原生的mysql cmd工具查看事务隔离级别。

二、JDBC连接的事务隔离级别

JDBC连接的事务隔离级别默认取数据库服务端设置的默认隔离级别，也就是show variables like '%tx_isolation%'查询结果

1. 查看JDBC连接的事务隔离级别

以MyBatis框架为例，Debug跟踪当前SqlSession，查看org.apache.ibatis.session.SqlSession#getConnection对象使用的原生Connection对象(com.mysql.cj.jdbc.ConnectionImpl)查看isolationLevel属性值即可！

  /**
     * A constant indicating that transactions are not supported.
     */
    int TRANSACTION_NONE             = 0;

    /**
     * A constant indicating that
     * dirty reads, non-repeatable reads and phantom reads can occur.
     * This level allows a row changed by one transaction to be read
     * by another transaction before any changes in that row have been
     * committed (a "dirty read").  If any of the changes are rolled back,
     * the second transaction will have retrieved an invalid row.
     */
    int TRANSACTION_READ_UNCOMMITTED = 1;

    /**
     * A constant indicating that
     * dirty reads are prevented; non-repeatable reads and phantom
     * reads can occur.  This level only prohibits a transaction
     * from reading a row with uncommitted changes in it.
     */
    int TRANSACTION_READ_COMMITTED   = 2;

    /**
     * A constant indicating that
     * dirty reads and non-repeatable reads are prevented; phantom
     * reads can occur.  This level prohibits a transaction from
     * reading a row with uncommitted changes in it, and it also
     * prohibits the situation where one transaction reads a row,
     * a second transaction alters the row, and the first transaction
     * rereads the row, getting different values the second time
     * (a "non-repeatable read").
     */
    int TRANSACTION_REPEATABLE_READ  = 4;

    /**
     * A constant indicating that
     * dirty reads, non-repeatable reads and phantom reads are prevented.
     * This level includes the prohibitions in
     * <code>TRANSACTION_REPEATABLE_READ</code> and further prohibits the
     * situation where one transaction reads all rows that satisfy
     * a <code>WHERE</code> condition, a second transaction inserts a row that
     * satisfies that <code>WHERE</code> condition, and the first transaction
     * rereads for the same condition, retrieving the additional
     * "phantom" row in the second read.
     */
    int TRANSACTION_SERIALIZABLE     = 8;

    /**
     * Attempts to change the transaction isolation level for this
     * <code>Connection</code> object to the one given.
     * The constants defined in the interface <code>Connection</code>
     * are the possible transaction isolation levels.
     * <P>
     * <B>Note:</B> If this method is called during a transaction, the result
     * is implementation-defined.
     *
     * @param level one of the following <code>Connection</code> constants:
     *        <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
     *        <code>Connection.TRANSACTION_READ_COMMITTED</code>,
     *        <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
     *        <code>Connection.TRANSACTION_SERIALIZABLE</code>.
     *        (Note that <code>Connection.TRANSACTION_NONE</code> cannot be used
     *        because it specifies that transactions are not supported.)
     * @exception SQLException if a database access error occurs, this
     * method is called on a closed connection
     *            or the given parameter is not one of the <code>Connection</code>
     *            constants
     * @see DatabaseMetaData#supportsTransactionIsolationLevel
     * @see #getTransactionIsolation
     */
    void setTransactionIsolation(int level) throws SQLException;
2. JDBC连接的事务隔离级别设置过程

JDBC SPI加载机制

com.mysql.cj.jdbc.ConnectionImpl#ConnectionImpl(com.mysql.cj.conf.HostInfo)

==>

com.mysql.cj.jdbc.ConnectionImpl#createNewIO

==>

com.mysql.cj.jdbc.ConnectionImpl#connectOneTryOnly

==>

com.mysql.cj.jdbc.ConnectionImpl#initializePropsFromServer

==> 查询服务端变量transaction_isolation（别名）和tx_isolation

com.mysql.cj.jdbc.ConnectionImpl#checkTransactionIsolationLevel

/**
     * Set transaction isolation level to the value received from server if any.
     * Is called by connectionInit(...)
     */
    private void checkTransactionIsolationLevel() {
        String s = this.session.getServerSession().getServerVariable("transaction_isolation");
        if (s == null) {
            s = this.session.getServerSession().getServerVariable("tx_isolation");
        }

        if (s != null) {
            Integer intTI = mapTransIsolationNameToValue.get(s);

            if (intTI != null) {
                this.isolationLevel = intTI.intValue();
            }
        }
    }
  • 从服务端加载变量

在这里插入图片描述

com.mysql.cj.NativeSession#loadServerVariables

/**
     * Loads the result of 'SHOW VARIABLES' into the serverVariables field so
     * that the driver can configure itself.
     * 
     * @param syncMutex
     *            synchronization mutex
     * @param version
     *            driver version string
     */
    public void loadServerVariables(Object syncMutex, String version) {

        if (this.cacheServerConfiguration.getValue()) {
            createConfigCacheIfNeeded(syncMutex);

            Map<String, String> cachedVariableMap = this.serverConfigCache.get(this.hostInfo.getDatabaseUrl());

            if (cachedVariableMap != null) {
                String cachedServerVersion = cachedVariableMap.get(SERVER_VERSION_STRING_VAR_NAME);

                if (cachedServerVersion != null && getServerSession().getServerVersion() != null
                        && cachedServerVersion.equals(getServerSession().getServerVersion().toString())) {
                    this.protocol.getServerSession().setServerVariables(cachedVariableMap);

                    return;
                }

                this.serverConfigCache.invalidate(this.hostInfo.getDatabaseUrl());
            }
        }

        try {
            if (version != null && version.indexOf('*') != -1) {
                StringBuilder buf = new StringBuilder(version.length() + 10);
                for (int i = 0; i < version.length(); i++) {
                    char c = version.charAt(i);
                    buf.append(c == '*' ? "[star]" : c);
                }
                version = buf.toString();
            }

            String versionComment = (this.propertySet.getBooleanProperty(PropertyDefinitions.PNAME_paranoid).getValue() || version == null) ? ""
                    : "/* " + version + " */";

            this.protocol.getServerSession().setServerVariables(new HashMap<String, String>());

            if (versionMeetsMinimum(5, 1, 0)) {
                StringBuilder queryBuf = new StringBuilder(versionComment).append("SELECT");
                queryBuf.append("  @@session.auto_increment_increment AS auto_increment_increment");
                queryBuf.append(", @@character_set_client AS character_set_client");
                queryBuf.append(", @@character_set_connection AS character_set_connection");
                queryBuf.append(", @@character_set_results AS character_set_results");
                queryBuf.append(", @@character_set_server AS character_set_server");
                queryBuf.append(", @@collation_server AS collation_server");
                queryBuf.append(", @@init_connect AS init_connect");
                queryBuf.append(", @@interactive_timeout AS interactive_timeout");
                if (!versionMeetsMinimum(5, 5, 0)) {
                    queryBuf.append(", @@language AS language");
                }
                queryBuf.append(", @@license AS license");
                queryBuf.append(", @@lower_case_table_names AS lower_case_table_names");
                queryBuf.append(", @@max_allowed_packet AS max_allowed_packet");
                queryBuf.append(", @@net_write_timeout AS net_write_timeout");
                if (!versionMeetsMinimum(8, 0, 3)) {
                    queryBuf.append(", @@query_cache_size AS query_cache_size");
                    queryBuf.append(", @@query_cache_type AS query_cache_type");
                }
                queryBuf.append(", @@sql_mode AS sql_mode");
                queryBuf.append(", @@system_time_zone AS system_time_zone");
                queryBuf.append(", @@time_zone AS time_zone");
                if (versionMeetsMinimum(8, 0, 3) || (versionMeetsMinimum(5, 7, 20) && !versionMeetsMinimum(8, 0, 0))) {
                    queryBuf.append(", @@transaction_isolation AS transaction_isolation");
                } else {
                    queryBuf.append(", @@tx_isolation AS transaction_isolation");
                }
                queryBuf.append(", @@wait_timeout AS wait_timeout");

                NativePacketPayload resultPacket = sendCommand(this.commandBuilder.buildComQuery(null, queryBuf.toString()), false, 0);
                Resultset rs = ((NativeProtocol) this.protocol).readAllResults(-1, false, resultPacket, false, null,
                        new ResultsetFactory(Type.FORWARD_ONLY, null));
                Field[] f = rs.getColumnDefinition().getFields();
                if (f.length > 0) {
                    ValueFactory<String> vf = new StringValueFactory(f[0].getEncoding());
                    Row r;
                    if ((r = rs.getRows().next()) != null) {
                        for (int i = 0; i < f.length; i++) {
                            this.protocol.getServerSession().getServerVariables().put(f[i].getColumnLabel(), r.getValue(i, vf));
                        }
                    }
                }

            } else {
                NativePacketPayload resultPacket = sendCommand(this.commandBuilder.buildComQuery(null, versionComment + "SHOW VARIABLES"), false, 0);
                Resultset rs = ((NativeProtocol) this.protocol).readAllResults(-1, false, resultPacket, false, null,
                        new ResultsetFactory(Type.FORWARD_ONLY, null));
                ValueFactory<String> vf = new StringValueFactory(rs.getColumnDefinition().getFields()[0].getEncoding());
                Row r;
                while ((r = rs.getRows().next()) != null) {
                    this.protocol.getServerSession().getServerVariables().put(r.getValue(0, vf), r.getValue(1, vf));
                }
            }
        } catch (PasswordExpiredException ex) {
            if (this.disconnectOnExpiredPasswords.getValue()) {
                throw ex;
            }
        } catch (IOException e) {
            throw ExceptionFactory.createException(e.getMessage(), e);
        }

        if (this.cacheServerConfiguration.getValue()) {
 // 缓存服务端变量
            this.protocol.getServerSession().getServerVariables().put(SERVER_VERSION_STRING_VAR_NAME, getServerSession().getServerVersion().toString());
            this.serverConfigCache.put(this.hostInfo.getDatabaseUrl(), this.protocol.getServerSession().getServerVariables());
        }
    }

上面代码本质是执行select语句查询MySQL服务端变量

select  @@session.auto_increment_increment AS auto_increment_increment, @@character_set_client AS character_set_client, @@character_set_connection AS character_set_connection, @@character_set_results AS character_set_results, @@character_set_server AS character_set_server, @@collation_server AS collation_server, @@init_connect AS init_connect, @@interactive_timeout AS interactive_timeout, @@license AS license, @@lower_case_table_names AS lower_case_table_names, @@max_allowed_packet AS max_allowed_packet, @@net_write_timeout AS net_write_timeout, @@query_cache_size AS query_cache_size, @@query_cache_type AS query_cache_type, @@sql_mode AS sql_mode, @@system_time_zone AS system_time_zone, @@time_zone AS time_zone, @@tx_isolation AS transaction_isolation, @@wait_timeout AS wait_timeout

三、修改JDBC连接的事务隔离级别

1. 全局修改

java.sql.Connection#TRANSACTION_REPEATABLE_READ

  • Druid数据源

com.alibaba.druid.pool.DruidAbstractDataSource#defaultTransactionIsolation

          druid:
            defaultTransactionIsolation: 2
  • Hikari数据源

com.zaxxer.hikari.HikariConfig#transactionIsolationName

    hikari:
      transactionIsolationName: TRANSACTION_READ_COMMITTED
2. 局部修改
@Transactional(isolation = Isolation.READ_COMMITTED)

参考：

查-MySQL 常用语句速查

源码分析-JDBC SPI加载机制

springboot @ConfigurationProperties注解源码解析（含松散绑定）

搬山境KL攻城狮
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ORACLE数据库事务隔离级别介绍
12-16
两个并发事务同时访问数据库表相同的行时，可能存在以下三个问题： 1、幻想读：事务T1读取一条指定where条件的语句，返回结果集。此时事务T2插入一行新记录，恰好满足T1的where条件。然后T1使用相同的条件再次查询，结果集中可以看到T2插入的记录，这条新纪录就是幻想。 2、不可重复读取：事务T1读取一行记录，紧接着事务T2修改了T1刚刚读取的记录，然后T1再次查询，发现与第一次读取的记录不同，这称为不可重复读。 3、脏读：事务T1更新了一行记录，还未提交所做的修改，这个T2读取了更新后的数据，然后T1执行回滚操作，取消刚才的修改，所以T2所读取的行就无效，也就是脏数据。 一、为了处理这些问
MySQL数据库事务隔离级别详解
12-16
数据库事务隔离级别 数据库事务的隔离级别有4个，由低到高依次为 Read uncommitted：允许脏读。 Read committed： 防止脏读，最常用的隔离级别,并且是大多数数据库的默认隔离级别。 Repeatable read：可以防止脏读和不可重复读。 Serializable：可以防止脏读，不可重复读取和幻读，（事务串行化）会降低数据库的效率。 这四个级别可以逐个解决脏读 、不可重复读 、幻读 这几类问题。 √: 可能出现 ×: 不会出现 事务级别 脏读 不可重复读 幻读 Read uncommitted √ √ √ Read committed
【图例】直观的感受MySQL事务的隔离级别分别解决了什么问题？以及如何查看和设置事务隔离级别！
最新发布
DD-Blog
02-01 521
在MySQL中，事务的隔离级别决定了一个事务可能受其他并发事务影响的程度。可重复读作为默认的隔离级别，确保了在同一个事务中，多次读取同一行数据的结果都是一致的。-查看隔离级别： 设置隔离级别。
MySQL数据库事务隔离级别
02-26
数据库隔离级别有四种，应用《高性能mysql》一书中的说明：然后说说修改事务隔离级别的方法：1.全局修改，修改mysql.ini配置文件，在最后加上#可选参数有：READ-UNCOMMITTED,READ-COMMITTED,REPEATABLE-READ,SERIALIZABLE.2[mysqld]3transaction-isolation=REPEATABLE-READ这里全局默认是REPEATABLE-READ,其实MySQL本来默认也是这个级别2.对当前session修改，在登录mysql客户端后，执行命令：要记住mysql有一个autocommit参数，默认是on，他的作用是每一条
常见的数据库事务隔离级别
12-14
为什么会出现数据库的隔离级别呢? 数据库隔离级别是为了解决数据库并发访问过程中产生的各种数据安全问题. 事务的基本要素（ACID） 原子性（Atomicity）：事务开始后所有操作，要么全部做完，要么全部不做，不可能停滞在中间环节。事务执行过程中出错，会回滚到事务开始前的状态，所有的操作就像没有发生一样。也就是说事务是一个不可分割的整体，就像化学中学过的原子，是物质构成的基本单位。 一致性（Consistency）：事务开始前和结束后，数据库的完整性约束没有被破坏 。比如A向B转账，不可能A扣了钱，B却没收到。 隔离性（Isolation）：同一时间，只允许一个事务请求同一数据，不同的事务之间
查看数据库隔离级别,mysql
zf0512305的博客
01-28 2780
1.查看当前会话隔离级别 select @@tx_isolation; 2.查看系统当前隔离级别 select @@global.tx_isolation; 3.设置当前会话隔离级别 set session transaction isolatin level repeatable read; 4.设置系统当前隔离级别 set global transac...
mysql数据库事务隔离级别的查看、设置、以及隔离级别有效范围的设置
qq_41544627的博客
10-15 8436
事务基于数据库连接，我们将一个数据库会话看作一个事务）：session A、session B、session C。会话范围：对当前会话的后续的事务有效，对之前的事务无效；思考1:设置了global的有效范围，当前会话查看应该仍然是 repeatable-read；因为我们之前说过global对于当前存在的会话是不会生效的，之后新的会话才有效；根据结果，上面的思考预期是正确的，我们的理论也是得到了验证；重启数据库可以自己验证。全局范围和会话范围都是基于内存的，重启mysql之后又会回到默认的隔离级别。
数据库事务隔离级别
tiantiantbtb的博客
06-13 962
读已提交存在的问题是:不可重复读.--->不可重复读的意思:开启事务,当别人一直在改变 数据时,每次查询的数据不一致。读未提交存在脏读(Dirty Read)现象:表示读到了脏的数据.（未提交,读到的是缓存中的数据）第二级别:读已提交(read committed)----->这种隔离级别解决了脏读现象。事务隔离性存在隔离级别,理论上隔离级别包括4个: 理论上有4个级别,但基本上所有数据库二档起步,但是效率低,事务排队。A:原子性:事务是最小的工作单元,不可再分.
数据库的4种隔离级别
C18298182575的博客
04-14 2819
在这个级别下，普通的查询同样是使用的“快照读”，但是，和“读提交”不同的是，当事务启动时，就不允许进行“修改操作（Update）”了，而“不可重复读”恰恰是因为两次读取之间进行了数据的修改，因此，“可重复读”能够有效的避免“不可重复读”，但却避免不了“幻读”，因为幻读是由于“插入或者删除操作（Insert or Delete）”而产生的。不可重复读：指在一个事务内，多次读同一数据。下，查询是不会加锁的，也由于查询的不加锁，所以这种隔离级别的一致性是最差的，可能会产生“脏读”、“不可重复读”、“幻读”。
mysql隔离级别查看与设置（各版本）
global_coding的博客
08-04 1113
mysql隔离级别查看与设置（各版本） Unknown system variable ‘tx_isolation’
Mysql事务隔离级别
m0_62946761的博客
09-20 8276
本篇文章介绍Mysql中的事务隔离级别，简单易懂，适合刚刚学习Mysql的萌新。
事务隔离级别有哪些?MySQL的默认隔离级别是?
m0_51684972的博客
11-22 1万+
事务隔离级别有哪些?MySQL的默认隔离级别是? SQL 标准定义了四个隔离级别： READ-UNCOMMITTED(读取未提交)： 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。 READ-COMMITTED(读取已提交)： 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生。 REPEATABLE-READ(可重复读)： 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。 SERI
【MySQL】事务及其隔离性/隔离级别
学了就忘是正常现象
06-29 2905
MySQL事务的隔离级别（只有innoDB解决了RR级别的幻读问题）
数据库事务的四种隔离级别
scorpio的博客
10-26 9850
数据库事务的四种隔离级别
MySQL事务隔离级别详解（全网最详细）
qq_53868937的博客
04-19 7139
在关系型数据库中，事务隔离级别是指多个并发事务之间的隔离程度MySQL 中事务的隔离级别一共分为四种，分别如下READ-UNCOMMITTED(读取未提交)： 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。READ-COMMITTED(读取已提交)： 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生。REPEATABLE-READ(可重复读)
数据库之事务隔离级别详解
热门推荐
qq_39939541的博客
04-30 1万+
儿子某一天去消费，花了8千元，然后他的父亲去查看他今天的消费记录（全表扫描，儿子事务开启），看到确实是花了8千元，就在这个时候，儿子花了1万买了一部电脑，即新增INSERT了一条消费记录，并提交。但是转账时父亲不小心按错了数字，按成10万/月，该钱已经打到儿子的账户，但是事务还没有提交，就在这时，儿子去查看自己的储蓄卡，发现转多了9万，以为凭空多了9万非常高兴。事务的隔离性是指在并发执行的多个事务中，每个事务的执行互不影响，每个事务都有自己独立的空间进行操作。儿子看到的是父亲还没提交事务时的数据。
mysql,oracle,sql server中的默认事务隔离级别查看,更改
Alex的博客
03-06 9357
第一节 好久没碰数据库了，只是想起自己当时在搞数据库的时候在事务隔离级别这块老是卡，似懂非懂的。现在想把这块整理出来，尽量用最简洁的语言描述出来，供新人参考。 首先创建一个表account。创建表的过程略过（由于InnoDB存储引擎支持事务，所以将表的存储引擎设置为InnoDB）。表的结构如下： 表结构 然后往表中插入两条数据，插入后结果如下： 数据 为了说明问题，我们打开两个...
mysql查看隔离级别
m0_51060165的博客
09-16 3459
mysql查看隔离级别 四种隔离级别： READ_UNCOMMITTED（读未提交） READ_COMMITTED（读已提交） REPEATABLE_READ（可重复读，MySQL默认） SERIALIZABLE（串行读） 设置mysql的隔离级别： //设置全局的隔离级别 命令：set global transaction isolation level 隔离级别名称; //设置的时会话级别 命令：set session transaction isolation level 隔离级别 //设置一次操作的
mysql事务隔离级别
山巅
02-17 2998
给一条记录加 Gap Lock，是锁住了这条记录前面的空隙，例如给 id 为 1 的记录加 Gap Lock，锁住的范围是 (-∞,1)，给 id 为 3 的记录加 Gap Lock，锁住的范围是 (1,3)，那么 id 为 10 后面的空隙怎么锁定呢？S 锁是共享锁，X 锁是排他锁，当我们加 S 锁或者 X 锁的时候，如果用到了索引，锁加在了某一条具体的记录上，那么这个锁也是一个记录锁（其实，记录锁，S 锁，X 锁，概念有一些重复的地方，但是描述的重点不一样）。综上，最终锁定的范围是 [89,95)。
数据库事务隔离级别理解
06-09
数据库事务隔离级别指的是多个事务同时操作同一个数据库时，数据库如何保证数据的一致性和隔离性。常见的事务隔离级别有四种： 1. 读未提交（Read Uncommitted）：最低的隔离级别，指允许一个事务读取另一个事务未提交的数据。该级别存在脏读、不可重复读、幻读等问题。 2. 读已提交（Read Committed）：指一个事务只能读取另一个事务已经提交的数据。该级别能够避免脏读问题，但是不可重复读和幻读问题仍然存在。 3. 可重复读（Repeatable Read）：指一个事务在执行过程中多次读取同一行数据时，能够保证所读取的数据是一致的。该级别能够避免脏读和不可重复读问题，但是幻读问题仍然存在。 4. 序列化（Serializable）：最高的隔离级别，指所有事务依次执行，相当于事务串行化执行。该级别能够避免脏读、不可重复读和幻读问题，但是会影响并发性能。 不同的隔离级别具有不同的优缺点，需要根据实际业务场景和性能要求进行选择。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

搬山境KL攻城狮

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值