Spring 多线程事务控制

最新推荐文章于 2024-07-09 17:58:26 发布
最新推荐文章于 2024-07-09 17:58:26 发布
阅读量1.4k 收藏 7
点赞数 2
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35987023/article/details/132908628
版权

java 多线程事务控制

在Java多线程事务控制中，有一些注意事项和实例可以帮助你更好地理解和应用。

注意事项

  1. 确保线程安全：在多线程环境下，确保代码是线程安全的。这可以通过使用synchronized关键字、Lock接口或Atomic类来实现。
  2. 事务的隔离级别：根据需要选择适当的事务隔离级别，以避免并发问题，例如脏读、不可重复读和幻读。
  3. 事务的传播行为：了解事务的传播行为，例如事务的提交和回滚如何影响其他事务。
  4. 异常处理：在多线程环境下处理异常时，需要特别小心。确保捕获和处理所有异常，并正确地处理事务回滚。

spring事务隔离级别

Java Spring框架提供了一种方便的方式来管理数据库事务，它支持多种事务隔离级别。事务隔离级别决定了事务在并发执行时的隔离程度，包括对其他事务的可见性和可能出现的并发问题。

以下是Spring框架支持的事务隔离级别及其详细说明：

  1. ISOLATION_DEFAULT（默认）：这是系统的默认隔离级别。根据具体数据库来定义，大多数数据库默认级别是可重复读。
  2. ISOLATION_READ_UNCOMMITTED（读未提交）：在这个级别，一个事务可以看到其他未提交事务的变动。这种级别可以导致脏读、不可重复读和幻读的问题。
  3. ISOLATION_READ_COMMITTED（读提交）：在这个级别，一个事务只能看到其他事务已经提交的变动。这种级别可以避免脏读问题，但可能会出现不可重复读和幻读的问题。
  4. ISOLATION_REPEATABLE_READ（可重复读）：在这个级别，同一事务中多次读取的数据是一致的。这种级别可以避免脏读和不可重复读的问题，但可能会出现幻读的问题。
  5. ISOLATION_SERIALIZABLE（可串行化）：这是最高的事务隔离级别。在这个级别，事务串行化顺序执行，可以避免脏读、不可重复读和幻读的问题。但是这种隔离级别效率低下，因为事务通常需要等待前一个事务完成，才能继续执行。

Spring事务的默认隔离级别与数据库一致

在Spring中，可以通过以下方式设置事务的隔离级别：

@Transactional(isolation = Isolation.READ_COMMITTED)  
public void someMethod() {  
    // some code  
}

在上述代码中，@Transactional注解指定了事务的隔离级别为READ_COMMITTED。注意，虽然可以使用其他隔离级别，但并不是所有数据库都支持所有的隔离级别。使用哪种隔离级别取决于你的具体需求和数据库的能力。

spring事务传播行为

Java Spring框架中的事务传播行为是指在一个事务方法被另一个事务方法调用时，如何处理事务的传播。事务传播行为定义了在一个方法中调用另一个方法时，事务应该如何启动、提交或回滚。

以下是Spring框架支持的事务传播行为及其详细说明：

  1. PROPAGATION_REQUIRED（必需）：如果当前存在一个事务，那么就加入这个事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
  2. PROPAGATION_SUPPORTS（支持）：支持当前事务，如果当前没有事务，就以非事务方式执行。
  3. PROPAGATION_MANDATORY（强制）：使用当前的事务，如果当前没有事务，就抛出异常。
  4. PROPAGATION_REQUIRES_NEW（新建）：新建事务，如果当前存在事务，把当前事务挂起。
  5. PROPAGATION_NOT_SUPPORTED（不支持）：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  6. PROPAGATION_NEVER（从不）：以非事务方式执行，如果当前存在事务，抛出异常。
  7. PROPAGATION_NESTED（嵌套）：如果当前存在一个事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

在Spring中，可以通过以下方式设置事务的传播行为：

@Transactional(propagation = Propagation.REQUIRES_NEW)  
public void someMethod() {  
    // some code  
}

在上述代码中，@Transactional注解指定了事务的传播行为为REQUIRES_NEW。根据具体情况选择不同的事务传播行为以确保应用程序的数据一致性和可靠性。

