[JAVA] 😇프로젝트 예약기능에서 마주친 동시성 문제 해결 방법 (synchronized와concurrentHashMap)

랸나·2024년 2월 21일

ConcurrentHashMap Java synchronized 동시성

자바

목록 보기

1/1

🤯문제 발생 상황

유니버스스테이(숙박예약 플랫폼) 프로젝트를 구축하면서, 기능 구현에만 우선순위를 두었었는데 동시성 문제에 대한 피드백을 받았었다.

멀티스레드 환경에서 사용자가 여러명 있다고 가정했을때, 사용자(게스트)가 같은 날짜 혹은 겹치는 날짜에 동시에 예약을 한다면 어떻게 될까?

우선 정말 원초적인 방법으로 테스트해보기 위해서 띄워놓은 서버에서 팀원 한명과 함께 동시에 예약 요청을 해봤다🤣

그랬더니.. 몇번 시도했을 때 정말 동시에 같은 날짜로 예약이 되는 것을 확인할 수 있었다 😓
테스트코드로 쓰레드를 여러개 돌린게 아닌 인간의 손으로 동시성을 체크했는데도 오류가 발생한다면, 실제 서비스에서는 무조건 엄청난 문제가 생길게 분명했다.

그래서 수기가 아닌 테스트코드로 멀티쓰레드 환경을 테스트해봤다.

😤테스트방식

테스트는 아래처럼 서비스를 간략화해서 진행했다.

예약을 담을 createdBookings map을 만든다.

쓰레드를 100개로 지정한 뒤, 멀티스레드 환경으로 요청을 날린다.

bookingDTO(예약 정보를 담은 객체)의 checkin_date와 checkout_date가 같으면 예약이 있는 것으로 간주
3-1. 예약이 이미 존재한다면 => createdBookings 맵에 값을 추가하지 않는다.
3-2. 예약이 없다면 => createdBookings 맵에 값을 추가한다.

테스트코드(동시성 이슈 O)

 @Test
    public void testNoConcurrentBookings() throws InterruptedException {

        long startTime = System.currentTimeMillis();

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

        Map<String, BookingDto> createdBookings = new HashMap<>();
        BookingDto bookingDto = createBookingDto();

        for (int i = 0; i < numThreads; i++) {
            final String bookingId = UUID.randomUUID().toString();
            executorService.submit(() -> {
                try {
                    // 동일한 체크인 및 체크아웃 날짜를 갖는 기존 예약이 있는지 확인
                    boolean isDuplicateBooking = checkForDuplicate(createdBookings, bookingDto);
                    // 중복된 예약이 없을 경우에만 bookingDto를 createdBookings 맵에 추가
                    if (!isDuplicateBooking) {
                        System.out.println("중복된 예약 없음, createdBookings에 추가");
                        createdBookings.put(bookingId, bookingDto);
                    } else {
                        System.out.println("중복된 예약 발견, createdBookings에 추가하지 않음");
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                } finally {
                    latch.countDown();
                }
            });

        }
        // 모든 스레드가 완료될 때까지 대기
        latch.await();
        executorService.shutdown();
        // 생성된 예약의 수를 확인
        System.out.println("createdBookings = " + createdBookings.size());
        assertEquals(1, createdBookings.size());
    }
    
   
   //map에 같은 날짜를 가진 예약건이 있는지 확인하는 메소드
   private boolean checkForDuplicate(Map<String, BookingDto> createdBookings,
            BookingDto newBooking) {
        for (BookingDto existingBooking : createdBookings.values()) {
            if (existingBooking.getBooking_checkin_date()
                    .equals(newBooking.getBooking_checkin_date()) &&
                    existingBooking.getBooking_checkout_date()
                            .equals(newBooking.getBooking_checkout_date())) {
                return true;
            }
        }
        return false;
    }
  // bookingDto를 생성하는 메소드
    private BookingDto createBookingDto() {
        BookingDto bookingDto = new BookingDto();
        bookingDto.setBooking_id(UUID.randomUUID().toString());
        bookingDto.setUser_id("f6b58fa7-a088-453a-8533-d6e1d68eec93");
        bookingDto.setRoom_id("004f28e1-4c1c-40b3-b580-a2293671110f");
        bookingDto.setStatus_id("B01");
        bookingDto.setBooking_checkin_date("2024-02-28");
        bookingDto.setBooking_checkout_date("2024-02-29");
        bookingDto.setBooking_num_of_guest(1);
        bookingDto.setBooking_total_pay_amount(1);
        return bookingDto;
    }

아무런 조치를 해주지 않았을때 , 100개의 멀티스레드 환경에서 동시성 문제가 종종 발생했다.

🤩해결 방법 (1) - Synchronized

 @Test
    public void testSynchronizedBookings() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(numThreads);
        ExecutorService executorService = Executors.newFixedThreadPool(numThreads);

        HashMap<String, BookingDto> createdBookings = new HashMap<>();
        BookingDto bookingDto = createBookingDto();

        for (int i = 0; i < numThreads; i++) {
            final String bookingId = UUID.randomUUID().toString();
            executorService.submit(() -> {
                try {
                
                //***** 임계구역 지정 시작*******//
                    synchronized (lock) {
                        // 동일한 체크인 및 체크아웃 날짜를 갖는 기존 예약이 있는지 확인
                        boolean isDuplicateBooking = checkForDuplicate(createdBookings, bookingDto);
                        // 중복된 예약이 없을 경우에만 bookingDto를 createdBookings 맵에 추가
                        if (!isDuplicateBooking) {
                            System.out.println("중복된 예약 없음, createdBookings에 추가");
                            createdBookings.put(bookingId, bookingDto);
                        } else {
                            System.out.println("중복된 예약 발견, createdBookings에 추가하지 않음");
                        }
                    }
				//***** 임계구역 지정 끝*******//

                } catch (Exception ex) {
                    ex.printStackTrace();
                } finally {
                    latch.countDown();
                }
            });
        }
        // 모든 스레드가 완료될 때까지 대기
        latch.await();
        executorService.shutdown();
        // 생성된 예약의 수를 확인
        assertEquals(1, createdBookings.size());
    }
    
       //map에 같은 날짜를 가진 예약건이 있는지 확인하는 메소드
   private boolean checkForDuplicate(Map<String, BookingDto> createdBookings,
            BookingDto newBooking) {
        for (BookingDto existingBooking : createdBookings.values()) {
            if (existingBooking.getBooking_checkin_date()
                    .equals(newBooking.getBooking_checkin_date()) &&
                    existingBooking.getBooking_checkout_date()
                            .equals(newBooking.getBooking_checkout_date())) {
                return true;
            }
        }
        return false;
    }
  // bookingDto를 생성하는 메소드
    private BookingDto createBookingDto() {
        BookingDto bookingDto = new BookingDto();
        bookingDto.setBooking_id(UUID.randomUUID().toString());
        bookingDto.setUser_id("f6b58fa7-a088-453a-8533-d6e1d68eec93");
        bookingDto.setRoom_id("004f28e1-4c1c-40b3-b580-a2293671110f");
        bookingDto.setStatus_id("B01");
        bookingDto.setBooking_checkin_date("2024-02-28");
        bookingDto.setBooking_checkout_date("2024-02-29");
        bookingDto.setBooking_num_of_guest(1);
        bookingDto.setBooking_total_pay_amount(1);
        return bookingDto;
    }

