Spring事务在多线程下保证原子性

背景

Springboot项目，有个需求，需要提供接口，接口调用方每一次调用时，都会上报大量的数据，接口需要满足以下要求：

• 数据保存要保证数据原子性：要么全部保存成功，要么全部不保存。
• 保证接口性能。

实践发现，即使使用批量保存，接口耗时也高达一秒多，所以需要开启多线程来保存。现在的问题是，如果保证在开启多线程保存的情况下，保证数据的原子性。

思路

• 开启多线程，每个线程都是使用独立的DB连接。否则由于数据库是串行阻塞操作，最终还是会变成排队操作数据库。
• 依赖spring事务异常回滚机制。
• 有个统一的标识来标识“是否有线程操作失败”。
• 线程如果出现异常：先捕获异常，将标识设置为失败，然后继续抛出异常。
• 线程如果没有异常，在执行的最后，判断标识是失败，也就是“有其他线程有执行失败”，就自定义抛出异常来回滚。
• 通过锁来保证：所有的线程都操作完之后，一起判断标识是否成功；确保不会出现“还有线程的业务未执行完成，其他线程就已经结束工作”。

流程图

失败流程如下：

代码

@Slf4j
@Component
public class AtomicConcurrentTransactionalExecutor {
    @Autowired
    private TransactionalWorker transactionalWorker;

    /**
     * @param threadWwaitTerminationTimeout
     * @param runnables
     * @return boolean
     */
    public boolean execute(int threadWwaitTerminationTimeout, Runnable... runnables) {
        int threadSize = runnables.length;
        CyclicBarrier workerCyclicBarrier = new CyclicBarrier(threadSize);
        AtomicBoolean isSuccess = new AtomicBoolean(true);
        ExecutorService executorService = Executors.newFixedThreadPool(threadSize);
        for (Runnable runnable : runnables) {
            executorService.submit(() -> {
                transactionalWorker.run(workerCyclicBarrier, isSuccess, runnable);
            });
        }
        ThreadUtils.shutdown(executorService, threadWwaitTerminationTimeout, TimeUnit.SECONDS);
        return isSuccess.get();
    }

    /**
     * @param threadWwaitTerminationTimeout
     * @param threadPollSize
     * @param runnable
     * @return boolean
     */
    public boolean execute(int threadWwaitTerminationTimeout, int threadPollSize, Runnable runnable) {
        Runnable[] runnables = IntStream.range(0, threadPollSize)
                .mapToObj(i -> runnable)
                .toArray(Runnable[]::new);
        return execute(threadWwaitTerminationTimeout, runnables);
    }
}

@Component
@Slf4j
public class TransactionalWorker {

    /**
     * @param workerCyclicBarrier
     * @param isSuccess
     * @param runnable
     */
    @Transactional(rollbackFor = Exception.class)
    public void run(CyclicBarrier workerCyclicBarrier, AtomicBoolean isSuccess, Runnable runnable) {
        try {
            runnable.run();
        } catch (Exception e) {
            log.error("TransactionalWorker current thread execute error！");
            isSuccess.set(false);
            throw e;
        } finally {
            try {
                workerCyclicBarrier.await();
            } catch (Exception e) {
                log.error("TransactionalWorker current thread execute CyclicBarrier.await error!", e);
            }
        }
        if (!isSuccess.get()) {
            log.error("TransactionalWorker other thread execute error, create SystemException to rollback！");
            throw new SystemException("TransactionalWorker other thread execute error, create SystemException to rollback！");
        }
    

}

使用例子

• 同样的业务，拆分多个线程来

return atomicConcurrentTransactionalExecutor.execute(10, 2,
  // 业务
  () -> testService.test1()
}

• 不同的业务，每个线程操作不同的业务

return atomicConcurrentTransactionalExecutor.execute(10,
  // 业务1
  () -> testService.test1(),
  // 业务2
  () -> testService.test2(),
}

注意在使用时，同一个类内，调用内部方法，Spring事务不生效的问题。