Java中事务的传播机制和隔离级别

一、传播机制

Spring事务的传播机制是指在方法调用链中，对于已经开启的事务以及后续子方法如何处理事务。Spring框架提供了7种传播行为来控制事务的传播过程，分别为：

1. PROPAGATION_REQUIRED：默认传播行为，当前有事务，则沿用当前事务，不存在则创建新事务。

2. PROPAGATION_REQUIRES_NEW：将当前事务挂起，创建一个新的事务进行处理，当前方法执行结束，再将新事务提交或回滚。

3. PROPAGATION_NESTED：嵌套事务，如果没有上级事务，那么和PROPAGATION_REQUIRED一样，否则在上级事务的控制下进行提交或回滚。

4. PROPAGATION_SUPPORTS：支持当前事务，有事务则用，没有事务则不用。

5. PROPAGATION_NOT_SUPPORTED：不支持当前事务，不使用事务处理逻辑。

6. PROPAGATION_MANDATORY：强制当前事务，必须在某个事务内部执行，否则将抛出异常。

7. PROPAGATION_NEVER：绝不使用当前事务，不使用事务处理逻辑，如果某个方法已经在事务中被创建，将抛出异常。

下面是一些具体的例子，来解释Spring事务传播行为的使用：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User user) {
        userDao.addUser(user);
        // 继续调用其他方法，传播方式为REQUIRED
        addRequiredOther(user);
    }

    private void addRequiredOther(User user) {
        userDao.addOtherUser(user);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNew(User user) {
        userDao.addUser(user);
        // 继续调用其他方法，传播方式为REQUIRES_NEW
        addRequiresNewOther(user);
    }

    private void addRequiresNewOther(User user) {
        userDao.addOtherUser(user);
    }

    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNested(User user) {
        userDao.addUser(user);
        // 继续调用其他方法，传播方式为NESTED
        addNestedOther(user);
    }

    private void addNestedOther(User user) {
        userDao.addOtherUser(user);
    }
}

在上面的代码中，addRequired方法、addRequiresNew方法和addNested方法的传播行为分别为REQUIRED、REQUIRES_NEW和NESTED。当执行addRequired方法时，如果外围没有事务，它会自己创建一个事务并使用，如果外围已经存在了一个事务，它就加入到这个事务中并与外围事务一同提交或回滚。当执行addRequiresNew方法时，始终创建新的事务，它不会受外围事务的影响。当执行addNested方法时，如果外围存在事务，它将会在嵌套的事务中运行，并受到外围事务的控制，但是它也可以独立提交或回滚这个嵌套事务。

在使用Spring事务传播行为时，需要根据业务需求和场景选择合适的传播行为，以避免事务失效或其他不必要的问题。

二、隔离级别

关系型数据库中，事务的隔离级别是指在并发访问下，对于不同的事务之间能否看到彼此的数据变化。常见的四种隔离级别分别是：

1. 读未提交（Read uncommitted）：一个事务可以读取到其他未提交事务的数据修改。

2. 读已提交（Read committed）：一个事务只能读取到已经提交的数据，无法读取到其他事务未提交的数据。

3. 可重复读（Repeatable read）：一个事务只能读取到已经提交的数据，并且在该事务中多次读取同一数据时，始终保证读取到的是同一份数据版本。

4. 串行化（Serializable）：所有的并发操作都须按照某种顺序串行执行。即每个事务都是在其他事务执行完之后才能执行。

隔离级别越高，事务并发性越弱，但是数据一致性越高。在选择隔离级别时，需要根据具体场景的并发量、数据一致性要求以及数据库性能等因素来选择。

以下是使用Java编写的一个简单的示例程序，演示事务隔离级别的不同影响：

import java.sql.*;

public class TransactionExample {
    public static void main(String[] args) throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useSSL=false", "root", "123456");

        // 关闭自动提交事务
        conn.setAutoCommit(false);

        // 设置事务隔离级别为读未提交
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

        // 执行查询
        System.out.println("查询结果1：");
        executeQuery(conn);
        System.out.println("******************************");

        // 开启一个新的线程执行数据修改操作
        new Thread(() -> {
            try {
                Connection conn2 = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useSSL=false", "root", "123456");
                conn2.setAutoCommit(false);
                conn2.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
                Statement stmt2 = conn2.createStatement();
                stmt2.executeUpdate("update t_user set balance = balance + 50 where id = 1");
                conn2.commit();
                System.out.println("线程2执行成功！");
                conn2.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }).start();

        // 等待线程执行完成
        Thread.sleep(2000);

        // 再次执行查询
        System.out.println("查询结果2：");
        executeQuery(conn);
        System.out.println("******************************");

        // 回滚事务并关闭连接
        conn.rollback();
        conn.close();
    }

    private static void executeQuery(Connection conn) throws SQLException {
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("select * from t_user where id = 1");
        while (rs.next()) {
            System.out.println(rs.getString("name") + ", " + rs.getDouble("balance"));
        }
        rs.close();
        stmt.close();
    }
}

上述示例程序演示了在事务隔离级别为“读未提交”时，一个事务可以读取到另一个未提交事务的修改。在上述程序中，开启了一个新的线程修改了数据库中的数据，然后主线程又查询了一次数据库中的数据，可以看到主线程读取到的数据已经包含了新的修改。

注：示例程序仅为演示事务隔离级别的效果，并不符合实际应用开发的规范，实际应用开发中需要注意事务的提交和回滚操作，并选择合适的隔离级别。