spring事务默认传播行为

Spring的事务传播行为默认是PROPAGATION_REQUIRED，也就是如果当前存在一个事务，就加入该事务；如果当前没有事务，就新建一个事务。

mysql事务默认隔离级别

MySQL的事务隔离级别默认是可重复读（REPEATABLE READ），这是大多数数据库系统的默认设置。这个隔离级别可以避免脏读和不可重复读的问题，但可能会出现幻读的问题。

多线程事务控制

Spring实现事务通过ThreadLocal把事务和当前线程进行了绑定。

ThreadLocal作为本地线程变量载体，保存了当前线程的变量，并确保所有变量是线程安全的。

这些封闭隔离的变量中就包含了数据库连接，Session管理的对象以及当前事务运行的其他必要信息，而开启的新线程是获取不到这些变量和对象的。

也就是说：主线程事务与子线程事务是相互独立的

怎么验证？

验证事务 以及 多线程事务控制编码

package cn.cjf.tt;

import cn.cjf.tt.dao.UserMapper;
import cn.cjf.tt.po.User;
import cn.cjf.tt.service.UserService;
import lombok.SneakyThrows;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;


// 使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
// 加载配置文件或者配置类
@ContextConfiguration(locations = {"classpath:spring.xml"})//加载配置文件
public class UserTest {
    @Autowired
    private UserService userService;
    @Autowired
    private DataSourceTransactionManager transactionManager;
    @Autowired
    private UserMapper userMapper;

    /**
     * 验证数据库连接是否正常
     */
    @Test
    public void selectAllUser() {
        List<User> users = userService.selectAllUser();
        for (User i : users) {
            System.out.println(i);
        }
    }

    /**
     * 验证：能否正常插入数据
     */
    public void test() {
        final User user = new User() {{
            this.setUsername("test_" + UUID.randomUUID().toString());
            this.setPassword("123456");
            this.setCreateTime(new Date());
        }};
        userService.addUser(user);
    }

