究竟选哪个？我与Java的事务隔离级别的爱恨情仇

最新推荐文章于 2023-07-31 18:21:13 发布
最新推荐文章于 2023-07-31 18:21:13 发布
阅读量58 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49768044/article/details/131528124
版权

在这里插入图片描述

文章目录

Java事务的隔离级别指定了多个并发事务之间的相互影响程度。

在Java中，常见的事务隔离级别有以下四种：

1. READ_UNCOMMITTED（读取未提交数据）

这是最低级别的隔离级别，它允许事务读取其他未提交事务的数据变更。由于存在脏读、不可重复读和幻读的问题，一般情况下很少使用。

请注意，虽然我会提供一个例子来说明 READ_UNCOMMITTED 隔离级别，但在实际开发中不推荐使用 READ_UNCOMMITTED 级别，因为它存在严重的并发问题。这个例子仅用于演示目的。

以下是一个简单的Java代码示例，展示了如何使用 READ_UNCOMMITTED 隔离级别：

import java.sql.*;

public class ReadUncommittedExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "root";
        String password = "password";
        
        Connection conn = null;
        try {
            // 建立数据库连接
            conn = DriverManager.getConnection(url, username, password);
            
            // 设置隔离级别为 READ_UNCOMMITTED
            conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
            
            // 开启事务
            conn.setAutoCommit(false);
            
            // 执行查询
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");
            
            // 输出结果集
            while (rs.next()) {
                System.out.println("User ID: " + rs.getInt("id") + ", Username: " + rs.getString("username"));
            }
            
            // 提交事务
            conn.commit();
            
        } catch (SQLException e) {
            e.printStackTrace();
            // 回滚事务
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 关闭数据库连接
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

请注意，使用 READ_UNCOMMITTED 隔离级别，事务可以读取到其他未提交事务的数据变更。这可能会导致脏读和不可重复读等并发问题。因此，在实际开发中，为了保证数据一致性和可靠性，建议使用更高级别的隔离级别，如 READ_COMMITTED 或 REPEATABLE_READ。

2. READ_COMMITTED（读取已提交数据）

这是大多数数据库的默认隔离级别。它保证一个事务只能读取到已经提交的数据变更。但是，仍然存在不可重复读和幻读的问题。

以下是一个简单的Java代码示例，展示了如何使用 READ_COMMITTED 隔离级别：

import java.sql.*;

public class ReadCommittedExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "root";
        String password = "password";
        
        Connection conn = null;
        try {
            // 建立数据库连接
            conn = DriverManager.getConnection(url, username, password);
            
            // 设置隔离级别为 READ_COMMITTED
            conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
            
            // 开启事务
            conn.setAutoCommit(false);
            
            // 执行查询
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");
            
            // 输出结果集
            while (rs.next()) {
                System.out.println("User ID: " + rs.getInt("id") + ", Username: " + rs.getString("username"));
            }
            
            // 提交事务
            conn.commit();
            
        } catch (SQLException e) {
            e.printStackTrace();
            // 回滚事务
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 关闭数据库连接
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中，我们将隔离级别设置为 READ_COMMITTED。这意味着事务只能读取到已经提交的数据变更。它避免了脏读的问题，但仍然可能存在不可重复读和幻读的情况。请注意，在实际开发中，要根据具体需求选择合适的隔离级别，以保证数据的一致性和并发性能。

3. REPEATABLE_READ（可重复读）

在该隔离级别下，事务在执行期间多次读取同一数据时，会得到相同的结果。它通过锁定查询的数据集来避免脏读、不可重复读和幻读的问题。

以下是一个简单的Java代码示例，展示了如何使用 REPEATABLE_READ 隔离级别：

import java.sql.*;

public class RepeatableReadExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "root";
        String password = "password";
        
        Connection conn = null;
        try {
            // 建立数据库连接
            conn = DriverManager.getConnection(url, username, password);
            
            // 设置隔离级别为 REPEATABLE_READ
            conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
            
            // 开启事务
            conn.setAutoCommit(false);
            
            // 执行查询
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");
            
            // 输出结果集
            while (rs.next()) {
                System.out.println("User ID: " + rs.getInt("id") + ", Username: " + rs.getString("username"));
            }
            
            // 提交事务
            conn.commit();
            
        } catch (SQLException e) {
            e.printStackTrace();
            // 回滚事务
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 关闭数据库连接
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中，我们将隔离级别设置为 REPEATABLE_READ。这意味着事务在整个事务期间都能看到一致的快照，不受其他事务的影响。它可以避免脏读和不可重复读的问题，但仍然可能存在幻读的情况。请注意，在实际开发中，要根据具体需求选择合适的隔离级别，以保证数据的一致性和并发性能。

4. SERIALIZABLE（串行化）

这是最高级别的隔离级别，它要求事务串行执行，并且所有的读写操作都会加上锁。它可以避免所有的并发问题，但也会极大地降低并发性能。

以下是一个简单的Java代码示例，展示了如何使用 SERIALIZABLE 隔离级别：

import java.sql.*;

public class SerializableExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "root";
        String password = "password";
        
        Connection conn = null;
        try {
            // 建立数据库连接
            conn = DriverManager.getConnection(url, username, password);
            
            // 设置隔离级别为 SERIALIZABLE
            conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            
            // 开启事务
            conn.setAutoCommit(false);
            
            // 执行查询
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");
            
            // 输出结果集
            while (rs.next()) {
                System.out.println("User ID: " + rs.getInt("id") + ", Username: " + rs.getString("username"));
            }
            
            // 提交事务
            conn.commit();
            
        } catch (SQLException e) {
            e.printStackTrace();
            // 回滚事务
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            // 关闭数据库连接
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中，我们将隔离级别设置为 SERIALIZABLE。这是最严格的隔离级别，它确保事务串行执行，避免了脏读、不可重复读和幻读的所有问题。然而，它也可能导致并发性能较差，因为事务需要串行执行。请注意，在实际开发中，要根据具体需求选择合适的隔离级别，以平衡数据一致性和并发性能。

事务的隔离级别可以通过数据库的配置进行设置，例如在Java中使用JDBC连接数据库时，可以通过设置Connection对象的setTransactionIsolation()方法来指定隔离级别。

ai_todo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
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，他的作用是每一条
数据库事务的隔离级别
A_aspectJ的博客
09-10 463
3、READ COMMITTED (提交读)：大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”，但不能避免“幻读”和“不可重复读取”。也就是说，当前事务先进行了一次数据读取，然后再次读取到的数据是别的事务修改成功的数据，导致两次读取到的数据不匹配，也就照应了不可重复读的语义。：事务A首先读取了一条数据，然后执行逻辑的时候，事务B将这条数据改变了，然后事务A再次读取的时候，发现数据不匹配了，就是所谓的不可重复读了。mysql默认事务隔离级别为。
【MySQL】事务及其隔离性/隔离级别
学了就忘是正常现象
06-29 3450
MySQL事务的隔离级别（只有innoDB解决了RR级别的幻读问题）
事务的隔离级别以及传播机制的详细讲解
m0_57248981的博客
07-31 2255
在 Spring 项⽬中使⽤事务，⽤两种⽅法⼿动操作和声明式⾃动提交，其中后者使⽤的最多，在⽅法上添加 @Transactional 就可以实现了。设置事务的隔离级别 @Transactional(isolation = Isolation.SERIALIZABLE)，Spring 中的事务隔离级别有 5 种。设置事务的传播机制 @Transactional(propagation = Propagation.REQUIRED)，Spring 中的事务传播级别有 7 种。
事务的隔离级别
weixin_34128534的博客
10-08 122
【数据库事务并发问题】 假设现在有两个事务：Transaction01和Transaction02并发执行。 1)脏读 ①Transaction01将某条记录的AGE值从20修改为30。 ②Transaction02读取了Transaction01更新后的值：30。 ③Transaction01回滚，AGE值恢复到了20。 ④Transaction02读取到的30就是一个无效的值。 ...
【Java学习笔记（二十五）】之事务要点介绍与事务的隔离级别
开发小鸽
08-20 389
本文章由公号【开发小鸽】发布！欢迎关注！！！ 老规矩–妹妹镇楼： 一． 事务 （一） 概述        事务管理着一个包含多个步骤的业务操作，这些步骤要么同时成功，要么同时失败。当这些步骤中出现异常错误时，事务会及时地回滚到业务初始状态，防止出现逻辑错误。 （二） 操作 1. 开启事务 start transaction; 2. 回滚 rollback; 回滚到开启事务的位置、 3. 提交 commit; （三） 事务自动提交与手动提交 1.
数据库事务的四种隔离级别
一个小菜鸟的成长之路
02-17 5636
事务的四种隔离级别概念结合代码详解。
最易懂的数据库事务的四种隔离级别知识
u013127419的博客
06-05 1743
那为什么MySQL官方默认隔离级别是RR，而有些大厂选择了RC作为默认的隔离级别呢？提升并发RC 在加锁的过程中，不需要添加Gap Lock和的，只对要修改的记录添加行级锁就行了。因此RC的支持的并发度比RR高得多，减少死锁正是因为RR隔离级别增加了Gap Lock和锁，因此它相对于RC，更容易产生死锁。
SpringBoot事务隔离等级和传播行为
arjg30483的博客
08-08 427
一、开启事物管理 //import org.springframework.transaction.annotation.EnableTransactionManagement; @SpringBootApplication @EnableTransactionManagement //显示开启事物管理,springboot默认已经开启事物管理，可不用显示的注解 public...
Java 事务及隔离级别
热门推荐
大鹏
04-30 1万+
Java 事务及隔离级别
Spring事务隔离级别简介及实例解析
08-28
主要介绍了Spring事务隔离级别简介及实例解析，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
基础篇-MySQL简介 （Java面试，MySQL高频知识点：事务特点ACID，事务隔离级别，存储引擎，数据库锁）
12-14
MySQL有几个隔离级别（最好这个问题不要等被问，而在问上个的时候主动说这个） MySQL是怎么确保事务的正常执行的（日志，这个问得好像不多，但是可以作为一个亮点） MySQL有哪些存储引擎，各自的特点 因为这篇文章不...
深入理解Mysql事务隔离级别与锁机制.zip
最新发布
05-27
数据库
54.Spring事务的传播特性和隔离级别.avi
03-07
java面试宝典
Java面试题54.Spring事务的传播特性和隔离级别.mp4
09-09
Java面试题54.Spring事务的传播特性和隔离级别.mp4
【数据库】事务的隔离级别以及实现原理
DreamSun的博客
04-26 1825
原子性一致性隔离性持久性幻读和不可重复读都是在同一个事务中多次读取了其他事务已经提交的事务的数据导致每次读取的数据不一致，所不同的是不可重复读读取的是同一条数据，而幻读针对的是一批数据整体的统计(比如数据的个数)以MYSQL数据库来分析四种隔离级别。
数据库事务的隔离级别和并发异常
WZH577的博客
10-25 699
众所周知，数据库事务具有隔离性,理论上来说事务之间的执行不应该相互产生影响,其对数据库的影响应该和它们串行执行时一样。然而完全的隔离性会导致系统并发性能很低,降低对资源的利用率,因而实际上对隔离性的要求会有所放宽,这也会一定程度造成对数据库一致性要求降低。
你作为一个Java领域的专家，请完成以下任务：事务隔离级别
05-24
事务隔离级别是指多个事务并发执行时，保证事务之间相互隔离的程度。Java中的事务隔离级别主要有以下四种： 1. READ_UNCOMMITTED（读未提交）：允许一个事务读取另一个未提交的事务中的数据。这种隔离级别会导致脏读、不可重复读、幻读等问题。 2. READ_COMMITTED（读已提交）：要求一个事务只能读取另一个已经提交的事务中的数据。这种隔离级别解决了脏读问题，但是可能会出现不可重复读、幻读等问题。 3. REPEATABLE_READ（可重复读）：要求一个事务在执行期间多次读取同一行数据时，其结果必须一致。这种隔离级别解决了脏读、不可重复读问题，但是可能会出现幻读问题。 4. SERIALIZABLE（串行化）：要求所有事务依次执行，不允许并发执行。这种隔离级别解决了脏读、不可重复读、幻读等问题，但是会影响系统的性能。 在Java中，可以使用JDBC或者Hibernate等框架来设置事务隔离级别。例如，在JDBC中，可以使用以下代码设置事务隔离级别为可重复读： ```java Connection conn = dataSource.getConnection(); conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值