Hibernate环境下J2EE多线程同事务写入数据库问题排查

需求背景 #

在J2EE环境中实现数据库并行写入，数据库内置检查数据一致性的触发器，因此必须采用并行执行方式。核心要求是所有写入操作处于同一事务，确保任一线程出错时整个事务回滚，避免数据部分持久化。

尝试方案及问题分析 #

方案1：手动创建EntityManager绑定事务 #

问题：无法实现并行，推测事务内无法使用多个并行EntityManager。

@Stateless
@Local
@TransactionManagement(TransactionManagementType.BEAN)
public class ParallelBean {

 private static ThreadPoolExecutor executor;

 @Resource
 private SessionContext sessionContext;

 private ThreadLocal<EntityManager> threadLocal = new ThreadLocal<EntityManager>();

 @PersistenceUnit(unitName = "BASE_")
 private EntityManagerFactory entityManagerFactory;

 public void writeParallel() {
         UserTransaction beginTransaction = sessionContext.getUserTransaction();
         beginTransaction.begin();
         Map<Integer, EntityManager> map = new HashMap<>();
         for (int i = 0; i < 6; i++) {
             EntityManager em = entityManagerFactory.createEntityManager();
             em.joinTransaction();
             map.put(i, em);
         }
         final List<Future<?>> futureElements = new ArrayList<>();
         for (int i = 0; i < 6; i++) {
             final int a = i;
             futureElements.add(executor.submit(() -> {
                 EntityManager entityManager = map.get(a);
                 threadLocal.set(entityManager);
                 createEntity();
             }));
         }

         readResults(futureElements);
         beginTransaction.commit();
     }

     @Transactional(value = TxType.REQUIRED)
     public void createEntity() throws NotSupportedException, SystemException {
         DummyBusinessEntity newEntity = new DummyBusinessEntity ();
         threadLocal.get().persist(newEntity);
     }
 }

问题根源：

• JTA事务与线程强绑定，手动创建的EntityManager加入事务后，仅能在发起事务的主线程中操作，线程池任务属于独立线程，无法共享该事务上下文。
• Bean管理事务（BMT）模式下，@Transactional注解不生效，createEntity方法并未真正参与外层的UserTransaction。

方案2：通过DAO注入EntityManager #

问题：可实现并行，但每次插入后自动提交，出错时导致数据不一致。

@Stateless
@Local
@TransactionManagement(TransactionManagementType.BEAN)
public class ParallelBean {

 private static ThreadPoolExecutor executor;

 @Resource
 private SessionContext sessionContext;

 @PersistenceUnit(unitName = "BASE_")
 private EntityManagerFactory entityManagerFactory;

 public void writeParallel() {
         UserTransaction beginTransaction = sessionContext.getUserTransaction();
         beginTransaction.begin();

         final List<Future<?>> futureElements = new ArrayList<>();
         for (int i = 0; i < 6; i++) {
             final int a = i;
             futureElements.add(executor.submit(() -> {
                 createEntity();
             }));
         }

         readResults(futureElements);
         beginTransaction.commit();
     }

     @Transactional(value = TxType.REQUIRED)
     public void createEntity() throws NotSupportedException, SystemException {
         DummyBusinessEntity newEntity = new DummyBusinessEntity ();
         dummyDao.persistData(newEntity);
     }
 }

 @Stateless
 @TransactionAttribute(TransactionAttributeType.REQUIRED)
 @Local
 public class DummyDAO {

     @PersistenceContext(unitName = "BASE_", type = PersistenceContextType.TRANSACTION)
     protected EntityManager em;


     public void persistData(DummyBE entity) {
         em.persist(entity);
     }
 }

问题根源：

• 线程池任务运行在独立线程，未继承主线程的JTA事务上下文，@TransactionAttribute(REQUIRED)会为每个任务创建独立事务，执行完em.persist后自动提交，外层UserTransaction无法控制这些子事务。

正确解决方案 #

要实现同一事务下的并行写入，核心是让所有并行任务共享同一个JTA事务上下文，同时确保数据库支持同一事务内的多线程并行DML操作（如Oracle、PostgreSQL均支持）。

实现步骤 #

1. 改用容器管理事务（CMT），简化事务上下文传递。
2. 使用容器托管的ManagedExecutorService替代自定义线程池，确保线程能感知JTA事务。
3. 通过TransactionSynchronizationManager将主线程的事务上下文绑定到任务线程，让每个任务的EntityManager能加入全局事务。

示例代码 #

@Stateless
@Local
@TransactionManagement(TransactionManagementType.CONTAINER)
public class ParallelBean {

    @Resource
    private ManagedExecutorService executorService;

    @PersistenceUnit(unitName = "BASE_")
    private EntityManagerFactory emFactory;

    public void writeParallel() throws Exception {
        // CMT模式下容器自动开启全局事务
        List<Callable<Void>> tasks = new ArrayList<>();

        for (int i = 0; i < 6; i++) {
            final int index = i;
            tasks.add(() -> {
                // 将主线程的事务上下文绑定到当前任务线程
                TransactionSynchronizationManager.initSynchronization();
                EntityManager taskEm = null;
                try {
                    taskEm = emFactory.createEntityManager();
                    taskEm.joinTransaction(); // 加入全局事务

                    DummyBusinessEntity newEntity = new DummyBusinessEntity();
                    newEntity.setField("Parallel_Data_" + index);
                    taskEm.persist(newEntity);
                } finally {
                    if (taskEm != null) {
                        taskEm.close();
                    }
                    TransactionSynchronizationManager.clearSynchronization();
                }
                return null;
            });
        }

        // 提交所有任务并等待完成，任一任务抛异常则触发全局事务回滚
        List<Future<Void>> futures = executorService.invokeAll(tasks);
        for (Future<Void> future : futures) {
            future.get();
        }

        // 无异常时容器自动提交全局事务
    }
}

关键注意事项 #

• 容器托管线程池：自定义线程池无法感知JTA事务，必须使用JEE容器提供的ManagedExecutorService（需在容器配置中启用，如Wildfly、WebLogic均支持）。
• EntityManager线程安全：EntityManager本身非线程安全，每个任务需创建独立实例，加入全局事务后执行操作，完成后关闭。
• 异常传播：通过future.get()捕获所有任务异常，只要有一个任务抛出异常，容器会自动回滚整个全局事务。

内容的提问来源于stack exchange，提问作者sensen ol