인프런 커뮤니티 질문&답변

• 학습 관련 질문을 최대한 상세히 남겨주세요!

• 고민 과정도 같이 나열해주셔도 좋습니다.

• 먼저 유사한 질문이 있었는지 검색해보세요.

• 인프런 서비스 운영 관련 문의는 1:1 문의하기를 이용해주세요.

안녕하세요 댓글 수 구현 강의를 해보다가 동시성 문제를 해결해보고 싶어서 비관적 락 for update를 사용하는 방법으로 한번 코드를 짜보고 테스트를 해보고 있습니다.

코드는 아래처럼 짜보았습니다

@Table(name = "article_comment_count")
@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@ToString
public class ArticleCommentCount {
    @Id
    private Long articleId;
    private Long commentCount;

    public static ArticleCommentCount init(Long articleId, Long commentCount) {
        ArticleCommentCount articleCommentCount = new ArticleCommentCount();
        articleCommentCount.articleId = articleId;
        articleCommentCount.commentCount = commentCount;

        return articleCommentCount;
    }

    public void increase() {
        this.commentCount++;
    }

    public void decrease() {
        this.commentCount--;
    }
}

public interface ArticleCommentCountRepository extends JpaRepository<ArticleCommentCount, Long> {
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    Optional<ArticleCommentCount> findLockedByArticleId(Long articleId);
}

@Service
@RequiredArgsConstructor
public class CommentService {
    private final CommentRepository commentRepository;
    private final Snowflake snowflake = new Snowflake();
    private final ArticleCommentCountRepository articleCommentCountRepository;

    @Transactional
    public CommentResponse create(CommentCreateRequest request) {
        Comment parent = findParent(request);

        Comment comment = commentRepository.save(
                Comment.create(
                        snowflake.nextId(),
                        request.getContent(),
                        parent == null ? null : parent.getCommentId(),
                        request.getArticleId(),
                        request.getWriterId()
                )
        );

        ArticleCommentCount articleCommentCount = articleCommentCountRepository.findLockedByArticleId(request.getArticleId())
                .orElseGet(() -> {
                    ArticleCommentCount newCount = ArticleCommentCount.init(request.getArticleId(), 0L);
                    articleCommentCountRepository.save(newCount);
                    return newCount;
                });

        articleCommentCount.increase();

        articleCommentCountRepository.save(articleCommentCount);

        return CommentResponse.from(comment);
    }

    private Comment findParent(CommentCreateRequest request) {
        Long parentCommentId = request.getParentCommentId();

        if (parentCommentId == null) {
            return null;
        }

        return commentRepository.findById(parentCommentId)
                .filter(not(Comment::getDeleted))
                .filter(Comment::isRoot)
                .orElseThrow();
    }

    public CommentResponse read(Long commentId) {
        return CommentResponse.from(commentRepository.findById(commentId).orElseThrow());
    }

    @Transactional
    public void delete(Long commentId) {
        commentRepository.findById(commentId)
                .filter(not(Comment::getDeleted))
                .ifPresent(comment -> {
                    if (hasChildren(comment)) {
                        comment.delete();
                    } else {
                        delete(comment);
                    }
                });
    }

    private boolean hasChildren(Comment comment) {
        return commentRepository.countBy(comment.getArticleId(), comment.getCommentId(), 2L) == 2;
    }

    private void delete(Comment comment) {
        commentRepository.delete(comment);

        articleCommentCountRepository.findLockedByArticleId(comment.getArticleId())
                .ifPresent(articleCommentCount -> {
                    articleCommentCount.decrease();
                    articleCommentCountRepository.save(articleCommentCount);
                });

        if(!comment.isRoot()) {
            commentRepository.findById(comment.getParentCommentId())
                    .filter(Comment::getDeleted)
                    .filter(not(this::hasChildren))
                    .ifPresent(this::delete);
        }
    }

    public CommentPageResponse readAll(Long articleId, Long page, Long pageSize) {
        return CommentPageResponse.of(
                commentRepository.findAll(articleId, (page - 1) * pageSize, pageSize).stream()
                        .map(CommentResponse::from)
                        .toList(),
                commentRepository.count(articleId, PageLimitCalculator.calculatePageLimit(page, pageSize, 10L))
        );
    }

    // 무한 스크롤
    public List<CommentResponse> readAll(Long articleId, Long lastParentCommentId, Long lastCommentId, Long limit) {
        List<Comment> comments = lastParentCommentId == null || lastCommentId == null ?
                commentRepository.findAllInfiniteScroll(articleId, limit) :
                commentRepository.findAllInfiniteScroll(articleId, lastParentCommentId, lastCommentId, limit);
        return comments.stream()
                .map(CommentResponse::from)
                .toList();
    }

    public Long count(Long boardId) {
        return articleCommentCountRepository.findById(boardId)
                .map(ArticleCommentCount::getCommentCount)
                .orElse(0L);
    }
}

@Test
void concurrencyCountTest() throws InterruptedException {
    Long articleId = 24L;
    int threadCount = 10;

    ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
    CountDownLatch latch = new CountDownLatch(threadCount);

    for(int i = 0; i < threadCount; i++) {
        final Long writerId = (long) (1000 + i);

        executorService.execute(() -> {
            try {
                createComment(new CommentCreateRequest(articleId, "concurrency test", null, writerId));
            } catch (Exception e) {
                System.err.println("Exception in thread: " + Thread.currentThread().getName() + " -> " + e.getMessage());
            } finally {
                latch.countDown();
            }
        });
    }

    latch.await();

    Long commentCount = restClient.get()
        .uri("/v1/comments/articles/{articleId}/count", articleId)
        .retrieve()
        .body(Long.class);

    System.out.println("최종 commentCount = " + commentCount);
    assertThat(commentCount).isEqualTo(threadCount);
}

그런데 이렇게 했을때

맨 처음 실행을 하면 1개의 데이터만 삽입되고 나머지 9개는 소실이됩니다

그리고 한번더 실행하면 11개의 데이터가 저장되는데 맨처음 저장된 1개의 데이터 + 10개의 스레드가 저장한 10개의 데이터가 되어 11개가 됩니다.

여기서 문제가 article_comment_count 테이블에 데이터가 아예 없을때 10개의 스레드가 동시에 insert문을 날리려고해서 Duplicate entry '24' for key 'article_comment_count.PRIMARY' 이런 문제가 나오지 않나 생각이 듭니다만.. create 메서드에 @Transactional(isolation = Isolation.READ_COMMITTED)로 격리 수준을 높여봤지만 여전히 문제가 해결되지 않습니다.

혹시 제가 잘못 이해한 부분이 있을까요? 그리고 동시성 문제를 해결하려면 어떻게 해야할까요? gpt에 물어보거나 구글링해서 찾아봐도 해결이 되지 않아서 질문드립니다!