Synchrozied 키워드를 이용한 동시성 이슈 해결

1) Synchrozied 키워드를 이용한 동시성 이슈 해결

 

(1) 개요

• 웹 애플리케이션 서버 (WAS) 에서는 HTTP 요청 당 User Thread를 만들기 때문에 1대의 WAS에서 단일 DB 로의 세션은 요청 개수만큼 사용한다.

 

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

 

• 이처럼 Race Condition 을 해결하기 위해 Java에서 제공하는 Synchronized 키워드를 이용해 해결해보고자 한다.

 

(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) 예제 코드

• 비동기 작업 처리를 위해 스레드 풀 (ExecutorService)을 사용하였다.

 

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

 

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

 

• Synchronized 키워드 없이 여러 스레드가 동시에 공유 자원에 접근했을 때, 데이터 일관성이 지켜지는지 한 번 확인해보자!

@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이 되어있는 것을 확인할 수 있다.

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

→ 이를 해결하기 위해 Synchronized 키워드를 이용해보자!

 

(5) Synchronized 키워드 적용

@Getter
@Setter
public class JdbcTest {
            ...
            ...
            ...

    public static void main(String[] args) throws SQLException {
            ...
            ...
            ...

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

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

                    synchronized (JdbcTest.class) {
                        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;
            }
        }
    }
}

• Synchronized 블록을 이용해서 Member 데이터를 가져오고 업데이트 하는 부분을 Lock 처리하여 여러 스레드가 동시에 공유 자원에 접근하지 못하도록 하였다.

 

→ 상호 배제 동기화!!

 

(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)

• 동시성 이슈 해결!

 

• 사실, 위의 코드는 실제 웹 서버를 통한 요청으로 한 것이 아니라 간단하게 JDBC와 스레드풀을 이용하여 테스트하였기 때문에 직관적으로 와닿지 않을 수 있다.

 

• 나중에 프로젝트할 때, 분산 시스템 환경에서 테스트 해보는 것이 좋을 것 같다 b