feat: ch10 (#5)

Author: jundonghyuk

build.gradle.kts

@@ -19,6 +19,12 @@ repositories {
 
 dependencies {
     implementation("org.springframework.boot:spring-boot-starter")
+    implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+    runtimeOnly("com.h2database:h2:2.2.224")
+
+    implementation("org.springframework.boot:spring-boot-starter-actuator")
+
     testImplementation("org.springframework.boot:spring-boot-starter-test")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }

img/ch10_connection_pool_deadlock.svg

@@ -0,0 +1,12 @@
+package example.concurrency;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Application {
+
+  public static void main(String[] args) {
+    SpringApplication.run(Application.class, args);
+  }
+}

img/ch10_process_resource_diagram.svg

@@ -0,0 +1,14 @@
+package example.concurrency.ch10;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class InnerService {
+
+  @Transactional(propagation = Propagation.REQUIRES_NEW)
+  public void innerMethod() {
+    System.out.printf("InnerService.innerMethod is called by %s%n", Thread.currentThread().getName());
+  }
+}

src/main/java/example/concurrency/Application.java

@@ -0,0 +1,28 @@
+package example.concurrency.ch10;
+
+import java.sql.Connection;
+import javax.sql.DataSource;
+import org.springframework.jdbc.datasource.DataSourceUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class OuterService {
+
+  private final InnerService innerService;
+
+  public OuterService(InnerService innerService) {
+    this.innerService = innerService;
+  }
+
+  @Transactional
+  public void outerMethod() {
+    System.out.printf("OuterService.outerMethod is called by %s%n", Thread.currentThread().getName());
+    try {
+      Thread.sleep(1000);
+      innerService.innerMethod();
+    } catch (Exception e) {
+      throw new RuntimeException(e.getMessage());
+    }
+  }
+}

src/main/java/example/concurrency/ch10/InnerService.java

@@ -0,0 +1,18 @@
+spring:
+  datasource:
+    url: jdbc:h2:mem:testdb
+    driver-class-name: org.h2.Driver
+    hikari:
+      maximum-pool-size: 2
+#      connection-timeout: 2000
+#      idle-timeout: 300000
+#      max-lifetime: 1200000
+
+server:
+  port: 8888
+
+management:
+  endpoints:
+    web:
+      exposure:
+        include: "*"

src/main/java/example/concurrency/ch10/OuterService.java

@@ -1,4 +1,4 @@
-package com.example.concurrency;
+package example.concurrency;
 
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;

src/main/resources/application.yml

@@ -0,0 +1,71 @@
+package example.concurrency.ch10;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
+public class DeadLockTest {
+
+  @Autowired
+  private OuterService outerService;
+
+  @Test
+  public void testDeadLoc() throws InterruptedException {
+    ExecutorService executorService = Executors.newFixedThreadPool(2);
+    CountDownLatch startLatch = new CountDownLatch(1);
+    CountDownLatch doneLatch = new CountDownLatch(2);
+
+    System.out.println("=== 데드락 테스트 시작 ===");
+
+    // Thread 1
+    executorService.submit(() -> {
+      try {
+        startLatch.await(); // 동시 시작을 위한 대기
+        System.out.println("Thread-1 시작");
+        outerService.outerMethod();
+        System.out.println("Thread-1 완료");
+      } catch (Exception e) {
+        System.err.println("Thread-1 에러: " + e.getMessage());
+        e.printStackTrace();
+      } finally {
+        doneLatch.countDown();
+      }
+    });
+
+    // Thread 2
+    executorService.submit(() -> {
+      try {
+        startLatch.await(); // 동시 시작을 위한 대기
+        System.out.println("Thread-2 시작");
+        outerService.outerMethod();
+        System.out.println("Thread-2 완료");
+      } catch (Exception e) {
+        System.err.println("Thread-2 에러: " + e.getMessage());
+        e.printStackTrace();
+      } finally {
+        doneLatch.countDown();
+      }
+    });
+
+    // 잠시 대기 후 동시 실행
+    Thread.sleep(100);
+    System.out.println("두 스레드 동시 시작!");
+    startLatch.countDown();
+
+    // 최대 30초 대기 (데드락이면 타임아웃)
+    boolean completed = doneLatch.await(30, TimeUnit.SECONDS);
+
+    if (!completed) {
+      System.err.println("⚠️ 타임아웃 발생 - 데드락 가능성!");
+    } else {
+      System.out.println("✅ 모든 스레드 정상 완료");
+    }
+
+    executorService.shutdownNow();
+  }
+}