On TransactionIsolation（5）different transaction

最新推荐文章于 2022-01-10 23:29:55 发布
最新推荐文章于 2022-01-10 23:29:55 发布
阅读量148 收藏
点赞数
分类专栏： DataBase 文章标签： isolation transaction mysql database
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kamputer/article/details/109331249
版权

目录

结论

测试代码

read_uncommited

read_commited

repeatable_read

serializable

根据代码来看，isolation是针对单个连接而言的，如果对于读和写使用不同的隔离级别会是什么效果呢？

结论

先说结论，如下

 write
read READ_UNCOMMITTEDREAD_COMMITTEDREPEATABLE_READSERIALIZABLE
READ_UNCOMMITTEDREAD_UNCOMMITTED
READ_COMMITTEDREAD_COMMITTED
REPEATABLE_READREPEATABLE_READ
SERIALIZABLESERIALIZABLE

也就是只有read这个connection的isolation对自己生效了，而write对自己没有影响。

测试代码

测试代码如下，我是使用的MqSql

package com.qbit;

import java.sql.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Transaction {

    public static void main(String[] args) throws Exception {
        Database database = new Mysql();
        database.test();
    }
}

class Mysql extends Database {

    @Override
    Connection connection() throws ClassNotFoundException, SQLException {
        Class.forName(com.mysql.cj.jdbc.Driver.class.getName());
        Connection out = DriverManager.getConnection("jdbc:mysql://172.23.47.6:3306/qbit", "root", "mima");
        return out;
    }
}

abstract class Database {
    private static final String[] ids = {"valueA", "valueB"};
    public static final String TRANSACTION_TABLE = "transaction_table_" + (System.currentTimeMillis() % 10000);

    abstract Connection connection() throws Exception;

    public void test() throws Exception {
        Connection connection = connection();
        connection.setAutoCommit(true);
        connection.createStatement().execute("create table " + TRANSACTION_TABLE + "(id varchar(15),curr_value int )");


        int[] isolations = new int[]{Connection.TRANSACTION_READ_UNCOMMITTED, Connection.TRANSACTION_READ_COMMITTED,
                Connection.TRANSACTION_REPEATABLE_READ, Connection.TRANSACTION_SERIALIZABLE};
        System.out.println("==========update==========");
        for (int isolationRead : isolations) {
            for (int isolationWrite : isolations) {
                init(connection);
                var readBefore = connection(isolationRead);
                if (null == readBefore) {
                    continue;
                }
                var readAfter = connection(isolationRead);
                var write = connection(isolationWrite);
                printTransaction("---------- Isolation Read:", isolationRead);
                printTransaction(" ---------- Isolation Write:", isolationWrite);
                System.out.println(" ----------");
                update(readBefore, write, readAfter);
                for (Connection c : new Connection[]{write, readBefore, readAfter}) {
                    try {
                        c.close();
                    } catch (Exception e) {
                        System.err.println("close fail");
                    }
                }
            }
        }
        System.out.println();
        System.out.println("==========insert==========");
        for (int isolationRead : isolations) {
            for (int isolationWrite : isolations) {
                var readBefore = connection(isolationRead);
                if (null == readBefore) {
                    continue;
                }
                var readAfter = connection(isolationRead);
                var write = connection(isolationWrite);
                printTransaction("Isolation Read:", isolationRead);
                printTransaction("Isolation Write:", isolationWrite);
                insert(readBefore, write, readAfter);
                for (Connection c : new Connection[]{write, readBefore, readAfter}) {
                    try {
                        c.close();
                    } catch (Exception e) {
                        System.err.println("close fail");
                    }
                }
            }
        }
        connection.close();
    }

    private void init(Connection connection) throws SQLException {
        connection.createStatement().execute("truncate " + TRANSACTION_TABLE);
        var insert = connection.prepareStatement("insert into " + TRANSACTION_TABLE + " values(?,0)");
        for (String id : ids) {
            insert.setString(1, id);
            insert.executeUpdate();
        }
    }

    private void insert(Connection readBefore, Connection write, Connection readAfter) throws SQLException, InterruptedException {
        print("[ReadBefore]init", readBefore, "1=1");
        var insert = write.prepareStatement("insert " + TRANSACTION_TABLE + " values(66,?)");
        for (var id : ids) {
            id = id + '_';
            System.out.println("insert " + TRANSACTION_TABLE + " values(66,'" + id + "')");
            insert.setString(1, id);
            insert.executeUpdate();
            print(readBefore, write, readAfter, "1=1");
        }
        write.commit();
        print(readBefore, write, readAfter, "1=1");
    }

    private void printTransaction(String info, int isolation) {
        System.out.print(info);
        System.out.print(toString(isolation));
    }

