비관적 락 (Pessimistic Lock)을 이용한 동시성 이슈 해결

1) 비관적 락 (Pessimistic Lock)을 이용한 동시성 이슈 해결

 

(1) 개요

• 이전 게시글에서 Synchronized 키워드를 이용하여 동시성 이슈를 해결하였으나 실무 환경에서는 1대의 WAS만을 이용하지 않고 여러 대의 WAS 서버를 운용하기 때문에 Synchronized를 사용하지 않는다.

 

• 왜냐하면 Synchronized 키워드는 한 대의 WAS 서버에서만 동기화 할 수 있기 때문이다.

 

• 따라서, 여러 대의 WAS 서버에서 DB의 특정 데이터를 변경하는 경우, Race Condition 이 발생할 수 있다.

 

• 이처럼 Race Condition을 해결하기 위해 이번에는 MySQL에서 제공하는 Lock을 이용해 비관적 락으로 해결해보고자 한다.

 

• 이전 게시글의 "(2) 초기 설정" 부분부터 "(4) 결과 [동시성 이슈 발생]" 부분까지는 동일하므로 이전 게시글을 읽었다면 (5) 부분 부터 읽어보도록 하자!

 

(2) 초기 설정

 

실습 환경

• MySQL 8.0
• JDK 11 (IntelliJ)
• Spring boot 2.7
• Spring JDBC 5.3.29

 

application.properties 설정

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/example?serverTimezone=UTC&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=root

 

실습 테이블 생성

// 테이블 생성
CREATE TABLE MEMBER (
ID INT not null auto_increment,
NAME VARCHAR(100) not null,
JOB VARCHAR(30) not null,
POINT int not null,
primary key (ID));

// 초기 데이터 생성
INSERT INTO MEMBER VALUES (1, "userA", 'Student', 0);
INSERT INTO MEMBER VALUES (2, "userB", 'Student', 10);
INSERT INTO MEMBER VALUES (3, "userC", 'Student', 20);

 

MemberDTO 생성

@Getter
@Setter
public class Member {
    private int id;

    private String name;

    private String job;

    private int point;
}

 

(3) 예제 코드

• 실제 환경처럼 웹 서버를 여러 대 구성해서 진행해야 하나 단순한 테스트 용이므로 스레드 풀을 이용하였고 여러 대의 웹 서버에서 접근하는 것처럼 가정한다!!!!

 

• 아래의 예제 코드는 여러 스레드에서 DB에 있는 특정 Member 데이터를 가져와서 Point를 +1 증가한 다음 DB에 업데이트 하는 내용이다.

 

• 특정 Member 데이터를 가져오는 getMember() 메소드, 특정 Member의 Point를 +1 증가한 다음 DB에 업데이트하는 updateMember() 메소드가 있다.

 

• 비관적 락 처리 없이 여러 웹 서버에서 동시에 공유 자원에 접근했을 때, 데이터 일관성이 지켜지는지 한 번 확인해보자!

@Getter
@Setter
public class JdbcTest {

    public static HikariDataSource dataSource = new HikariDataSource();

    static {
        // 접속 정보
        String url = "jdbc:mysql://localhost:3306/sesac?serverTimezone=Asia/Seoul&characterEncoding=UTF-8";
        String id = "root";
        String pwd = "root";

        // 스레드풀 설정
        dataSource.setJdbcUrl(url);
        dataSource.setUsername(id);
        dataSource.setPassword(pwd);
        dataSource.setMaximumPoolSize(100);
        dataSource.setPoolName("test");
    }

