链接
数据库事务隔离级别“读未提交（Read Uncommitted）”代码演示
数据库事务隔离级别“读已提交（Read Committed）”代码演示
数据库事务隔离级别“可重复读（Repeatable Read）”代码演示
数据库事务隔离级别“串行化（Serializable）”代码演示
目录
一、简介
数据库事务的隔离级别用于控制多个事务并发访问数据库时的相互影响程度，不同的隔离级别在性能和数据一致性上有不同的权衡。SQL 标准定义了四种隔离级别，从低到高分别为：读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read）和串行化（Serializable）。
读未提交（Read Uncommitted）是最低级别的事务隔离级别，它允许一个事务读取另一个事务尚未提交的数据。这种隔离级别提供了最低级别的数据一致性保障，因为事务可以读取到其他事务尚未提交的更改（即“脏数据”），这就是所谓的脏读现象（后面将通过代码进行演示）。尽管这种隔离级别在并发性能方面表现优异，但它也带来了显著的数据一致性和可靠性问题。
1. 优点
并发性能最高：由于几乎没有对事务的并发访问进行限制，读未提交隔离级别允许多个事务同时读写相同的数据，从而极大地提高了系统的并发性能。在这种模式下，事务不需要等待其他事务完成即可立即读取数据，减少了锁定和等待的时间。
2. 缺点
数据一致性最差：使用读未提交隔离级别会导致数据的一致性问题。事务可能会读取到其他事务尚未提交的数据（即“脏数据”）。这种情况下，事务读取到的数据可能是不准确或不存在的，导致应用程序中的数据不确定性和不可靠性。因此，在大多数实际应用场景中，不建议使用这种隔离级别。
3. 示例描述
假设事务 A 将账户余额从 100 元修改为 200 元，但尚未提交。此时，事务 B 以读未提交的隔离级别运行，并读取到了这个未提交的 200 元余额。随后，事务 A 回滚了其更改，账户余额恢复到原来的 100 元。然而，事务 B 已经基于错误的 200 元余额进行了进一步的操作，导致其处理结果基于不存在的“脏数据”。这种情况下，事务 B 得到的结果是不可靠的，可能会引发一系列连锁反应，影响整个系统的数据完整性和准确性。
二、代码示例
该示例中，我们重点关注客户端B的事务隔离级别，将在客户端B的代码中演示读未提交（Read Uncommitted）这种隔离级别存在的脏读现象（客户端A采用什么样的隔离级别，并不会影响客户端B中出现脏读现象，因为B中的事务隔离级别是Read Uncommitted）。
C# 版本
客户端A的代码
客户端A启动一个事务，修改账户余额但不提交，然后回滚更改以恢复原始状态。
using System;
using System.Data.SqlClient;
class ClientA
{
static void Main(string[] args)
{
string connectionString = "your_connection_string_here"; // 替换为你的数据库连接字符串
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
// 开始事务A，设置隔离级别为ReadCommitted（这里可以使用更高的隔离级别）
SqlTransaction transactionA = connection.BeginTransaction(System.Data.IsolationLevel.ReadCommitted);
try
{
SqlCommand commandA = connection.CreateCommand();
commandA.Transaction = transactionA;
// 更新账户余额为200元
commandA.CommandText = "UPDATE Accounts SET Balance = 200 WHERE AccountId = 1";
commandA.ExecuteNonQuery();
Console.WriteLine("Client A: 已将账户余额更新为200元，但尚未提交");
// 模拟等待一段时间让Client B有机会读取数据
System.Threading.Thread.Sleep(5000); // 等待5秒，给Client B时间读取未提交的数据
// 回滚事务A，恢复余额为100元
transactionA.Rollback();
Console.WriteLine("Client A: 已回滚，账户余额恢复到100元");
}
catch (Exception ex)
{
Console.WriteLine("Client A异常: " + ex.Message);
transactionA.Rollback(); // 如果发生异常，回滚事务
}
}
}
}执行结果输出：
- Client A: 已将账户余额更新为200元，但尚未提交
- Client A: 已回滚，账户余额恢复到100元
客户端B的代码
在客户端A执行事务的同时，客户端B也执行了一个事务，但由于客户端B的事务隔离级别为读未提交，因此会读取到事务A已修改但尚未提交的账户余额数据（即脏数据）。
using System;
using System.Data.SqlClient;
class ClientB
{
static void Main(string[] args)
{
string connectionString = "your_connection_string_here"; // 替换为你的数据库连接字符串
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
// 开始事务B，设置隔离级别为ReadUncommitted
SqlTransaction transactionB = connection.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted);
try
{
SqlCommand commandB = connection.CreateCommand();
commandB.Transaction = transactionB;
// 查询账户余额
commandB.CommandText = "SELECT Balance FROM Accounts WHERE AccountId = 1";
object result = commandB.ExecuteScalar();
// 由于事务A未提交，此时读取到的是事务A未提交的余额200元
Console.WriteLine($"Client B: 读取到的账户余额是 {result} 元"); // 应输出200元
transactionB.Commit(); // 提交事务B
}
catch (Exception ex)
{
Console.WriteLine("Client B异常: " + ex.Message);
transactionB.Rollback(); // 如果发生异常，回滚事务
}
}
}
}执行结果输出：
- Client B: 读取到的账户余额是 200 元
执行结果说明了事务B在事务A未提交的情况下读取到了事务A未提交的余额200元（脏读现象）。
Java 版本
客户端A的代码
客户端A启动一个事务，修改账户余额但不提交，然后回滚更改以恢复原始状态。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class ClientA {
public static void main(String[] args) throws InterruptedException {
String url = "jdbc:mysql://localhost:3306/your_database"; // 替换为你的数据库连接字符串
String user = "root";
String password = "password";
Connection conn = null;
Statement stmt = null;
try {
conn = DriverManager.getConnection(url, user, password);
// 设置隔离级别为ReadCommitted（这里可以使用更高的隔离级别）
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
conn.setAutoCommit(false);
stmt = conn.createStatement();
// 更新账户余额为200元
stmt.executeUpdate("UPDATE Accounts SET Balance = 200 WHERE AccountId = 1");
System.out.println("Client A: 已将账户余额更新为200元，但尚未提交");
// 模拟等待一段时间让Client B有机会读取数据
Thread.sleep(5000); // 等待5秒，给Client B时间读取未提交的数据
// 回滚事务A，恢复余额为100元
conn.rollback();
System.out.println("Client A: 已回滚，账户余额恢复到100元");
} catch (SQLException e) {
e.printStackTrace();
if (conn != null) {
try {
System.err.print("Transaction is being rolled back");
conn.rollback();
} catch (SQLException excep) {
excep.printStackTrace();
}
}
} finally {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
/* ignored */
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
/* ignored */
}
}
}
}
}执行结果输出：
- Client A: 已将账户余额更新为200元，但尚未提交
- Client A: 已回滚，账户余额恢复到100元
客户端B的代码
在客户端A执行事务的同时，客户端B也执行了一个事务，但由于客户端B的事务隔离级别为读未提交，因此会读取到事务A已修改但尚未提交的账户余额数据（即脏数据）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class ClientB {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/your_database"; // 替换为你的数据库连接字符串
String user = "root";
String password = "password";
Connection conn = null;
Statement stmt = null;
try {
conn = DriverManager.getConnection(url, user, password);
// 设置隔离级别为ReadUncommitted
conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
conn.setAutoCommit(false);
stmt = conn.createStatement();
// 查询账户余额
ResultSet rs = stmt.executeQuery("SELECT Balance FROM Accounts WHERE AccountId = 1");
if (rs.next()) {
int balance = rs.getInt("Balance");
System.out.println("Client B: 读取到的账户余额是 " + balance + " 元"); // 应输出200元
}
conn.commit(); // 提交事务B
} catch (SQLException e) {
e.printStackTrace();
if (conn != null) {
try {
System.err.print("Transaction is being rolled back");
conn.rollback();
} catch (SQLException excep) {
excep.printStackTrace();
}
}
} finally {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
/* ignored */
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
/* ignored */
}
}
}
}
}执行结果输出：
- Client B: 读取到的账户余额是 200 元
执行结果说明了事务B在事务A未提交的情况下读取到了事务A未提交的余额200元（脏读现象）。
扫一扫
400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