    private String toString(int isolation) {
        switch (isolation) {
            case Connection.TRANSACTION_READ_UNCOMMITTED:
                return "READ_UNCOMMITTED";
            case Connection.TRANSACTION_READ_COMMITTED:
                return "READ_COMMITTED";
            case Connection.TRANSACTION_REPEATABLE_READ:
                return "REPEATABLE_READ";
            case Connection.TRANSACTION_SERIALIZABLE:
                return "SERIALIZABLE";
            default:
                return null;
        }
    }

    ExecutorService executorService = Executors.newCachedThreadPool();

    private void update(Connection readBefore, Connection write, Connection readAfter) throws SQLException, InterruptedException {
        print("[ReadBefore]init", readBefore, "id='" + ids[0] + "'");
        var update = write.prepareStatement("update " + TRANSACTION_TABLE + " set curr_value=? where id=?");
        var id = ids[0];
        for (int i = 1; i < 3; i++) {
            System.out.println("update " + TRANSACTION_TABLE + " set curr_value=" + i + " where id='" + id + "'");
            update.setInt(1, i);
            update.setString(2, id);
            update.executeUpdate();
            print(readBefore, write, null , "id='"+id+"'");
        }
        write.commit();
        System.out.println("After commit for " + id);
        print(readBefore, write, null, "id='" + id + "'");

        id = ids[1];
        for (int i = 1; i < 3; i++) {
            System.out.println("update " + TRANSACTION_TABLE + " set curr_value=" + i + " where id='" + id + "'");
            update.setInt(1, i);
            update.setString(2, id);
            update.executeUpdate();
            print(null, write, readAfter, "1=1");
        }
        write.commit();
        System.out.println("After commit for " + id);
        print(readBefore, write, readAfter, "1=1");
    }

    protected void print(Connection readBefore, Connection write, Connection readAfter, String where) throws InterruptedException {
        executorService.submit(new Callable<Object>() {
            @Override
            public Object call() throws SQLException {
                print("[write]", write, where);
                return null;
            }
        });
        Thread.sleep(400);
        if(readBefore!=null) {
            executorService.submit(new Callable<Object>() {
                @Override
                public Object call() throws Exception {
                    print("[readBefore]", readBefore, where);
                    return null;
                }
            });
            Thread.sleep(400);
        }
        if (null == readAfter) {
            return;
        }
        executorService.submit(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                print("[readAfter]", readAfter, where);
                return null;
            }
        });
        Thread.sleep(400);
    }

    private void print(String info, Connection connection, String where) throws SQLException {
        System.out.println("\t" + info + ":");
        PreparedStatement select = connection.prepareStatement("select * from " + TRANSACTION_TABLE + " where " + where);
        ResultSet resultSet = select.executeQuery();
        while (resultSet.next()) {
            int currValue = resultSet.getInt(2);
            if (currValue == 1 && info.contains("read")) {
                System.err.println("\t\t\t" + resultSet.getString(1) + " | " + currValue);
            } else {
                System.out.println("\t\t\t" + resultSet.getString(1) + " | " + currValue);
            }
        }
    }

    private Connection connection(int isolationWrite) throws Exception {
        Connection connection = connection();
        try {
            connection.setTransactionIsolation(isolationWrite);
        } catch (SQLException e) {
            System.out.println("Unsupported " + toString(isolationWrite));
            return null;
        }
        connection.setAutoCommit(false);
        return connection;
    }


}

read_uncommited

read_uncommited的打印结果如下（可以看到任何时候readBefore，write，readAfter得到的数据都是一致的）

[ReadBefore]init:
			valueA | 0
update transaction_table_3423 set curr_value=1 where id='valueA'
	[write]:
			valueA | 1
	[readBefore]:
			valueA | 1
update transaction_table_3423 set curr_value=2 where id='valueA'
	[write]:
			valueA | 2
	[readBefore]:
			valueA | 2
After commit for valueA
	[write]:
			valueA | 2
	[readBefore]:
			valueA | 2
update transaction_table_3423 set curr_value=1 where id='valueB'
	[write]:
			valueA | 2
			valueB | 1
	[readAfter]:
			valueA | 2
			valueB | 1
update transaction_table_3423 set curr_value=2 where id='valueB'
	[write]:
			valueA | 2
			valueB | 2
	[readAfter]:
			valueA | 2
			valueB | 2
After commit for valueB
	[write]:
			valueA | 2
			valueB | 2
	[readBefore]:
			valueA | 2
			valueB | 2
	[readAfter]:
			valueA | 2
			valueB | 2

read_commited

当read的隔离级别设为read_commited的时候，打印结果如下

[ReadBefore]init:
			valueA | 0
update transaction_table_3423 set curr_value=1 where id='valueA'
	[write]:
			valueA | 1
	[readBefore]:
			valueA | 0
update transaction_table_3423 set curr_value=2 where id='valueA'
	[write]:
			valueA | 2
	[readBefore]:
			valueA | 0
