DB 커넥션 풀, 왜 필요하고 어떻게 설정해야 할까

1
// 1997년 스타일 JDBC 코드
2
class OldSchoolDatabase {
3
    void insertUser(String name) throws SQLException {
4
        // 1. DB 연결 생성 (비싸다!)
5
        Connection conn = DriverManager.getConnection(
6
            "jdbc:mysql://localhost:3306/mydb",
7
            "username",
8
            "password"
9
        );
10

11
        // 2. 쿼리 실행
12
        Statement stmt = conn.createStatement();
13
        stmt.executeUpdate("INSERT INTO users VALUES ('" + name + "')");
14

15
        // 3. 연결 종료
16
        stmt.close();
17
        conn.close(); // 다시 만들어야 함...
18
    }
19
}

1
// 커넥션 생성 비용 측정
2
class ConnectionBenchmark {
3
    public static void main(String[] args) {
4
        long start = System.currentTimeMillis();
5

6
        for (int i = 0; i < 100; i++) {
7
            try (Connection conn = DriverManager.getConnection(
8
                "jdbc:mysql://localhost:3306/test", "root", "password")) {
9
                // 커넥션만 만들고 바로 닫음
10
            }
11
        }
12

13
        long end = System.currentTimeMillis();
14
        System.out.println("100개 커넥션 생성 시간: " + (end - start) + "ms");
15
        // 결과: 약 3000~5000ms (30~50ms per connection)
16
    }
17
}

1
// 커넥션 풀의 개념
2
class SimpleConnectionPool {
3
    private Queue<Connection> pool = new LinkedList<>();
4

5
    // 애플리케이션 시작 시 미리 생성
6
    public SimpleConnectionPool(int poolSize) {
7
        for (int i = 0; i < poolSize; i++) {
8
            pool.add(createNewConnection());
9
        }
10
    }
11

12
    // 커넥션 빌려주기
13
    public Connection getConnection() {
14
        if (pool.isEmpty()) {
15
            throw new SQLException("커넥션 풀이 비었습니다!");
16
        }
17
        return pool.poll();
18
    }
19

20
    // 커넥션 반납
21
    public void returnConnection(Connection conn) {
22
        pool.offer(conn);
23
    }
24
}

1
// 커넥션 풀을 매번 새로 만든다면?
2
class BadConnectionPoolUsage {
3
    void processRequest() throws SQLException {
4
        // 문제: 요청마다 풀을 새로 생성!
5
        HikariConfig config = new HikariConfig();
6
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
7
        config.setUsername("user");
8
        config.setPassword("password");
9
        config.setMaximumPoolSize(10);
10

11
        // 풀 생성 시 10개 커넥션을 미리 만듦
12
        HikariDataSource pool = new HikariDataSource(config);  // 비싸다!
13

14
        // 사용
15
        Connection conn = pool.getConnection();
16
        // ... 쿼리 실행 ...
17
        conn.close();
18

19
        pool.close();  // 풀을 닫으면 10개 커넥션 모두 종료!
20
    }
21
}

1
// 올바른 방법: 싱글톤으로 하나만 만들기
2
class ConnectionPoolManager {
3
    // 애플리케이션 전체에서 딱 1개만 존재!
4
    private static HikariDataSource dataSource;
5

6
    // 애플리케이션 시작 시 한 번만 초기화
7
    static {
8
        HikariConfig config = new HikariConfig();
9
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
10
        config.setUsername("user");
11
        config.setPassword("password");
12
        config.setMaximumPoolSize(10);
13

14
        dataSource = new HikariDataSource(config);
15
        // 여기서 10개 커넥션을 미리 생성 (시작 시 한 번만!)
16
    }
17

18
    public static DataSource getDataSource() {
19
        return dataSource;
20
    }
21
}

1
// 사용하는 곳
2
@Service
3
class UserService {
4
    @Autowired
5
    private DataSource dataSource;  // 싱글톤 풀 주입
6

7
    void processRequest() throws SQLException {
8
        // 풀에서 커넥션만 빌려옴 (빠름!)
9
        Connection conn = dataSource.getConnection();
10
        // ... 쿼리 실행 ...
11
        conn.close();  // 풀에 반납 (종료 아님!)
12
    }
13
}

1
@Configuration
2
public class DataSourceConfig {
3

4
    @Bean  // Spring이 싱글톤으로 관리!
5
    public DataSource dataSource() {
6
        HikariConfig config = new HikariConfig();
7
        config.setJdbcUrl(jdbcUrl);
8
        config.setUsername(username);
9
        config.setPassword(password);
10
        config.setMaximumPoolSize(10);
11

12
        // 애플리케이션 시작 시 딱 1번만 실행됨!
13
        return new HikariDataSource(config);
14
    }
15
}