    /**
     * 验证：线程池子线程中能否正常插入数据
     */
    @Test
    public void testForBatch() throws InterruptedException {
        final ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            service.submit(new Runnable() {
                @SneakyThrows
                @Override
                public void run() {
                    test1();
                }
            });
        }
        Thread.sleep(5000);
    }

    /**
     * 验证：正常插入数据，抛出异常后，注解事务是否回滚
     */
    @Transactional(rollbackFor = Exception.class)
    @Test
    public void test1() throws Exception {
        final User user = new User() {{
            this.setUsername("test_" + UUID.randomUUID().toString());
            this.setPassword("123456");
            this.setCreateTime(new Date());
        }};
        userService.addUser(user);
        if (true) {
            throw new Exception();
        }
    }

    /**
     * 验证：正常插入数据，抛出异常后，手动事务是否回滚
     */
    @Test
    public void test11() {
        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
        final TransactionStatus transaction = transactionManager.getTransaction(dd);
        try {
            final User user = new User() {{
                this.setUsername("test_" + UUID.randomUUID().toString());
                this.setPassword("123456");
                this.setCreateTime(new Date());
            }};
            userService.addUser(user);
            System.out.println(user);
            if (true) {
                throw new Exception();
            }
            // User(id=13, username=test1694675733277, password=123456, salt=null, token=null, isEnabled=null, createTime=Thu Sep 14 15:15:33 CST 2023, modifiedTime=null)
            transactionManager.commit(transaction);
            System.out.println("---------------------" + Thread.currentThread().getName() + "事务提交");
        } catch (Exception e) {
            e.printStackTrace();
            transactionManager.rollback(transaction);
            System.out.println("---------------------" + Thread.currentThread().getName() + "事务回滚");
        }
    }


    /**
     * 验证：主线程事务，是否能影响到子线程事务
     */
    @Transactional(rollbackFor = Exception.class)
    @Test
    public void test2() throws Exception {
        final User user = new User() {{
            this.setUsername("test_" + UUID.randomUUID().toString());
            this.setPassword("123456");
            this.setCreateTime(new Date());
        }};
        userService.addUser(user);
        System.out.println("---------------------" + Thread.currentThread().getName() + "：" + user);
        final ExecutorService service = Executors.newFixedThreadPool(5);
        List<Integer> idList = new ArrayList<>();
        idList.add(user.getId());
        for (int i = 0; i < 5; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    final User user = new User() {{
                        this.setUsername("test_" + UUID.randomUUID().toString());
                        this.setPassword("123456");
                        this.setCreateTime(new Date());
                    }};
                    userService.addUserForTransaction(user);
                    System.out.println("---------------------" + Thread.currentThread().getName() + "：" + user);
                    final Integer id = user.getId();
                    idList.add(id);
                }
            });
        }

        Thread.sleep(5000);
        try {
            throw new Exception();
        } finally {
            for (int i = 0; i < idList.size(); i++) {
                final Integer id = idList.get(i);
                final User po = userMapper.selectByPrimaryKey(id);
                if (po == null) {
                    System.out.println("---------------------id:" + id + "事务回滚");
                } else {
                    System.out.println("---------------------id:" + id + "事务提交");
                }
                // 主线程事务未结束
                // 实际主线程事务回滚了，但子线程事务未回滚
            }
        }
    }

    /**
     * 验证：主线程事务，未能影响到子线程事务，是因为子线程的事务传播行为影响
     */
    @Transactional(rollbackFor = Exception.class)
    @Test
    public void test21() throws Exception {
        final User user = new User() {{
            this.setUsername("test_" + UUID.randomUUID().toString());
            this.setPassword("123456");
            this.setCreateTime(new Date());
        }};
        userService.addUser(user);
        System.out.println("---------------------" + Thread.currentThread().getName() + "：" + user);
        final ExecutorService service = Executors.newFixedThreadPool(5);
        List<Integer> idList = new ArrayList<>();
        idList.add(user.getId());
        for (int i = 0; i < 5; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    final User user = new User() {{
                        this.setUsername("test_" + UUID.randomUUID().toString());
                        this.setPassword("123456");
                        this.setCreateTime(new Date());
                    }};
                    userService.addUserForNestedTransaction(user);
                    System.out.println("---------------------" + Thread.currentThread().getName() + "：" + user);
                    final Integer id = user.getId();
                    idList.add(id);
                }
            });
        }

        Thread.sleep(5000);
        try {
            throw new Exception();
        } finally {
            for (int i = 0; i < idList.size(); i++) {
                final Integer id = idList.get(i);
                final User po = userMapper.selectByPrimaryKey(id);
                if (po == null) {
                    System.out.println("---------------------id:" + id + "事务回滚");
                } else {
                    System.out.println("---------------------id:" + id + "事务提交");
                }
                // 主线程事务未结束
                // 实际主线程事务回滚了，但子线程事务未回滚
            }
        }
    }

    /**
     * 验证：主线程事务，未能影响到子线程事务
     * 主线程手动控制事务，与注解自动控制事务，结果是否依然是，主线程事务不能影响到子线程事务
     */
    @Test
    public void test22() throws Exception {
        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
        final TransactionStatus transaction = transactionManager.getTransaction(dd);
        List<Integer> idList = new ArrayList<>();
        try {
            final User user = new User() {{
                this.setUsername("test_" + UUID.randomUUID().toString());
                this.setPassword("123456");
                this.setCreateTime(new Date());
            }};
            userService.addUser(user);
            System.out.println("---------------------" + Thread.currentThread().getName() + "：" + user);
            final ExecutorService service = Executors.newFixedThreadPool(5);
            idList.add(user.getId());
            for (int i = 0; i < 5; i++) {
                service.submit(new Runnable() {
                    @Override
                    public void run() {
                        final User user = new User() {{
                            this.setUsername("test_" + UUID.randomUUID().toString());
                            this.setPassword("123456");
                            this.setCreateTime(new Date());
                        }};
                        userService.addUserForNestedTransaction(user);
                        System.out.println("---------------------" + Thread.currentThread().getName() + "：" + user);
                        final Integer id = user.getId();
                        idList.add(id);
                    }
                });
            }

            Thread.sleep(5000);
            if (true) {
                throw new Exception();
            }

            // User(id=13, username=test1694675733277, password=123456, salt=null, token=null, isEnabled=null, createTime=Thu Sep 14 15:15:33 CST 2023, modifiedTime=null)
            System.out.println("---------------------" + Thread.currentThread().getName() + "事务提交");
        } catch (Exception e) {
            e.printStackTrace();
            transactionManager.rollback(transaction);
            System.out.println("---------------------" + Thread.currentThread().getName() + "事务回滚");
        }

        for (int i = 0; i < idList.size(); i++) {
            final Integer id = idList.get(i);
            final User po = userMapper.selectByPrimaryKey(id);
            if (po == null) {
                System.out.println("---------------------id:" + id + "事务回滚");
            } else {
                System.out.println("---------------------id:" + id + "事务提交");
            }
            // 主线程事务已结束
            // 主线程事务回滚了，但子线程事务未回滚
        }
    }

    /**
     * 验证：主线程事务，未能影响到子线程事务
     * 主线程手动控制事务，子线程也手动控制事务，结果是否依然是，主线程事务不能影响到子线程事务
     */
    @Test
    public void test23() throws InterruptedException {
        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
        final TransactionStatus transaction = transactionManager.getTransaction(dd);
        List<Integer> idList = new ArrayList<>();
        try {
            final User user = new User() {{
                this.setUsername("test_" + UUID.randomUUID().toString());
                this.setPassword("123456");
                this.setCreateTime(new Date());
            }};
            userService.addUser(user);
            idList.add(user.getId());
            final ExecutorService service = Executors.newFixedThreadPool(5);
            for (int i = 0; i < 5; i++) {
                service.submit(new Runnable() {
                    @Override
                    public void run() {
                        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
                        final TransactionStatus transaction = transactionManager.getTransaction(dd);
                        try {
                            final User user = new User() {{
                                this.setUsername("test_" + UUID.randomUUID().toString());
                                this.setPassword("123456");
                                this.setCreateTime(new Date());
                            }};
                            userService.addUser(user);
                            System.out.println(user);
                            final Integer id = user.getId();
                            idList.add(id);
                            // User(id=13, username=test1694675733277, password=123456, salt=null, token=null, isEnabled=null, createTime=Thu Sep 14 15:15:33 CST 2023, modifiedTime=null)
                            transactionManager.commit(transaction);
                            System.out.println("---------------------" + Thread.currentThread().getName() + "事务提交");
                        } catch (Exception e) {
                            e.printStackTrace();
                            transactionManager.rollback(transaction);
                            System.out.println("---------------------" + Thread.currentThread().getName() + "事务回滚");
                        }
                    }
                });
            }

            Thread.sleep(5000);
            if (true) {
                throw new Exception();
            }

            // User(id=13, username=test1694675733277, password=123456, salt=null, token=null, isEnabled=null, createTime=Thu Sep 14 15:15:33 CST 2023, modifiedTime=null)
            System.out.println("---------------------" + Thread.currentThread().getName() + "事务提交");
        } catch (Exception e) {
            e.printStackTrace();
            transactionManager.rollback(transaction);
            System.out.println("---------------------" + Thread.currentThread().getName() + "事务回滚");
        }

        for (int i = 0; i < idList.size(); i++) {
            final Integer id = idList.get(i);
            final User po = userMapper.selectByPrimaryKey(id);
            if (po == null) {
                System.out.println("---------------------id:" + id + "事务回滚");
            } else {
                System.out.println("---------------------id:" + id + "事务提交");
            }
            // 主线程事务已结束
            // 主线程事务回滚了，但子线程事务未回滚
        }
    }

    /**
     * 验证结果：主线程事务不能影响到子线程事务
     * <p>
     * 主线程，子线程控制各自事务，等待一起提交
     */
    @Test
    public void test3() throws InterruptedException {
        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
        final TransactionStatus transaction = transactionManager.getTransaction(dd);
        List<Integer> idList = new ArrayList<>();
        int time = 5;
        CountDownLatch cdl = new CountDownLatch(time);
        AtomicBoolean flag = new AtomicBoolean(true);
        try {
            final User user = new User() {{
                this.setUsername("test_" + UUID.randomUUID().toString());
                this.setPassword("123456");
                this.setCreateTime(new Date());
            }};
            userService.addUser(user);
            idList.add(user.getId());
            final ExecutorService service = Executors.newFixedThreadPool(time);
            for (int i = 0; i < time; i++) {
                service.submit(new Runnable() {
                    @SneakyThrows
                    @Override
                    public void run() {
                        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
                        final TransactionStatus transaction = transactionManager.getTransaction(dd);
                        try {
                            final User user = new User() {{
                                this.setUsername("test_" + UUID.randomUUID().toString());
                                this.setPassword("123456");
                                this.setCreateTime(new Date());
                            }};
                            userMapper.insertSelective(user);
                            idList.add(user.getId());
                            System.out.println("---------------" + Thread.currentThread().getName() + "--执行成功");
                        } catch (Exception e) {
                            e.printStackTrace();
                            System.out.println("---------------" + Thread.currentThread().getName() + "--执行失败，等待事务回滚");
                            flag.set(false);
                        } finally {
                            System.out.println("---------------" + Thread.currentThread().getName() + "--等待");
                            cdl.countDown();
                            cdl.await();
                            if (flag.get()) {
                                System.out.println("---------------" + Thread.currentThread().getName() + "--提交事务");
                                transactionManager.commit(transaction);
                            } else {
                                System.out.println("---------------" + Thread.currentThread().getName() + "--回滚事务");
                                transactionManager.rollback(transaction);
                            }

                            System.out.println("---------------" + Thread.currentThread().getName() + "--End");
                        }
                    }
                });
            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("---------------" + Thread.currentThread().getName() + "--执行失败，等待事务回滚");
            flag.set(false);
        } finally {
            System.out.println("---------------" + Thread.currentThread().getName() + "--等待");
            cdl.await();
            if (flag.get()) {
                System.out.println("---------------" + Thread.currentThread().getName() + "--提交事务");
                transactionManager.commit(transaction);
            } else {
                System.out.println("---------------" + Thread.currentThread().getName() + "--回滚事务");
                transactionManager.rollback(transaction);
            }
        }

        System.out.println("---------------" + Thread.currentThread().getName() + "--End");

        for (int i = 0; i < idList.size(); i++) {
            final Integer id = idList.get(i);
            final User po = userMapper.selectByPrimaryKey(id);
            if (po == null) {
                System.out.println("---------------------id:" + id + "事务回滚");
            } else {
                System.out.println("---------------------id:" + id + "事务提交");
            }
            // 主线程事务已结束
            // 主线程事务回滚了，子线程事务也回滚
        }
    }

    /**
     * 验证结果：主线程事务不能影响到子线程事务
     * <p>
     * 主线程，子线程控制各自事务，等待一起提交
     * 验证，主线程异常，子线程未异常，事务都回滚了
     */
    @Test
    public void test31() throws InterruptedException {
        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
        final TransactionStatus transaction = transactionManager.getTransaction(dd);
        List<Integer> idList = new ArrayList<>();
        int time = 5;
        CountDownLatch cdl = new CountDownLatch(time);
        AtomicBoolean flag = new AtomicBoolean(true);
        try {
            final User user = new User() {{
                this.setUsername("test_" + UUID.randomUUID().toString());
                this.setPassword("123456");
                this.setCreateTime(new Date());
            }};
            userService.addUser(user);
            idList.add(user.getId());
            final ExecutorService service = Executors.newFixedThreadPool(time);
            for (int i = 0; i < time; i++) {
//                int finalI = i;
                service.submit(new Runnable() {
                    @SneakyThrows
                    @Override
                    public void run() {
                        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
                        final TransactionStatus transaction = transactionManager.getTransaction(dd);
                        try {
                            final User user = new User() {{
                                this.setUsername("test_" + UUID.randomUUID().toString());
                                this.setPassword("123456");
                                this.setCreateTime(new Date());
                            }};
                            userMapper.insertSelective(user);
                            idList.add(user.getId());
                            // 最后一个提交的任务，抛出异常；注释掉会全部完成，否则全部回滚
//                            if (finalI == time - 1) {
//                                throw new RuntimeException();
//                            }
                            // User(id=13, username=test1694675733277, password=123456, salt=null, token=null, isEnabled=null, createTime=Thu Sep 14 15:15:33 CST 2023, modifiedTime=null)
                            System.out.println("---------------" + Thread.currentThread().getName() + "--执行成功");
                        } catch (Exception e) {
                            e.printStackTrace();
                            System.out.println("---------------" + Thread.currentThread().getName() + "--执行失败，等待事务回滚");
                            flag.set(false);
                        } finally {
                            System.out.println("---------------" + Thread.currentThread().getName() + "--等待");
                            cdl.countDown();
                            cdl.await();
                            if (flag.get()) {
                                System.out.println("---------------" + Thread.currentThread().getName() + "--提交事务");
                                transactionManager.commit(transaction);
                            } else {
                                System.out.println("---------------" + Thread.currentThread().getName() + "--回滚事务");
                                transactionManager.rollback(transaction);
                            }

                            System.out.println("---------------" + Thread.currentThread().getName() + "--End");
                        }
                    }
                });
            }

            if (true) {
                throw new Exception();
            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("---------------" + Thread.currentThread().getName() + "--执行失败，等待事务回滚");
            flag.set(false);
        } finally {
            System.out.println("---------------" + Thread.currentThread().getName() + "--等待");
            cdl.await();
            if (flag.get()) {
                System.out.println("---------------" + Thread.currentThread().getName() + "--提交事务");
                transactionManager.commit(transaction);
            } else {
                System.out.println("---------------" + Thread.currentThread().getName() + "--回滚事务");
                transactionManager.rollback(transaction);
            }
        }

        System.out.println("---------------" + Thread.currentThread().getName() + "--End");

        for (int i = 0; i < idList.size(); i++) {
            final Integer id = idList.get(i);
            final User po = userMapper.selectByPrimaryKey(id);
            if (po == null) {
                System.out.println("---------------------id:" + id + "事务回滚");
            } else {
                System.out.println("---------------------id:" + id + "事务提交");
            }
            // 主线程事务已结束
            // 主线程事务回滚了，子线程事务也回滚
        }
    }

    /**
     * 验证结果：主线程事务不能影响到子线程事务
     * <p>
     * 主线程，子线程控制各自事务，等待一起提交
     * 验证，主线程未异常，子线程异常，事务都回滚了
     */
    @Test
    public void test32() throws InterruptedException {
        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
        final TransactionStatus transaction = transactionManager.getTransaction(dd);
        List<Integer> idList = new ArrayList<>();
        int time = 5;
        CountDownLatch cdl = new CountDownLatch(time);
        AtomicBoolean flag = new AtomicBoolean(true);
        try {
            final User user = new User() {{
                this.setUsername("test_" + UUID.randomUUID().toString());
                this.setPassword("123456");
                this.setCreateTime(new Date());
            }};
            userService.addUser(user);
            idList.add(user.getId());
            final ExecutorService service = Executors.newFixedThreadPool(time);
            for (int i = 0; i < time; i++) {
                int finalI = i;
                service.submit(new Runnable() {
                    @SneakyThrows
                    @Override
                    public void run() {
                        DefaultTransactionDefinition dd = new DefaultTransactionDefinition();
                        final TransactionStatus transaction = transactionManager.getTransaction(dd);
                        try {
                            final User user = new User() {{
                                this.setUsername("test_" + UUID.randomUUID().toString());
                                this.setPassword("123456");
                                this.setCreateTime(new Date());
                            }};
                            userMapper.insertSelective(user);
                            idList.add(user.getId());
                            // 最后一个提交的任务，抛出异常；注释掉会全部完成，否则全部回滚
                            if (finalI == time - 1) {
                                throw new RuntimeException();
                            }
                            // User(id=13, username=test1694675733277, password=123456, salt=null, token=null, isEnabled=null, createTime=Thu Sep 14 15:15:33 CST 2023, modifiedTime=null)
                            System.out.println("---------------" + Thread.currentThread().getName() + "--执行成功");
                        } catch (Exception e) {
                            e.printStackTrace();
                            System.out.println("---------------" + Thread.currentThread().getName() + "--执行失败，等待事务回滚");
                            flag.set(false);
                        } finally {
                            System.out.println("---------------" + Thread.currentThread().getName() + "--等待");
                            cdl.countDown();
                            cdl.await();
                            if (flag.get()) {
                                System.out.println("---------------" + Thread.currentThread().getName() + "--提交事务");
                                transactionManager.commit(transaction);
                            } else {
                                System.out.println("---------------" + Thread.currentThread().getName() + "--回滚事务");
                                transactionManager.rollback(transaction);
                            }

                            System.out.println("---------------" + Thread.currentThread().getName() + "--End");
                        }
                    }
                });
            }

//            if (true) {
//                throw new Exception();
//            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("---------------" + Thread.currentThread().getName() + "--执行失败，等待事务回滚");
            flag.set(false);
        } finally {
            System.out.println("---------------" + Thread.currentThread().getName() + "--等待");
            cdl.await();
            if (flag.get()) {
                System.out.println("---------------" + Thread.currentThread().getName() + "--提交事务");
                transactionManager.commit(transaction);
            } else {
                System.out.println("---------------" + Thread.currentThread().getName() + "--回滚事务");
                transactionManager.rollback(transaction);
            }
        }

        System.out.println("---------------" + Thread.currentThread().getName() + "--End");

        for (int i = 0; i < idList.size(); i++) {
            final Integer id = idList.get(i);
            final User po = userMapper.selectByPrimaryKey(id);
            if (po == null) {
                System.out.println("---------------------id:" + id + "事务回滚");
            } else {
                System.out.println("---------------------id:" + id + "事务提交");
            }
            // 主线程事务已结束
            // 主线程事务回滚了，子线程事务也回滚
        }
    }
}
qq_35987023
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring 多线程事务的问题
亚索@哈塞给
09-15 1782
线程不属于spring托管，故线程不能够默认使用spring的事务,也不能获取spring注入的bean 在被spring声明式事务管理的方法内开启多线程，多线程内的方法不被事务控制。 如下代码，线程内调用insert方法，spring不会把insert方法加入事务 就算在insert方法上加入@Transactional注解，也不起作用。 （？不解，试过将serviceA变成多例，也不行） Java代码 @Service public class ServiceA .
spring boot注解事务+多线程
01-25
本示例将深入探讨如何使用注解来实现事务控制以及如何在Spring Boot中运用多线程。 首先，让我们关注"注解事务"。在Spring框架中，我们主要依赖`@Transactional`注解来声明事务边界。当一个方法被这个注解标记时，...
spring 使用多线程，保证事务一致性
曾令胜的博客
05-30 302
大体思路，就是所有子线程在各自线程内开启事务，执行业务逻辑后，判断是否抛错，一旦抛错，会把全局AtomicBoolean置为false，因为其具有原子性所以不会有线程不安全问题。所有子线程完业务代码会等待主线程，全部子线程执行业务结束后，主线程等待结束，判断AtomicBoolean是什么状态，一旦false,所有子线程回滚，否则提交。
spring多线程事务控制
Linging_24的博客
03-14 691
【代码】spring多线程事务控制。
Spring多线程事务解决方案
can_meng_yun的博客
01-07 6994
对批量操作进行性能优化时会用到多线程来并行处理，从而提高运行效率。而时有业务要求保证批量操作事务的一致性，但不同线程所对应的是不同的事务，这就无法通过Spring提供的注解@Transactional来保证线程间的事务一致性。这也是Spring事务失效的一种情况。可以参考分布式2PC协议，通过编程式事务的方式，统一管理所有1线程事务的提交或回滚
Spring多线程事务处理方案
qq_43503653的博客
03-11 2117
本文介绍了在spring体系下对多线程事务的处理方案
Springboot 多线程实现事务控制
名字好难想
04-28 1651
springboot 多线程处理事务
Spring的多线程事务
weixin_45733420的博客
05-07 585
【代码】Spring的多线程事务。
spring 多线程 事务的实际应用场景
烤鸭的世界我们不懂的博客
03-04 2230
今天分享的是spring 事务部分的源码： 环境： spring-jdbc 5.0.4.REALEASE 今天分享一下spring事务的方法，这一篇会涉及到多线程的几种场景使用和分析。
springboot控制多线程事务
hehe8881的博客
05-18 2266
import org.springframework.stereotype.Service; import org.springframework.transaction.support.TransactionTemplate; import javax.annotation.Resource; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CountDownLatch; import java.uti
spring 多线程队列执行
08-06
Spring AOP（面向切面编程）可以与多线程结合，用于在任务执行前后添加日志记录、事务管理等逻辑。通过定义切面和通知，我们可以实现对多线程任务的统一管理和监控。 6. **线程安全**： 在多线程环境下，需要特别...
java 后端学习资料包含(spring，多线程).zip
07-10
此外，Spring框架还提供了`@Transactional`注解，用于声明式事务管理，这在多线程环境中尤为重要，因为正确地管理事务边界是确保数据一致性的关键。 本资料包中可能包含有关Spring框架的源码解析，帮助开发者理解其...
详解Springboot对多线程的支持
08-27
Spring是通过任务执行器(TaskExecutor)来实现多线程和并发编程，使用ThreadPoolTaskExecutor来创建一个基于线城池的TaskExecutor。这篇文章给大家介绍Springboot对多线程的支持，感兴趣的朋友一起看看吧
多线程及spring相关面试专题及答案.zip
05-05
6. **Spring事务管理**：Spring提供了声明式和编程式的事务管理，确保在多线程环境中数据的一致性。 7. **Spring Bean**：Spring容器管理的对象称为Bean，容器通过XML、注解或Java配置来定义Bean的生命周期和装配...
SpringSecurity认证逻辑源码分析
qq_43676797的博客
07-07 561
类。
SpringBootV12和mybatis全部知识点
最新发布
近日终于有时间好好回顾下一些作品了，有帮助的好好看就行
07-09 946
框架: 快速开发项目的一个架子sshssmspring --> applicationContext.xml配置文件(spring不是业务层,是管理其他框架的)springmvc --> springmvc.xml配置文件 (对应之前servlet)mybatis —> mybatis-config.xml配置文件(对应之前jdbc)—> springboot优化了之前的框架配置,思想是约定大于配置注意：根据网络状况，可能会提示无法连接。如果不能连接，使用http://start.springboot.io
springboot基于Java的超市进销存系统+ LW+ PPT+源码+讲解
u014445459的博客
07-06 687
操作的多样性也变高了。由此可见，本系统在操作上是可行的。软件测试的方法有好几种，但目前主要采用的是包括以功能为主要测试方向的黑盒测试以及以逻辑为主要测试方向的白盒测试，这是两种不同的测试方法，针对的测试侧重点不同，本课题根据实际需求情况，选择以功能为主要的黑盒测试方法，同时测试是要遵循一定的规则来执行的，一个测试要执行其执行的依据一般是由测试用例来规定的，而测试用例一般是依据需求或说明书来综合制定的，测试在硬件出厂前是十分重要的一个过程，本课题由于时间和精力的关系，选择以实现的功能作为测试要点来进行测试。
spring多线程事务失效
06-10
在Spring中，多线程事务失效的原因可能有以下几种： 1. 多线程事务不是由同一个事务管理器管理。在Spring中，事务管理器是用来管理事务的，如果多个线程使用了不同的事务管理器来管理事务，就会导致多线程事务失效。 2. 事务传播行为设置错误。在Spring中，事务传播行为用来描述在不同方法之间如何传播事务。如果多个线程的事务传播行为设置不同，就会导致多线程事务失效。 3. 多线程事务不在同一个事务中。在Spring中，事务是基于线程的。如果多个线程的事务不在同一个线程中，就会导致多线程事务失效。 4. 多线程事务中出现异常。在Spring中，如果多线程事务中有任何一个线程抛出异常，就会导致整个事务回滚。因此，如果在多线程事务中出现异常，就会导致多线程事务失效。 为了避免多线程事务失效，可以采取以下措施： 1. 使用同一个事务管理器来管理多线程事务。 2. 设置正确的事务传播行为。 3. 确保多个线程在同一个事务中。 4. 避免在多线程事务中出现异常，如果出现异常，就要及时处理异常，以避免整个事务回滚。如果必须回滚，也需要确保所有线程都能够正确回滚。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值