After commit for valueA
	[write]:
			valueA | 2
	[readBefore]:
			valueA | 2
update transaction_table_3423 set curr_value=1 where id='valueB'
	[write]:
			valueA | 2
			valueB | 1
	[readAfter]:
			valueA | 2
			valueB | 0
update transaction_table_3423 set curr_value=2 where id='valueB'
	[write]:
			valueA | 2
			valueB | 2
	[readAfter]:
			valueA | 2
			valueB | 0
After commit for valueB
	[write]:
			valueA | 2
			valueB | 2
	[readBefore]:
			valueA | 2
			valueB | 2
	[readAfter]:
			valueA | 2
			valueB | 2

repeatable_read

repeatable_read的结果如下，这是一个有些让人困惑的级别，有空我再单独研究一下。可以看到readBefore对于valueA和valueB的值读取出来永远是0，即使它是在write执行了commit后才去读取的valueB。另外需要说明Oracle是不支持这个隔离级别的

[ReadBefore]init:
			valueA | 0
update transaction_table_3423 set curr_value=1 where id='valueA'
	[write]:
			valueA | 1
	[readBefore]:
			valueA | 0
update transaction_table_3423 set curr_value=2 where id='valueA'
	[write]:
			valueA | 2
	[readBefore]:
			valueA | 0
After commit for valueA
	[write]:
			valueA | 2
	[readBefore]:
			valueA | 0
update transaction_table_3423 set curr_value=1 where id='valueB'
	[write]:
			valueA | 2
			valueB | 1
	[readAfter]:
			valueA | 2
			valueB | 0
update transaction_table_3423 set curr_value=2 where id='valueB'
	[write]:
			valueA | 2
			valueB | 2
	[readAfter]:
			valueA | 2
			valueB | 0
After commit for valueB
	[write]:
			valueA | 2
			valueB | 2
	[readBefore]:
			valueA | 0
			valueB | 0
	[readAfter]:
			valueA | 2
			valueB | 0

serializable

观察前面的输出可以知道当write设置隔离级别是serializable时是不会影响read的，当时当read设置serialable时会影响write

---------- Isolation Read:SERIALIZABLE ---------- Isolation Write:READ_UNCOMMITTED ----------
	[ReadBefore]init:
			valueA | 0
update transaction_table_3423 set curr_value=1 where id='valueA'
Exception in thread "main" com.mysql.cj.jdbc.exceptions.MySQLTransactionRollbackException: Lock wait timeout exceeded; try restarting transaction
	at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:123)
	at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:97)
	at com.mysql.cj.jdbc.exceptions.SQLExceptionsMapping.translateException(SQLExceptionsMapping.java:122)
	at com.mysql.cj.jdbc.ClientPreparedStatement.executeInternal(ClientPreparedStatement.java:953)
	at com.mysql.cj.jdbc.ClientPreparedStatement.executeUpdateInternal(ClientPreparedStatement.java:1092)
	at com.mysql.cj.jdbc.ClientPreparedStatement.executeUpdateInternal(ClientPreparedStatement.java:1040)
	at com.mysql.cj.jdbc.ClientPreparedStatement.executeLargeUpdate(ClientPreparedStatement.java:1347)
	at com.mysql.cj.jdbc.ClientPreparedStatement.executeUpdate(ClientPreparedStatement.java:1025)
	at com.qbit.Database.update(Transaction.java:141)
	at com.qbit.Database.test(Transaction.java:53)
	at com.qbit.Transaction.main(Transaction.java:12)

 