1
// 잘못된 방법: 메모리 낭비
2
class MemoryWaste {
3
    void badApproach() {
4
        // 요청 1: 커넥션 풀 1개 (10개 커넥션) = 20MB
5
        HikariDataSource pool1 = new HikariDataSource(config);
6

7
        // 요청 2: 커넥션 풀 1개 (10개 커넥션) = 20MB
8
        HikariDataSource pool2 = new HikariDataSource(config);
9

10
        // 요청 3: 커넥션 풀 1개 (10개 커넥션) = 20MB
11
        HikariDataSource pool3 = new HikariDataSource(config);
12

13
        // 총 메모리: 60MB + GC 부담 증가
14
    }
15
}
16

17
// 올바른 방법: 싱글톤
18
class MemoryEfficient {
19
    private static HikariDataSource pool = new HikariDataSource(config);
20
    // 애플리케이션 전체에서 20MB만 사용
21

22
    void goodApproach() {
23
        // 모든 요청이 같은 풀 공유
24
        Connection conn = pool.getConnection();
25
    }
26
}

1
<!-- C3P0 설정 (2000년대 스타일) -->
2
<c3p0-config>
3
    <default-config>
4
        <property name="driverClass">com.mysql.jdbc.Driver</property>
5
        <property name="jdbcUrl">jdbc:mysql://localhost/test</property>
6
        <property name="user">root</property>
7
        <property name="password">password</property>
8

9
        <property name="minPoolSize">5</property>
10
        <property name="maxPoolSize">20</property>
11
        <property name="acquireIncrement">5</property>
12
    </default-config>
13
</c3p0-config>

1
// Tomcat JDBC Pool 설정
2
org.apache.tomcat.jdbc.pool.DataSource ds =
3
    new org.apache.tomcat.jdbc.pool.DataSource();
4
ds.setUrl("jdbc:mysql://localhost:3306/test");
5
ds.setDriverClassName("com.mysql.jdbc.Driver");
6
ds.setUsername("root");
7
ds.setPassword("password");
8
ds.setMaxActive(100);
9
ds.setMaxIdle(10);

1
# Spring Boot 2.0+ 기본 설정
2
spring:
3
  datasource:
4
    hikari:
5
      # HikariCP가 기본이 됨
6
      maximum-pool-size: 10
7
      connection-timeout: 30000

1
// 다른 풀들: ArrayList.get() 사용
2
Connection conn = connectionList.get(index);
3
// ArrayList.get()은 범위 체크를 함
4
public E get(int index) {
5
    rangeCheck(index); // 불필요한 체크!
6
    return elementData[index];
7
}
8

9
// HikariCP: FastList 직접 구현
10
Connection conn = fastList.get(index);
11
// 범위 체크 없이 직접 접근
12
public T get(int index) {
13
    return elementData[index]; // 바로 접근
14
}

1
// HikariCP의 ConcurrentBag
2
class ConcurrentBag<T> {
3
    // 각 스레드가 자기 전용 리스트를 가짐 (락 없음!)
4
    private ThreadLocal<List<T>> threadList = new ThreadLocal<>();
5

6
    // 공유 큐 (백업용)
7
    private CopyOnWriteArrayList<T> sharedList;
8

9
    T borrow() {
10
        // 1단계: 내 전용 리스트에서 찾기 (락 없음!)
11
        List<T> list = threadList.get();
12
        for (T item : list) {
13
            if (item.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
14
                return item;
15
            }
16
        }
17

18
        // 2단계: 공유 리스트에서 찾기
19
        for (T item : sharedList) {
20
            if (item.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
21
                return item;
22
            }
23
        }
24

25
        return null;
26
    }
27
}

1
// MySQL Connector/J 드라이버 설정으로 캐싱 활성화
2
// jdbc:mysql://localhost:3306/mydb?cachePrepStmts=true&prepStmtCacheSize=250
3
Connection conn = dataSource.getConnection();
4
PreparedStatement ps = conn.prepareStatement("SELECT * FROM users WHERE id = ?");

1
spring:
2
  datasource:
3
    hikari:
4
      # 커넥션 풀 크기
5
      maximum-pool-size: 20
6
      minimum-idle: 20
7

8
      # 타임아웃
9
      connection-timeout: 3000        # 3초
10
      validation-timeout: 1000        # 1초