    // Member 데이터 가져오는 메소드
    public static Member getMember(Connection conn, String sql, String name) {

        PreparedStatement pstmt = null;
        ResultSet rs = null;
        Member member = new Member();

        try {
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, name);
            rs = pstmt.executeQuery();

            while(rs.next()) {
                member.setId(rs.getInt("id"));
                member.setName(rs.getString("name"));
                member.setJob(rs.getString("job"));
                member.setPoint(rs.getInt("point"));
            }

        } catch (SQLException e) {
            throw new RuntimeException("SQL Error 발생!!");

        } finally {
            // ResultSet 및 PreparedStatement 객체 Close()
            try {
                rs.close();
                pstmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        return member;
    }


    // Member 데이터 업데이트 하는 메소드
    public static int updateMember(Connection conn, String sql, Member member) {
        PreparedStatement pstmt = null;
        int result = 0;

        try {
            pstmt = conn.prepareStatement(sql);
            pstmt.setInt(1, member.getPoint());
            pstmt.setString(2, member.getName());

            result = pstmt.executeUpdate();

        } catch (SQLException e) {
            throw new RuntimeException(e);

        } finally {
            // PreparedStatement 객체 Close()
            try {
                pstmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        return result;
    }

    public static void main(String[] args) throws SQLException {
        // 스레드풀 생성
        ExecutorService es = Executors.newCachedThreadPool();

        int count = 30;

        for (int i=1; i<=count; i++) {

            // Count 숫자만큼 비동기로 작업 처리
            es.execute(() -> {
                try {
                    // Connection 객체 생성 + sql 작성
                    Connection conn = dataSource.getConnection();
                    conn.setAutoCommit(false);

                    String sql = "Select * from member where name = ?";
                    String name = "userA";

                    // Member 객체 가져오기
                    Member member = getMember(conn, sql, name);

                    // Point + 1 증가
                    member.setPoint(member.getPoint() + 1);

                    // Member 업데이트
                    sql = "Update member set point = ? where name = ?";
                    int result = updateMember(conn, sql, member);

                    // transaction 처리
                    if (result >= 1) {
                        conn.commit();
                    } else {
                        conn.rollback();
                    }

                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            });

            // 스레드 풀 작업 큐에 모두 들어가면 Shutdown()
            if (i == count) {
                es.shutdown();
                break;
            }
        }
    }
}

 

(4) 결과 [동시성 이슈 발생]

[실행 전]
MySQL [sesac]> select * from member;
+----+-------+---------+-------+
| ID | NAME  | JOB     | POINT |
+----+-------+---------+-------+
|  1 | userA | Student |     0 |
|  2 | userB | Student |    20 |
|  3 | userC | Student |    30 |
+----+-------+---------+-------+
3 rows in set (0.001 sec)

[실행 후]
MySQL [sesac]> select * from member;
+----+-------+---------+-------+
| ID | NAME  | JOB     | POINT |
+----+-------+---------+-------+
|  1 | userA | Student |    28 |
|  2 | userB | Student |    20 |
|  3 | userC | Student |    30 |
+----+-------+---------+-------+
3 rows in set (0.001 sec)

→ Point +1씩 30번 했으므로 총 30이 되어야 하는데 28이 되어있는 것을 확인할 수 있다.

→ 여러 대의 WAS 서버에서 공유 자원인 (Point)에 동시에 접근하여 Race Condition이 발생하였기 때문이다.

→ 이를 해결하기 위해 비관적 락을 이용해보자!

 

(5) 비관적 락 적용

@Getter
@Setter
public class JdbcTest2 {
            ...
            ...
            ...

    // Member 데이터 가져오는 메소드
    public static Member getMember(Connection conn, String sql, String name) {

        PreparedStatement pstmt = null;
        ResultSet rs = null;
        Member member = new Member();

        try {
            // 비관적 락 설정 !!!!!
            pstmt = conn.prepareStatement(sql + " for update");
            pstmt.setString(1, name);
            rs = pstmt.executeQuery();

            while(rs.next()) {
                member.setId(rs.getInt("id"));
                member.setName(rs.getString("name"));
                member.setJob(rs.getString("job"));
                member.setPoint(rs.getInt("point"));
            }

        } catch (SQLException e) {
            throw new RuntimeException("SQL Error 발생!!");

        } finally {
            // ResultSet 및 PreparedStatement 객체 Close()
            try {
                rs.close();
                pstmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        return member;
    }
             ...
            ...
            ...     

• DB에 접근하여 Member 데이터를 가져오기 전에 해당 레코드에 베타 락을 설정한다.

 

• 다른 WAS 서버에서 해당 레코드를 가져오기 전에 베타 락을 설정해야 하는데 이미 다른 WAS 서버에서 베타 락이 걸려있으므로 해당 락이 풀리기 전까지는 데이터를 조회할 수 없다.

 

• 해당 데이터에 베타 락을 처음 설정한 서버에서 Member 데이터를 가져오고 업데이트 한 다음 Commit 하기 전까지는 베타 락이 해제되지 않으므로 동시성 이슈를 해결할 수 있다.

 

(6) 결과 [동시성 이슈 해결]

[실행 전]
MySQL [sesac]> select * from member;
+----+-------+---------+-------+
| ID | NAME  | JOB     | POINT |
+----+-------+---------+-------+
|  1 | userA | Student |     0 |
|  2 | userB | Student |    20 |
|  3 | userC | Student |    30 |
+----+-------+---------+-------+
3 rows in set (0.001 sec)

[실행 후]
MySQL [sesac]> select * from member;
+----+-------+---------+-------+
| ID | NAME  | JOB     | POINT |
+----+-------+---------+-------+
|  1 | userA | Student |    30 |
|  2 | userB | Student |    20 |
|  3 | userC | Student |    30 |
+----+-------+---------+-------+
3 rows in set (0.001 sec)

• 끗!

 

• 다음에는 낙관적 락을 이용해 동시성 이슈를 해결해보자!

 

[참고] 비관적 락 (Pessimistic Lock) 이란

• 비관적 락은 현재 트랜잭션에서 변경하고자 하는 레코드에 대해 잠금을 먼저 획득하고 변경 작업을 처리하는 방식을 말한다.

 

• 이 처리 방식은 이름에서도 느낄 수 있듯이, “현재 변경하고자 하는 레코드를 다른 트랜잭션에서도 변경할 수 있다” 라는 비관적인 가정을 하기 때문에 먼저 잠금을 획득한다.