synchronized 제어자를 통해서 임계구역을 지정한 뒤, 락을 주어 쓰레드가 한개씩만 접근할 수 있도록 했다.

테스트 결과 단 하나의 예약만 생성되면서 무조건 동시성을 보장할 수 있었다!

그러나 확실히 성능상으로는 느려진 것을 확인할 수 있었다.

즉, synchronized 제어자로 락을 줌으로써 동시성은 보장할 수 있지만 그로 인한 성능 저하의 문제가 발생한다.

🤩해결 방법 (2) - ConcurrentHashMap ..?

   @Test
    public void testConcurrentBookingsWithConcurrentHashMap() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(numThreads);
        ExecutorService executorService = Executors.newFixedThreadPool(numThreads);

        Map<String, BookingDto> createdBookings = new ConcurrentHashMap<>();
        BookingDto bookingDto = createBookingDto();

        for (int i = 0; i < numThreads; i++) {
            final String bookingId = UUID.randomUUID().toString();
            executorService.submit(() -> {
                try {
                    // 동일한 체크인 및 체크아웃 날짜를 갖는 기존 예약이 있는지 확인
                    boolean isDuplicateBooking = checkForDuplicate(createdBookings, bookingDto);
                    // 중복된 예약이 없을 경우에만 bookingDto를 createdBookings 맵에 추가
                    if (!isDuplicateBooking) {
                        System.out.println("중복된 예약 없음, createdBookings에 추가");
                        createdBookings.putIfAbsent(bookingId, bookingDto);
                    } else {
                        System.out.println("중복된 예약 발견, createdBookings에 추가하지 않음");
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                } finally {
                    latch.countDown();
                }
            });
        }
        // 모든 스레드가 완료될 때까지 대기
        latch.await();
        executorService.shutdown();
        // 생성된 예약의 수를 확인
        System.out.println("createdBookings = " + createdBookings.size());
        assertEquals(1, createdBookings.size());
    }
    
       //map에 같은 날짜를 가진 예약건이 있는지 확인하는 메소드
   private boolean checkForDuplicate(Map<String, BookingDto> createdBookings,
            BookingDto newBooking) {
        for (BookingDto existingBooking : createdBookings.values()) {
            if (existingBooking.getBooking_checkin_date()
                    .equals(newBooking.getBooking_checkin_date()) &&
                    existingBooking.getBooking_checkout_date()
                            .equals(newBooking.getBooking_checkout_date())) {
                return true;
            }
        }
        return false;
    }
  // bookingDto를 생성하는 메소드
    private BookingDto createBookingDto() {
        BookingDto bookingDto = new BookingDto();
        bookingDto.setBooking_id(UUID.randomUUID().toString());
        bookingDto.setUser_id("f6b58fa7-a088-453a-8533-d6e1d68eec93");
        bookingDto.setRoom_id("004f28e1-4c1c-40b3-b580-a2293671110f");
        bookingDto.setStatus_id("B01");
        bookingDto.setBooking_checkin_date("2024-02-28");
        bookingDto.setBooking_checkout_date("2024-02-29");
        bookingDto.setBooking_num_of_guest(1);
        bookingDto.setBooking_total_pay_amount(1);
        return bookingDto;
    }