11

12
      # 생명주기
13
      max-lifetime: 580000            # 9분 40초 (DB wait_timeout보다 짧게)
14
      idle-timeout: 0                 # 0 = 유휴 만료 없음
15
      keepalive-time: 30000           # 30초
16
      # 주의 1: idle-timeout은 max-lifetime보다 '짧을' 때만 의미가 있다
17
      #         (길면 max-lifetime이 먼저 커넥션을 제거하므로 무의미).
18
      # 주의 2: 아래 권장대로 minimum-idle == maximum-pool-size(고정 풀)면
19
      #         HikariCP가 유휴 제거 자체를 비활성화하므로 idle-timeout은 어차피 동작하지 않는다.
20
      #         그래서 여기선 0으로 명시했다.
21

22
      # 기타
23
      auto-commit: true
24
      leak-detection-threshold: 60000 # 60초

1
hikari:
2
  maximum-pool-size: 20
3
  minimum-idle: 20  # 같은 값!

1
hikari:
2
  connection-timeout: 3000  # 3초

1
hikari:
2
  max-lifetime: 580000  # 9분 40초

1
-- MySQL에서 wait_timeout 확인
2
SHOW VARIABLES LIKE 'wait_timeout';
3

4
-- wait_timeout 설정 (10분)
5
SET GLOBAL wait_timeout = 600;
6
SET GLOBAL interactive_timeout = 600;

1
hikari:
2
  leak-detection-threshold: 60000  # 60초

1
// 누수 발생 예시
2
@Service
3
class UserService {
4
    @Autowired
5
    private DataSource dataSource;
6

7
    void badMethod() throws SQLException {
8
        Connection conn = dataSource.getConnection();
9
        // 쿼리 실행
10
        Statement stmt = conn.createStatement();
11
        stmt.executeQuery("SELECT * FROM users");
12

13
        // 문제: conn.close()를 안 했다!
14
        // 60초 후 HikariCP가 경고 로그 출력
15
        // WARN - Connection leak detection triggered
16
    }
17
}

1
connections = (core_count × 2) + effective_spindle_count

1
CPU: 1 GHz = 10억 사이클/초
2
디스크: 100 IOPS = 100번/초
3
네트워크: 1ms 레이턴시 = 1000번/초
4

5
속도 차이: 약 100만 배!

1
server:
2
  tomcat:
3
    threads:
4
      max: 200  # 톰캣 최대 스레드

1
@Service
2
class OrderService {
3
    @Transactional
4
    void createOrder(Order order) {
5
        // 1개의 커넥션만 사용
6
        orderRepository.save(order);
7
        itemRepository.updateStock(order.getItemId());
8
    }
9
}
10

11
@Service
12
class ComplexService {
13
    void complexOperation() {
14
        // 문제: 2개의 커넥션이 필요!
15
        Connection conn1 = dataSource.getConnection(); // 1번
16
        // ... 작업 중 ...
17
        Connection conn2 = dataSource.getConnection(); // 2번
18
        // 데드락 위험!
19
    }
20
}

1
pool_size = thread_count × (connections_per_task - 1) + 1

1
@RestController
2
class StreamingController {
3
    @GetMapping("/api/stream/{id}")
4
    void getStream(@PathVariable Long id) {
5
        // 1. DB 조회 (커넥션 사용)
6
        Stream stream = streamRepository.findById(id);
7

8
        // 2. 비즈니스 로직 (커넥션 사용 안 함)
9
        processStream(stream);
10

11
        // 3. 캐시 확인 (커넥션 사용 안 함)
12
        cacheService.get(id);
13

14
        // 4. 외부 API 호출 (커넥션 사용 안 함)
15
        notificationService.send(stream);
16
    }
17
}

1
hikari:
2
  maximum-pool-size: 50  # CPU 코어 수 기준, 성능 테스트로 결정
3
  minimum-idle: 50       # maximum과 동일

1
// 설정
2
hikari:
3
  maximum-pool-size: 10
4
  connection-timeout: 3000  // 3초
5

6
// 상황
7
// 1초에 100개 요청 들어옴
8
// 각 요청은 DB 쿼리에 5초 소요
9

10
// 1초 후: 100개 요청이 10개 커넥션을 대기
11
// 90개 요청이 큐에서 대기
12
// 3초 후: connection-timeout 발생!
13

14
// 로그
15
org.springframework.dao.DataAccessResourceFailureException:
16
  Unable to acquire JDBC Connection
17
Caused by: java.sql.SQLTransientConnectionException:
18
  HikariPool-1 - Connection is not available,
