长事务指的是执行时间超过阈值的事务，这类事务会长时间持有数据库锁、占用连接池资源，还可能阻塞后续的写操作或者查询操作，严重时会导致数据库响应变慢甚至服务不可用。优化长事务的核心思路是减少单个事务的执行时长，其中只读事务剥离和事务大小拆分是最常用的两种方案。
长事务的危害与识别
长事务的危害主要体现在三个方面：第一是锁资源占用，写事务会持有行锁或者表锁，其他事务需要等待锁释放才能执行；第二是连接池耗尽，长时间未提交的事务会一直占用数据库连接，高并发场景下容易把连接池占满；第三是主从延迟，长事务产生的binlog会在从库回放，导致主从数据同步滞后。
可以通过数据库的监控命令识别长事务，以MySQL为例，执行以下语句可以查看当前运行时间超过60秒的事务：
-- 查询运行时间超过60秒的未提交事务 SELECT trx_id, trx_started, TIMESTAMPDIFF(SECOND, trx_started, NOW()) AS trx_duration, trx_query FROM information_schema.innodb_trx WHERE TIMESTAMPDIFF(SECOND, trx_started, NOW()) > 60;
只读事务剥离优化方案
很多业务场景中，事务里既包含查询操作也包含写操作，但实际上查询操作不需要加事务锁，也不需要参与后续的写操作回滚。只读事务剥离就是把事务内的查询操作移到事务外部，只把必要的写操作放在事务里，从而减少事务的执行时长。
优化前的代码示例
以下是一个典型的错误写法，把查询用户信息和更新用户积分放在同一个事务里：
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class UserService {
public void updateUserScore(Connection conn, Long userId, Integer addScore) throws SQLException {
// 开启事务
conn.setAutoCommit(false);
try {
// 查询用户信息，属于只读操作
String querySql = "SELECT score FROM user WHERE id = ?";
PreparedStatement queryStmt = conn.prepareStatement(querySql);
queryStmt.setLong(1, userId);
ResultSet rs = queryStmt.executeQuery();
Integer currentScore = 0;
if (rs.next()) {
currentScore = rs.getInt("score");
}
// 更新用户积分，属于写操作
String updateSql = "UPDATE user SET score = ? WHERE id = ?";
PreparedStatement updateStmt = conn.prepareStatement(updateSql);
updateStmt.setInt(1, currentScore + addScore);
updateStmt.setLong(2, userId);
updateStmt.executeUpdate();
// 提交事务
conn.commit();
} catch (SQLException e) {
// 回滚事务
conn.rollback();
throw e;
} finally {
conn.setAutoCommit(true);
}
}
}
优化后的代码示例
把查询用户信息的操作移到事务外部，事务只保留更新操作：
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class UserService {
public void updateUserScore(Connection conn, Long userId, Integer addScore) throws SQLException {
// 先执行只读查询，不在事务内
String querySql = "SELECT score FROM user WHERE id = ?";
PreparedStatement queryStmt = conn.prepareStatement(querySql);
queryStmt.setLong(1, userId);
ResultSet rs = queryStmt.executeQuery();
Integer currentScore = 0;
if (rs.next()) {
currentScore = rs.getInt("score");
}
// 开启事务，只处理写操作
conn.setAutoCommit(false);
try {
String updateSql = "UPDATE user SET score = ? WHERE id = ?";
PreparedStatement updateStmt = conn.prepareStatement(updateSql);
updateStmt.setInt(1, currentScore + addScore);
updateStmt.setLong(2, userId);
updateStmt.executeUpdate();
conn.commit();
} catch (SQLException e) {
conn.rollback();
throw e;
} finally {
conn.setAutoCommit(true);
}
}
}
如果使用的是Spring框架，也可以通过@Transactional(readOnly = true)注解标记只读事务，这类事务不会加写锁，也支持数据库优化查询执行计划，但如果是完全不需要事务的查询，更建议直接放在事务外部。
事务大小拆分优化方案
另一个常见的长事务场景是批量处理大量数据，比如一次性更新十万条用户数据，这类事务执行时间会非常长。事务大小拆分就是把大事务拆成多个小事务，每个小事务处理一部分数据，减少单个事务的执行时长。
优化前的批量更新示例
以下是一个批量更新的错误写法，一次性处理所有数据：
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
public class BatchUpdateService {
public void batchUpdateUser(List<Long> userIds, Integer newStatus, Connection conn) throws SQLException {
// 开启一个大事务
conn.setAutoCommit(false);
try {
String updateSql = "UPDATE user SET status = ? WHERE id = ?";
PreparedStatement stmt = conn.prepareStatement(updateSql);
for (Long userId : userIds) {
stmt.setInt(1, newStatus);
stmt.setLong(2, userId);
stmt.addBatch();
}
stmt.executeBatch();
// 所有数据更新完成后才提交
conn.commit();
} catch (SQLException e) {
conn.rollback();
throw e;
} finally {
conn.setAutoCommit(true);
}
}
}
优化后的拆分示例
把批量更新拆成每100条数据一个事务：
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class BatchUpdateService {
// 每个小事务处理的数据量
private static final int BATCH_SIZE = 100;
public void batchUpdateUser(List<Long> userIds, Integer newStatus, Connection conn) throws SQLException {
// 把用户ID列表按BATCH_SIZE拆分
List<List<Long>> splitList = new ArrayList<>();
for (int i = 0; i < userIds.size(); i += BATCH_SIZE) {
int end = Math.min(i + BATCH_SIZE, userIds.size());
splitList.add(userIds.subList(i, end));
}
// 每个小列表单独开启一个事务
for (List<Long> subList : splitList) {
conn.setAutoCommit(false);
try {
String updateSql = "UPDATE user SET status = ? WHERE id = ?";
PreparedStatement stmt = conn.prepareStatement(updateSql);
for (Long userId : subList) {
stmt.setInt(1, newStatus);
stmt.setLong(2, userId);
stmt.addBatch();
}
stmt.executeBatch();
conn.commit();
} catch (SQLException e) {
conn.rollback();
throw e;
} finally {
conn.setAutoCommit(true);
}
}
}
}
拆分事务的时候需要注意，如果业务要求所有数据要么全部更新成功要么全部失败，就不能直接拆分，这种场景下可以考虑先批量处理到临时表，再通过单次事务把临时表的数据同步到业务表，既保证原子性又减少事务时长。
优化注意事项
实施只读事务剥离和事务大小拆分的时候，需要注意几个问题：第一是数据一致性，剥离只读事务后，查询到的数据可能是旧值，需要确认业务是否允许这种情况；第二是拆分事务的原子性，如果业务要求批量操作全部成功，拆分后需要额外做补偿机制；第三是事务隔离级别，不同的隔离级别对锁的影响不同，优化的时候需要结合业务的隔离级别调整方案。
除了这两个方案，还可以通过减少事务内的非数据库操作来优化长事务，比如不要在事务里调用第三方接口、处理文件上传等耗时操作，这些操作应该放在事务外部执行，进一步缩短事务的执行时间。