테스트를 통해 의외의 결과를 얻었다.
구글링을 해봤을 때, concurrentHashMap을 멀티스레드 환경에서 동시성을 보장하기 위한 자료구조로 많이 선택한다는 레퍼런스를 많이 봤기에 당연히 성공일줄 알았다!

그런데 실패하는 경우가 왕왕 있었다. 도통 이유가 무엇인지 모르겠어서 몇시간을 고민하다가 아래 내용의 블로그를 찾았다.

ConcurrentHashMap은 조회시 Lock을 할까?

concurrentHashMap은 조회에서는 synchronized가 구현되어있지 않다는것.
하지만 그럼에도 불구하고 concurrentHashMap은 CAS 알고리즘 방식으로 동시성을 보장해야하는데,
현재 내 테스트코드상의 오류로 인해서 동시성을 보장하지 못하고 있는 것 같다.

하루종일 살펴봤지만 어떤 부분이 문제인지 잘 모르겠어서, 추후 concurrentHashMap과 동시성에 대해서 더 공부해보려고 한다!

결론

synchronized를 사용하면 임계구역에서 lock을 얻어 멀티스레드 환경에서의 동시성을 보장할 수 있다.

..그러나!

1.서버가 여러대일 경우에는 이 제어자 또한 동시성을 보장하기 어렵다. synchronized는 하나의 프로세스에서만 동시성을 보장하기 때문이다.

2.성능에 대한 이슈가 있다. 실제로 내가 테스트 했을 때도 약 1.2~1.5배의 시간이 더 걸리는 것을 확인할 수 있었다.

그렇다면?
어떻게 해야할지 지피티에게 물어봤다.

👩‍💻 질문 : synchronized는 단일 프로세스에서만 동작하기때문에 서버가 여러대인 경우 동시성 문제를 해결하기 어렵다고 하잖아. 그럼 서버가 여러대인 경우 동시성 문제를 해결하려면 어떻게 해야해? 키워드 위주로 알려줄 수 있어?

👩‍💻 답변 :
맞습니다. 여러 대의 서버에서 동시성 문제를 해결하기 위해서는 몇 가지 기술과 원칙을 고려해야 합니다. 아래는 키워드 위주로 설명합니다:

분산 락 (Distributed Locking):

ZooKeeper, etcd 등의 분산 시스템: 분산된 서버 간에 동시성을 보장하기 위해 공유된 리소스에 대한 락을 사용할 수 있습니다.
트랜잭션 처리:

분산 트랜잭션 (Distributed Transactions): 여러 서버 간의 트랜잭션을 관리하여 일관성을 유지할 수 있습니다. 그러나 이는 복잡하고 성능에 영향을 미칠 수 있습니다.
버전 관리 (Versioning):

Optimistic Concurrency Control (OCC): 각 리소스에 대해 버전을 관리하여 충돌을 감지하고 해결하는 방식으로 동시성을 제어할 수 있습니다.
비동기 처리 (Asynchronous Processing):

메시지 큐 및 이벤트 기반 아키텍처: 비동기적으로 작업을 처리하고 서버 간의 통신을 최소화하여 동시성 문제를 완화할 수 있습니다.
분할과 정복 (Sharding):

데이터베이스 샤딩: 데이터를 여러 서버에 분산하여 부하를 분산하고 동시성을 향상시킬 수 있습니다.
캐시 활용:

분산 캐싱 시스템: 공통 데이터에 대한 캐싱을 사용하여 빈번한 읽기 작업의 부하를 줄이고 응답 시간을 개선할 수 있습니다.
동기화 없는 아키텍처 (Asynchronous Architectures):

마이크로서비스 아키텍처: 독립적으로 동작하는 서비스들을 조합하여 동시성 문제를 완화할 수 있습니다.
CAP 이론:

Consistency, Availability, Partition Tolerance: 이 세 가지 중 두 가지만 선택 가능하므로 시스템의 요구 사항에 따라 적절한 선택을 해야 합니다.
Quorum 기반 시스템:

분산 시스템에서 다수결을 이용한 의사 결정: 읽기 및 쓰기 작업에 대한 다수 결정을 통해 일관성을 유지하면서도 가용성을 확보할 수 있습니다.
이러한 기술과 원칙을 조합하여 분산 환경에서 동시성 문제를 효과적으로 관리할 수 있습니다.

서칭해봤을때도 분산락, 레디스, 트랜잭션 처리 등의 키워드가 많이 나와서, 추후에 서버가 여러대인 경우 사용할 수 있는 방법에 대해서도 공부해보려고 한다.

랸나

백엔드개발자