19
  request timed out after 3000ms.

1
hikari:
2
  maximum-pool-size: 50  # 10 → 50

1
-- Before: 5초
2
SELECT * FROM streams WHERE status = 'LIVE';
3

4
-- After: 0.1초 (인덱스 추가)
5
CREATE INDEX idx_stream_status ON streams(status);
6
SELECT * FROM streams WHERE status = 'LIVE';

1
@Service
2
class StreamService {
3
    @Cacheable("liveStreams")
4
    List<Stream> getLiveStreams() {
5
        // DB 조회 횟수 감소
6
        return streamRepository.findByStatus(StreamStatus.LIVE);
7
    }
8
}

1
@Service
2
class BadService {
3
    @Autowired
4
    private DataSource dataSource;
5

6
    void leakyMethod() throws SQLException {
7
        Connection conn = dataSource.getConnection();
8
        Statement stmt = conn.createStatement();
9
        ResultSet rs = stmt.executeQuery("SELECT * FROM users");
10

11
        // 처리...
12

13
        // 문제: close()를 안 했다!
14
        // conn, stmt, rs가 모두 닫히지 않음
15
    }
16
}
17

18
// 이 메서드를 10번 호출하면?
19
// 커넥션 풀(10개)이 모두 고갈됨!

1
WARN - Connection leak detection triggered for connection

1
@Service
2
class GoodService {
3
    @Autowired
4
    private DataSource dataSource;
5

6
    void goodMethod() throws SQLException {
7
        try (Connection conn = dataSource.getConnection();
8
             Statement stmt = conn.createStatement();
9
             ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
10

11
            // 처리...
12

13
        } // 자동으로 close() 호출!
14
    }
15
}

1
@Service
2
class BetterService {
3
    @Autowired
4
    private UserRepository userRepository;
5

6
    void betterMethod() {
7
        // JPA가 알아서 커넥션 관리
8
        List<User> users = userRepository.findAll();
9
    }
10
}

1
hikari:
2
  leak-detection-threshold: 60000  # 60초

1
-- MySQL 기본 설정
2
SHOW VARIABLES LIKE 'wait_timeout';
3
-- wait_timeout = 28800 (8시간)
4

5
-- 하지만 실제 운영에서는 짧게 설정하는 경우가 많음
6
SET GLOBAL wait_timeout = 60;  -- 60초로 변경

1
// 1. 커넥션 획득
2
Connection conn = dataSource.getConnection();
3

4
// 2. 아무것도 안 하고 70초 대기
5
Thread.sleep(70000);
6

7
// 3. 쿼리 실행 시도
8
stmt.executeQuery("SELECT * FROM users");
9
// 에러!
10
// Communications link failure
11
// The last packet successfully received from the server
12
// was 70,000 milliseconds ago

1
hikari:
2
  max-lifetime: 50000  # 50초 (wait_timeout보다 짧게)

1
SET GLOBAL wait_timeout = 600;           -- 10분
2
SET GLOBAL interactive_timeout = 600;    -- 10분

1
hikari:
2
  keepalive-time: 30000  # 30초마다 연결 확인

1
// HikariCP 내부 동작
2
class HikariPool {
3
    void keepalive() {
4
        for (Connection conn : idleConnections) {
5
            if (idleTime > keepaliveTime) {
6
                // 간단한 쿼리로 연결 확인
7
                conn.isValid(validationTimeout);
8
                // 또는
9
                stmt.execute("SELECT 1");
10
            }
11
        }
12
    }
13
}

1
@Service
2
class DeadlockService {
3
    @Transactional
4
    void problemMethod() {
5
        // 첫 번째 커넥션 획득
6
        Connection conn1 = dataSource.getConnection();
7

8
        // ... 작업 중 ...
9

10
        // 두 번째 커넥션 시도
11
        // 하지만 풀에 남은 커넥션이 없음!
12
        Connection conn2 = dataSource.getConnection();
13
        // 영원히 대기... (데드락!)
14
    }
15
}

1
# pool_size = thread_count × (connections_per_task - 1) + 1
2
# 16 × (2 - 1) + 1 = 17
3

4
hikari:
5
  maximum-pool-size: 17

1
@Service
2
class FixedService {
3
    @Transactional
4
    void fixedMethod() {
5
        // 하나의 트랜잭션으로 통합
6
        // 1개의 커넥션만 사용
7
        orderRepository.save(order);
8
        itemRepository.updateStock(itemId);
9
    }
10
}

