多线程调用时抛出org.hibernate.LazyInitializationException异常求助

问题原因 #

你遇到的是LazyInitializationException（懒加载初始化异常），根源在于：

• Spring的事务和JPA的EntityManager是线程绑定的，默认CompletableFuture.supplyAsync使用JDK的ForkJoinPool公共线程池，这些线程不在Spring的事务上下文范围内。
• 异步线程中调用repository.findById(id)后，EntityManager会立即关闭（无事务维持上下文），返回的A对象变成脱离持久化上下文的游离对象。后续在主线程调用A#getB()时，没有可用的EntityManager加载懒加载的B关联对象，因此抛出异常。

解决方案 #

方案1：异步任务绑定事务上下文 #

将查询逻辑抽离到独立的异步方法中，通过@Transactional和@Async注解让每个异步任务拥有自己的事务与EntityManager上下文：

@Service
@RequiredArgsConstructor
public class AService {

    private final Repository repository;
    private final AsyncQueryService asyncQueryService;

    public List<A> getAs(String[] ids) {
        return Arrays.stream(ids)
                .map(asyncQueryService::findAWithTransactionalContext)
                .map(CompletableFuture::join)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    // 独立类确保@Async代理生效（Spring AOP机制限制）
    @Service
    @RequiredArgsConstructor
    public static class AsyncQueryService {
        private final Repository repository;

        @Async
        @Transactional
        public CompletableFuture<A> findAWithTransactionalContext(String id) {
            return CompletableFuture.completedFuture(repository.findById(id).orElse(null));
        }
    }
}

方案2：提前加载关联对象（推荐） #

修改Repository，通过FETCH JOIN在查询A时直接加载关联的B，从根源避免懒加载问题：

public interface Repository extends JpaRepository<A, String> {
    @Query("SELECT a FROM A a LEFT JOIN FETCH a.b WHERE a.id = :id")
    Optional<A> findByIdWithB(@Param("id") String id);
}

同步修改业务方法：

@Service
@RequiredArgsConstructor
public class AService {

    private final Repository repository;

    public List<A> getAs(String[] ids) {
        List<A> as = Collections.synchronizedList(new ArrayList<>());

        List<CompletableFuture<Boolean>> futures = new ArrayList<>();
        for (String id : ids) {
            futures.add(CompletableFuture.supplyAsync(() -> repository.findByIdWithB(id).orElse(null))
                    .thenApply(as::add));
        }

        futures.forEach(CompletableFuture::join);

        return as;
    }
}

这种方式无需依赖事务上下文，还能减少后续数据库查询，性能更优。

方案3：自定义线程池传递上下文（进阶） #

配置Spring管理的线程池，让异步线程继承主线程的Spring上下文：

@Configuration
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(20);
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
}

业务方法中使用该线程池：

@Service
@RequiredArgsConstructor
public class AService {

    private final Repository repository;
    private final Executor taskExecutor;

    public List<A> getAs(String[] ids) {
        List<A> as = Collections.synchronizedList(new ArrayList<>());

        List<CompletableFuture<Boolean>> futures = new ArrayList<>();
        for (String id : ids) {
            futures.add(CompletableFuture.supplyAsync(() -> repository.findById(id).orElse(null), taskExecutor)
                    .thenApply(as::add));
        }

        futures.forEach(CompletableFuture::join);

        return as;
    }
}

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