首席IT民工
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MySQL基础部分总结3
ZZZZZR23333的博客
04-19 166
一. 事务原理 一个事务是由一条或者多条对数据库操作的SQL语句所组成的一个不可分割的单元，只有当事务中的所有操作都正常执行完了，整个事务才会被提交给数据库；如果有部分事务处理失败，那么事务就要回退到最初的状态，因此，事务要么全部执行成功，要么全部失败。 学习这些原理之前我们要先知道MySQL的Buffer Pool机制。 InnoDB作为MySQL的存储引擎，数据是存放在磁盘中的，但如果每次读写...
JDBC中setTransactionIsolation
u014244856的博客
09-29 280
JDBC中setTransactionIsolation
数据库事务
code_agent的博客
09-28 158
数据库事务 一：事务的特性 事务的特性：ACID 事务提供了一种机制，可用来将一系列数据库更改归入一个逻辑操作。更改数据库后，所做的更改可以作为一个单元进行提交或取消。事务可确保遵循原子性、一致性、隔离性和持续性（ACID）这几种属性，以使数据能够正确地提交到数据库中。 原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作 要么都发生，要么都不发生。 一致性（Consistency）一个事务中，事务前后数据的完整性必须保持一致。 隔离性（Isolation）多个事务，事务的隔离
mysql 事物的隔离级别
ppwwp的专栏
01-14 296
事物的隔离级别 隔离级别设定 connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); 事务有四个属性，称为ACID属性： 1、原子性(Atomicity):事务是一个原子单位，要么全部执行，要么全部不执行。 2、一致性(Consistent):事务的开始和结束，数据都必须保持一致状态。 3、隔离性(is...
深入浅出事务之隔离级别
grunt1223的专栏
12-30 90
除了事务传播属性（可参考我的另一篇文章《深入浅出事务之传播属性》）之外，另一个需要开发人员关注的是事务的隔离级别，它决定了一个事务中所进行的更新操作对其它事务的可见性。事实上，DBMS、EJB、Spring都允许你设置不同的隔离级别，你必须保证它们相互统一、兼容；因此，应用服务器可能支持许多种隔离级别，但要使用其中的某一种，首先你必须保证你的数据库也支持它。 事务的隔离性实质上是数据库的并发...
IEEE Transaction On Robotic 2010论文
07-18
《IEEE Transaction On Robotics 2010：计算机视觉在机器人领域的探索》 2010年， IEEE Transaction On Robotics（TRO）发表了24篇聚焦于计算机视觉的论文，这些研究工作代表了当时该领域的重要进展和技术突破。...
html5 Web SQL Database 之事务处理函数transaction与executeSQL解析
09-28
通过一个例子说明 Web SQL Database 的基本用法。它首先调用 openDatabase 创建了名为“fooDB”...然后使用 transaction 执行两条 SQL 语句。第一条 SQL 语句创建了名为“foo”的表，第二条 SQL 语句向表中插入一条记录
Research on dynamic update transaction for Java classes
02-20
Dynamic software updating is critical for many systems that must provide continuous ... In this paper, the update transaction is purposed to dynamically update the class set, and some of its propert
Transaction Processing in PostgreSQL
最新发布
03-04
postgresql Transaction Processing in PostgreSQL
事务的四种隔离级别（四）SERIALIZABLE（序列化）
qq_44829555的博客
06-08 1184
aaa
JDBC数据库事务（二）：数据库的隔离级别
区块链之美
06-13 1159
1.对于同时运行的多个事务,当这些事务访问数据库中相同的数据时,如果没有采取必要的隔离机制,就会导致各种并发问题:–脏读: 对于两个事物T1, T2, T1读取了已经被T2更新但还没有被提交的字段。之后, 若T2回滚,T1读取的内容就是临时且无效的。–不可重复读: 对于两个事物 T1, T2, T1 读取了一个字段, 然后T2更新了该字段.之后, T1再次读取同一个字段,值就不同了。–幻读: 对于...
setTransactionIsolation
木羊的窝
03-20 2006
conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);     ...                     static   int   TRANSACTION_NONE                           A   constant   indicating   that   transacti
事务隔离级别——Read uncommitted
我是真的囟的博客
06-10 3193
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。我们这篇博客主要来分析Read uncommitted 这种事务隔离级别。 一、修改MySQL数据库事务隔离级别。 在my.i...
MySQL SET TRANSACTION 设置事务隔离级别
u011866460的专栏
10-30 1万+
1.  首先说一下autocommit
JDBC 处理事务的隔离级别
weixin_46704564的博客
04-14 492
各种并发的问题 脏读：对于两个事务 T1，T2，T1 读取了已经被 T2 更新但还没有被提交的字段之后，若 T2 回滚，T1 读取的内容就是临时且无效的。 不可重复读：对于两个事物 T1 T2 ，T1 读取了一个字段，然后 T2 更新了该字段之后，T1 再次读取同一个字段，值就不同了。 幻读：对于两个事物 T1 T2，T1 从一个表中读取了一个字段，然后 T2 在该表中插入了一些新的行之后，如果...
spring事务(Transaction)的七种事务传播行为及五种隔离级别
热门推荐
Java仗剑走天涯
07-20 3万+
spring事务(Transaction)的七种事务传播行为及五种隔离级别
数据库事务隔离级别测试-postgresql
Just Do It!
11-10 1695
1. read-committed (default 级别) 客户端A： epmdb=> start transaction ; START TRANSACTION epmdb=> update t1.dbversion  set  value =1200  where dbversionid=1; UPDATE 1 epmdb=>  客户端B： epmdb=> start  
dbcp2配置参数不生效导致的请求阻塞
比尔·马云的博客
01-10 1169
数据库配置不生效，数据库请求阻塞，dbcp2连接池资源耗尽
Cannot begin Transaction on closed Session/EntityManager
04-28
这个问题通常是由于使用了已经关闭的Session或EntityManager对象导致的。你可以检查一下你的代码中是否有关闭Session或EntityManager的操作，或者在使用完这些对象后及时关闭它们。另外，你也可以尝试使用事务管理器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值