1
// 커넥션 하나당 메모리 사용량
2
class ConnectionMemory {
3
    // TCP 소켓: ~64KB
4
    // ResultSet 버퍼: ~1MB
5
    // Statement 객체들: ~100KB
6
    // 메타데이터: ~100KB
7

8
    // 총합: 약 1~2MB per connection
9
}
10

11
// 커넥션 1000개 = 1~2GB 메모리!
12
hikari:
13
  maximum-pool-size: 1000  // 위험!

1
hikari:
2
  maximum-pool-size: 50  # 적정 수준

1
-- MySQL 최대 커넥션 확인
2
SHOW VARIABLES LIKE 'max_connections';
3
-- max_connections = 151 (기본값)
4

5
-- 현재 커넥션 확인
6
SHOW STATUS LIKE 'Threads_connected';

1
# 서버 1대: 커넥션 50개
2
# 서버 3대: 커넥션 150개
3
# DB max_connections: 200
4

5
# 여유 있게 설정

1
// r2dbc-pool의 특성
2
// 생성 시점에 커넥션을 만들지 않고,
3
// 실제 필요할 때 만듦 (Lazy Initialization)
4

5
// IntelliJ에서는 동작함 (왜?)
6
// → Actuator의 HealthCheck가 JMX를 통해 자동 호출
7
// → 이 과정에서 커넥션 풀이 초기화됨
8

9
// jar 실행 시에는 동작 안 함
10
// → HealthCheck가 자동 호출되지 않음
11
// → 커넥션 풀이 초기화 안 됨
12
// → 첫 요청에서 지연 발생!

1
// 명시적으로 warmup 호출
2
r2dbcPool.warmup().block()

1
-- 잘못된 설정
2
SET GLOBAL wait_timeout = 60;  -- 너무 짧음!

1
// 60초마다 커넥션이 끊김
2
// HikariCP가 끊긴 커넥션을 감지하지 못함
3
// 애플리케이션에서 에러 발생!
4

5
// 에러 로그
6
Communications link failure
7
The last packet successfully received from the server
8
was 70,000 milliseconds ago

1
# HikariCP 설정
2
hikari:
3
  max-lifetime: 50000  # 50초 (wait_timeout보다 짧게)
4

5
# MySQL 설정
6
wait_timeout: 180      # 3분

1
# 잘못된 설정
2
hikari:
3
  leak-detection-threshold: 2000  # 2초 (너무 짧음!)

1
@Service
2
class SchedulerService {
3
    @Scheduled(fixedDelay = 1000)
4
    void scheduledTask() {
5
        // 정상적인 작업인데 3초 소요
6
        userRepository.findAll();  // 3초
7

8
        // HikariCP가 누수로 오판!
9
        // WARN - Apparent connection leak detected
10
    }
11
}

1
hikari:
2
  leak-detection-threshold: 60000  # 60초

1
// MySQL Connector/J의 문제
2
// AbandonedConnectionCleanupThread가 계속 생성됨
3
// 메모리 누수 발생!
4

5
// Thread Dump
6
"MySQL-AB-1" daemon
7
"MySQL-AB-2" daemon
8
"MySQL-AB-3" daemon
9
... (수백 개)

1
# JVM 옵션 추가
2
-Dcom.mysql.cj.disableAbandonedConnectionCleanup=true

1
# Actuator 설정
2
management:
3
  endpoints:
4
    web:
5
      exposure:
6
        include: metrics,health
7
  metrics:
8
    enable:
9
      hikaricp: true

1
// 확인 가능한 메트릭
2
hikaricp.connections.active      // 활성 커넥션 수
3
hikaricp.connections.idle        // 유휴 커넥션 수
4
hikaricp.connections.pending     // 대기 중인 요청 수
5
hikaricp.connections.timeout     // 타임아웃 발생 횟수
6
hikaricp.connections.usage       // 커넥션 사용 시간

1
# 라이브 스트리밍 서버 설정
2
spring:
3
  datasource:
4
    hikari:
5
      # 커넥션 풀
6
      maximum-pool-size: 50
7
      minimum-idle: 50
8

9
      # 타임아웃
10
      connection-timeout: 3000
11
      validation-timeout: 1000
12

13
      # 생명주기
14
      max-lifetime: 580000    # 9분 40초
15
      idle-timeout: 600000    # 10분
16
      keepalive-time: 30000   # 30초
17

18
      # 누수 감지
19
      leak-detection-threshold: 60000
20

21
# MySQL 설정
22
# wait_timeout = 600 (10분)
23
# interactive_timeout = 600 (10분)