1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 선점 가능한 패턴: tryLock으로 "자발적 선점" 구현
public void transferSafe(Account from, Account to, BigDecimal amount) {
    while (true) {
        if (from.getLock().tryLock(100, TimeUnit.MILLISECONDS)) {
            try {
                if (to.getLock().tryLock(100, TimeUnit.MILLISECONDS)) {
                    try {
                        from.withdraw(amount);
                        to.deposit(amount);
                        return;
                    } finally {
                        to.getLock().unlock();
                    }
                }
            } finally {
                from.getLock().unlock();  // 실패 시 자발적 해제 → 비선점 조건 제거
            }
        }
        Thread.sleep((long) (Math.random() * 50));  // 재시도 전 랜덤 대기
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 자원 순서 보장: 항상 ID가 작은 계좌의 락을 먼저 획득
@Transactional
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    Long firstId = Math.min(fromId, toId);
    Long secondId = Math.max(fromId, toId);

    Account first = accountRepository.findByIdForUpdate(firstId);
    Account second = accountRepository.findByIdForUpdate(secondId);

    if (fromId.equals(firstId)) {
        first.withdraw(amount);
        second.deposit(amount);
    } else {
        second.withdraw(amount);
        first.deposit(amount);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import java.util.concurrent.locks.ReentrantLock;

public class DiningPhilosophersDeadlock {
    // 5개의 포크를 ReentrantLock으로 표현
    private static final int NUM_PHILOSOPHERS = 5;
    private static final ReentrantLock[] forks = new ReentrantLock[NUM_PHILOSOPHERS];

    static {
        for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
            forks[i] = new ReentrantLock();
        }
    }

    static class Philosopher extends Thread {
        private final int id;
        private final ReentrantLock leftFork;   // 왼쪽 포크
        private final ReentrantLock rightFork;  // 오른쪽 포크

        Philosopher(int id) {
            this.id = id;
            this.leftFork = forks[id];                          // 자신의 번호 = 왼쪽 포크
            this.rightFork = forks[(id + 1) % NUM_PHILOSOPHERS]; // 다음 번호 = 오른쪽 포크
        }

        private void think() throws InterruptedException {
            System.out.println("철학자 " + id + " 생각 중...");
            Thread.sleep((long) (Math.random() * 100));
        }

        private void eat() throws InterruptedException {
            System.out.println("철학자 " + id + " 식사 중!");
            Thread.sleep((long) (Math.random() * 100));
        }

        @Override
        public void run() {
            try {
                while (true) {
                    think();

                    // 왼쪽 포크를 먼저 집는다
                    leftFork.lock();
                    System.out.println("철학자 " + id + " 왼쪽 포크 획득");

                    // 오른쪽 포크를 집는다 — 여기서 데드락 가능!
                    rightFork.lock();
                    System.out.println("철학자 " + id + " 오른쪽 포크 획득");

                    eat();

                    // 포크를 내려놓는다
                    rightFork.unlock();
                    leftFork.unlock();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public static void main(String[] args) {
        // 5명의 철학자를 생성하고 시작
        for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
            new Philosopher(i).start();
        }
        // 실행하면 얼마 지나지 않아 모든 철학자가 멈춘다 (데드락)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
public class DiningPhilosophersOrdered {
    private static final int NUM_PHILOSOPHERS = 5;
    private static final ReentrantLock[] forks = new ReentrantLock[NUM_PHILOSOPHERS];

    static {
        for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
            forks[i] = new ReentrantLock();
        }
    }

    static class Philosopher extends Thread {
        private final int id;
        private final ReentrantLock firstFork;   // 번호가 작은 포크
        private final ReentrantLock secondFork;  // 번호가 큰 포크

        Philosopher(int id) {
            this.id = id;
            int left = id;
            int right = (id + 1) % NUM_PHILOSOPHERS;

            // 핵심: 항상 번호가 작은 포크를 먼저 집는다
            if (left < right) {
                firstFork = forks[left];
                secondFork = forks[right];
            } else {
                firstFork = forks[right];  // P4의 경우: F0이 먼저
                secondFork = forks[left];  // P4의 경우: F4가 나중
            }
        }

        @Override
        public void run() {
            try {
                while (true) {
                    think();

                    // 번호가 작은 포크를 먼저 획득
                    firstFork.lock();
                    try {
                        // 번호가 큰 포크를 획득
                        secondFork.lock();
                        try {
                            eat();  // 두 포크 모두 획득 → 식사
                        } finally {
                            secondFork.unlock();
                        }
                    } finally {
                        firstFork.unlock();
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        private void think() throws InterruptedException {
            System.out.println("철학자 " + id + " 생각 중...");
            Thread.sleep((long) (Math.random() * 100));
        }

        private void eat() throws InterruptedException {
            System.out.println("철학자 " + id + " 식사 중!");
            Thread.sleep((long) (Math.random() * 100));
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
            new Philosopher(i).start();
        }
        // 데드락 없이 모든 철학자가 돌아가며 식사한다
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;

public class DiningPhilosophersSemaphore {
    private static final int NUM_PHILOSOPHERS = 5;
    private static final ReentrantLock[] forks = new ReentrantLock[NUM_PHILOSOPHERS];

    // 핵심: 동시에 식사를 시도할 수 있는 철학자 수를 4명으로 제한
    private static final Semaphore diningPermit = new Semaphore(NUM_PHILOSOPHERS - 1);

    static {
        for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
            forks[i] = new ReentrantLock();
        }
    }

    static class Philosopher extends Thread {
        private final int id;

        Philosopher(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            try {
                int left = id;
                int right = (id + 1) % NUM_PHILOSOPHERS;

                while (true) {
                    think();

                    // 세마포어로 동시 식사 인원 제한
                    diningPermit.acquire();
                    try {
                        // 이제 왼쪽-오른쪽 순서대로 집어도 안전하다
                        forks[left].lock();
                        try {
                            forks[right].lock();
                            try {
                                eat();
                            } finally {
                                forks[right].unlock();
                            }
                        } finally {
                            forks[left].unlock();
                        }
                    } finally {
                        diningPermit.release();  // 식사 완료 → 허가 반환
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        private void think() throws InterruptedException {
            System.out.println("철학자 " + id + " 생각 중...");
            Thread.sleep((long) (Math.random() * 100));
        }

        private void eat() throws InterruptedException {
            System.out.println("철학자 " + id + " 식사 중!");
            Thread.sleep((long) (Math.random() * 100));
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
            new Philosopher(i).start();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
// Spring에서 InnoDB 데드락 복구 패턴
@Retryable(
    retryFor = DeadlockLoserDataAccessException.class,
    maxAttempts = 3,
    backoff = @Backoff(delay = 50, multiplier = 2)
)
@Transactional
public void processOrder(Long orderId) {
    // 데드락으로 롤백되면 자동 재시도
    Order order = orderRepository.findByIdForUpdate(orderId);
    order.process();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class WaitDieScheduler {
    private final Map<Long, Long> resourceHolders = new ConcurrentHashMap<>();  // 자원ID → 트랜잭션 타임스탬프
    private final AtomicLong timestampGenerator = new AtomicLong(0);

    /**
     * 트랜잭션 시작 시 고유 타임스탬프 부여
     * 숫자가 작을수록 오래된 트랜잭션
     */
    public long beginTransaction() {
        return timestampGenerator.incrementAndGet();
    }

    /**
     * Wait-Die 방식으로 자원 요청
     * @param txTimestamp 요청 트랜잭션의 타임스탬프
     * @param resourceId 요청할 자원의 ID
     * @return true면 대기(wait), false면 롤백 필요(die)
     */
    public boolean requestResource(long txTimestamp, long resourceId) {
        Long holderTimestamp = resourceHolders.get(resourceId);

        if (holderTimestamp == null) {
            // 자원이 비어 있으면 즉시 획득
            resourceHolders.put(resourceId, txTimestamp);
            return true;
        }

        if (txTimestamp < holderTimestamp) {
            // 요청자가 보유자보다 오래됨 → 기다린다 (Wait)
            // 실제 구현에서는 대기 큐에 넣고 블로킹
            System.out.println("TX(" + txTimestamp + ") WAIT: 보유자 TX("
                + holderTimestamp + ")보다 오래되었으므로 대기");
            return true;  // 대기 허용
        } else {
            // 요청자가 보유자보다 젊음 → 롤백! (Die)
            System.out.println("TX(" + txTimestamp + ") DIE: 보유자 TX("
                + holderTimestamp + ")보다 젊으므로 롤백 후 재시작");
            return false;  // 롤백 필요
        }
    }

    /**
     * 자원 해제
     */
    public void releaseResource(long resourceId) {
        resourceHolders.remove(resourceId);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// 라이브락 예제
public class LivelockExample {
    static final Lock lock1 = new ReentrantLock();
    static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                lock1.lock();
                if (!lock2.tryLock()) {
                    lock1.unlock();       // 양보
                    continue;             // 다시 시도 → 라이브락!
                }
                try {
                    System.out.println("T1 작업 완료");
                    return;
                } finally {
                    lock2.unlock();
                    lock1.unlock();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            while (true) {
                lock2.lock();
                if (!lock1.tryLock()) {
                    lock2.unlock();       // 양보
                    continue;             // 다시 시도 → 라이브락!
                }
                try {
                    System.out.println("T2 작업 완료");
                    return;
                } finally {
                    lock1.unlock();
                    lock2.unlock();
                }
            }
        });

        t1.start();
        t2.start();
    }
}

1
2
3
4
5
6
// 라이브락 해결: 랜덤 백오프
if (!lock2.tryLock()) {
    lock1.unlock();
    Thread.sleep((long) (Math.random() * 100));  // 랜덤 대기
    continue;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.lang.management.*;

public class DeadlockMonitor {
    private static final ThreadMXBean threadBean =
        ManagementFactory.getThreadMXBean();

    public static void startMonitoring() {
        ScheduledExecutorService scheduler =
            Executors.newSingleThreadScheduledExecutor();

        scheduler.scheduleAtFixedRate(() -> {
            long[] deadlockedThreads = threadBean.findDeadlockedThreads();

            if (deadlockedThreads != null) {
                ThreadInfo[] infos = threadBean.getThreadInfo(
                    deadlockedThreads, true, true);

                StringBuilder sb = new StringBuilder("DEADLOCK DETECTED!\n");
                for (ThreadInfo info : infos) {
                    sb.append(String.format(
                        "Thread: %s (state: %s)\n  Lock: %s\n  Owner: %s\n",
                        info.getThreadName(),
                        info.getThreadState(),
                        info.getLockName(),
                        info.getLockOwnerName()
                    ));
                }
                log.error(sb.toString());
            }
        }, 0, 10, TimeUnit.SECONDS);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class SafeTransfer {
    private static final long TIMEOUT = 1000;

    public boolean transfer(Account from, Account to, BigDecimal amount)
            throws InterruptedException {

        long deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(TIMEOUT);

        while (true) {
            if (from.getLock().tryLock()) {
                try {
                    if (to.getLock().tryLock()) {
                        try {
                            from.withdraw(amount);
                            to.deposit(amount);
                            return true;
                        } finally {
                            to.getLock().unlock();
                        }
                    }
                } finally {
                    from.getLock().unlock();
                }
            }

            if (System.nanoTime() >= deadline) {
                return false;  // 타임아웃
            }

            // 라이브락 방지: 랜덤 백오프
            Thread.sleep(ThreadLocalRandom.current().nextLong(10, 50));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// AtomicInteger: CAS(Compare-And-Swap) 기반, 락 없음
private final AtomicInteger counter = new AtomicInteger(0);

public void increment() {
    counter.incrementAndGet();  // 데드락 불가능
}

// ConcurrentHashMap: 세그먼트 단위 락, 세밀한 동시성 제어
private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

public void update(String key) {
    map.merge(key, 1, Integer::sum);  // 원자적 연산
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// MySQL Gap Lock에 의한 데드락 예시
// T1: DELETE FROM order WHERE status = 'EXPIRED' AND user_id = 1;
// T2: DELETE FROM order WHERE status = 'EXPIRED' AND user_id = 2;
// 두 트랜잭션이 같은 Gap에 대해 Gap Lock을 잡으면 데드락 가능

// 해결 방법 1: 락 순서 통일
@Transactional
public void cleanupExpiredOrders(Long userId) {
    // Primary Key 순서로 처리
    List<Order> orders = orderRepository
        .findByUserIdAndStatusOrderById(userId, "EXPIRED");
    orderRepository.deleteAll(orders);
}

// 해결 방법 2: 격리 수준 변경
@Transactional(isolation = Isolation.READ_COMMITTED)
public void cleanupExpiredOrders(Long userId) {
    // READ COMMITTED에서는 Gap Lock이 걸리지 않음
    orderRepository.deleteByUserIdAndStatus(userId, "EXPIRED");
}