락 메커니즘의 모든 것 - 하드웨어부터 분산 시스템까지

1
// 소프트웨어로 락 구현 시도 (잘못된 방법)
2
class BrokenLock {
3
    private boolean locked = false;
4

5
    public void lock() {
6
        // 문제: 이 코드는 원자적이지 않다!
7
        while (locked) {
8
            // 대기
9
        }
10
        locked = true;  // 여러 스레드가 동시에 실행 가능!
11
    }
12

13
    public void unlock() {
14
        locked = false;
15
    }
16
}

1
// 하드웨어가 제공하는 원자 명령어
2
bool test_and_set(bool *target) {
3
    bool old_value = *target;
4
    *target = true;
5
    return old_value;
6
    // 이 세 줄이 원자적으로 실행됨 (중간에 끼어들 수 없음)
7
}

1
// C++/의사 코드
2
class TASLock {
3
    bool locked = false;
4

5
    void lock() {
6
        // old_value가 false일 때까지 반복 (락 획득 성공)
7
        while (test_and_set(&locked)) {
8
            // 바쁜 대기 (busy waiting)
9
        }
10
    }
11

12
    void unlock() {
13
        locked = false;
14
    }
15
}

1
// 하드웨어 CAS 명령어
2
bool compare_and_swap(int *ptr, int expected, int new_value) {
3
    int actual = *ptr;
4
    if (actual == expected) {
5
        *ptr = new_value;
6
        return true;
7
    }
8
    return false;
9
    // 이 모든 과정이 원자적으로 실행됨
10
}

1
import java.util.concurrent.atomic.AtomicInteger;
2

3
class CASExample {
4
    private AtomicInteger value = new AtomicInteger(0);
5

6
    public void increment() {
7
        int oldValue, newValue;
8
        do {
9
            oldValue = value.get();
10
            newValue = oldValue + 1;
11
        } while (!value.compareAndSet(oldValue, newValue));
12
        // CAS 실패 시 재시도 (낙관적 접근)
13
    }
14
}

1
class Singleton {
2
    private static Singleton instance;
3

4
    // 잘못된 구현 (Double-Checked Locking 문제)
5
    public static Singleton getInstance() {
6
        if (instance == null) {  // 1. 첫 번째 체크
7
            synchronized (Singleton.class) {
8
                if (instance == null) {  // 2. 두 번째 체크
9
                    instance = new Singleton();  // 문제 발생 지점!
10
                    // 이 연산은 (1) 메모리 할당, (2) 생성자 호출, (3) 참조 할당 세 단계로 분리되며,
11
                    // 컴파일러가 (3)을 (2)보다 먼저 실행(명령어 재배치)할 수 있다.
12
                    // 이 경우 다른 스레드가 초기화되지 않은 객체를 읽게 된다.
13
                }
14
            }
15
        }
16
        return instance;
17
    }
18
}

1
class Singleton {
2
    // volatile: happens-before 관계를 수립하여 가시성과 순서를 보장. CPU 캐시는 여전히 사용되며, 캐시 일관성 프로토콜(MESI 등)을 통해 동기화된다
3
    private static volatile Singleton instance;
4

5
    public static Singleton getInstance() {
6
        if (instance == null) {
7
            synchronized (Singleton.class) {
8
                if (instance == null) {
9
                    instance = new Singleton();
10
                    // volatile이 메모리 장벽 역할
11
                    // → 생성자 호출이 완전히 끝난 후에만 instance에 할당
12
                }
13
            }
14
        }
15
        return instance;
16
    }
17
}

1
class Spinlock {
2
    private AtomicBoolean locked = new AtomicBoolean(false);
3

4
    public void lock() {
5
        // 락을 획득할 때까지 계속 시도 (바쁜 대기)
6
        while (!locked.compareAndSet(false, true)) {
7
            // CPU를 계속 사용하면서 대기!
8
        }
9
    }
10

11
    public void unlock() {
12
        locked.set(false);
13
    }
14
}

1
// 좋은 예: 매우 짧은 임계영역
2
class Counter {
3
    private Spinlock lock = new Spinlock();
4
    private int count = 0;
5

6
    public void increment() {
7
        lock.lock();
8
        count++;  // 매우 짧은 연산 (나노초 단위, 단 원자적이지는 않음 — load, increment, store 3개 명령어)
9
        lock.unlock();
10
    }
11
}
12

13
// 나쁜 예: 긴 임계영역
14
class FileProcessor {
15
    private Spinlock lock = new Spinlock();
16

17
    public void processFile() {
18
        lock.lock();
19
        readFromDisk();   // 수 밀리초 소요
20
        parseData();      // 수십 밀리초 소요
21
        writeToDatabase(); // 수백 밀리초 소요
22
        lock.unlock();    // 다른 스레드는 계속 CPU 낭비!
23
    }
24
}

1
// Linux 커널에서 실제 사용되는 스핀락
2
spinlock_t my_lock = SPIN_LOCK_UNLOCKED;
3

4
spin_lock(&my_lock);
5
// 매우 짧은 임계영역 (보통 수십 나노초)
6
critical_section();
7
spin_unlock(&my_lock);

1
-- Shared Lock 획득
2
SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;

1
트랜잭션 A: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
2
  → Shared Lock 획득
3

4
트랜잭션 B: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
5
  → Shared Lock 획득 (가능!)
6

7
트랜잭션 C: UPDATE users SET name = 'Kim' WHERE id = 1;
8
  → Exclusive Lock 시도 → 대기 (Shared Lock이 있음)

1
-- Exclusive Lock 획득
2
SELECT * FROM users WHERE id = 1 FOR UPDATE;

1
트랜잭션 A: SELECT * FROM users WHERE id = 1 FOR UPDATE;
2
  → Exclusive Lock 획득
3

4
트랜잭션 B: SELECT * FROM users WHERE id = 1 FOR UPDATE;
5
  → 대기 (Exclusive Lock이 있음)
6

7
트랜잭션 C: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
8
  → 대기 (Exclusive Lock이 있음)

1
        S-Lock  X-Lock
2
S-Lock    O       X
3
X-Lock    X       X
4

5
O: 호환 (동시 획득 가능)
6
X: 비호환 (대기 필요)

1
@Service
2
@Transactional
3
public class OrderService {
4

5
    // 잘못된 방법: 경쟁 상태 발생
6
    public void createOrderWrong(Long productId, int quantity) {
7
        Product product = productRepository.findById(productId);
8

9
        if (product.getStock() >= quantity) {
10
            product.decreaseStock(quantity);  // 여러 트랜잭션이 동시 실행 가능!
11
            productRepository.save(product);
12
        }
13
    }
14

15
    // 올바른 방법: Exclusive Lock 사용
16
    @Query("SELECT p FROM Product p WHERE p.id = :id FOR UPDATE")
17
    Product findByIdForUpdate(@Param("id") Long id);
18

19
    public void createOrderCorrect(Long productId, int quantity) {
20
        // Exclusive Lock으로 다른 트랜잭션 차단
21
        Product product = productRepository.findByIdForUpdate(productId);
22

23
        if (product.getStock() >= quantity) {
24
            product.decreaseStock(quantity);
25
            productRepository.save(product);
26
        }
27
    }
28
}

1
// 예시: 도큐먼트 업데이트
2
db.users.updateOne(
3
    { _id: ObjectId("...") },
4
    { $set: { name: "Kim" } }
5
)
6

7
// 락 획득 순서 (쓰기 작업이므로 글로벌/데이터베이스/컬렉션에 IX, 도큐먼트에 X를 획득):
8
// 1. 글로벌: IX (Intent Exclusive)
9
// 2. 데이터베이스: IX (Intent Exclusive)
10
// 3. 컬렉션: IX (Intent Exclusive)
11
// 4. 도큐먼트: X (Exclusive)

1
글로벌 X-Lock을 걸려면:
2
→ 모든 데이터베이스 확인
3
  → 모든 컬렉션 확인
4
    → 모든 도큐먼트 확인 (수백만 개!)
5

6
→ 너무 느림!

1
글로벌 X-Lock을 걸려면:
2
→ 글로벌의 Intent Lock만 확인
3
→ IS나 IX가 있으면 대기
4
→ 없으면 즉시 획득
5

6
→ 빠름!

1
// 트랜잭션 A
2
db.users.updateOne({ _id: 1 }, { $set: { name: "Kim" } })
3
// → 전체 users 컬렉션에 X-Lock!
4

5
// 트랜잭션 B
6
db.users.updateOne({ _id: 2 }, { $set: { name: "Lee" } })
7
// → 대기 (같은 컬렉션)

1
// 트랜잭션 A
2
db.users.updateOne({ _id: 1 }, { $set: { name: "Kim" } })
3
// → 도큐먼트 1에만 X-Lock
4

5
// 트랜잭션 B
6
db.users.updateOne({ _id: 2 }, { $set: { name: "Lee" } })
7
// → 도큐먼트 2에 X-Lock (동시 실행 가능!)

1
10,000개 도큐먼트 동시 업데이트:
2

3
Collection-level Lock: 순차 실행 → 10초
4
Document-level Lock: 병렬 실행 → 0.5초

1
// JPA Pessimistic Lock
2
@Lock(LockModeType.PESSIMISTIC_WRITE)
3
@Query("SELECT p FROM Product p WHERE p.id = :id")
4
Product findByIdWithPessimisticLock(@Param("id") Long id);
5

6
@Transactional
7
public void updateStock(Long productId, int quantity) {
8
    Product product = productRepository.findByIdWithPessimisticLock(productId);
9
    // 여기서 Exclusive Lock이 걸림
10
    // 다른 트랜잭션은 대기
11

12
    product.decreaseStock(quantity);
13
    productRepository.save(product);
14
    // 커밋 시 락 해제
15
}

1
SELECT * FROM product WHERE id = 1 FOR UPDATE;
2
-- 다른 트랜잭션의 locking read(SELECT FOR UPDATE, SELECT LOCK IN SHARE MODE)와 쓰기(UPDATE, DELETE)는 차단되지만, 일반 SELECT(non-locking read)는 MVCC를 통해 여전히 가능

1
@Entity
2
public class Product {
3
    @Id
4
    private Long id;
5

6
    private String name;
7
    private int stock;
8

9
    @Version  // 낙관적 락용 버전 컬럼
10
    private Long version;
11
}
12

13
@Transactional
14
public void updateStock(Long productId, int quantity) {
15
    Product product = productRepository.findById(productId);
16
    // 락 없이 읽기
17
    // version = 1
18

19
    product.decreaseStock(quantity);
20
    productRepository.save(product);
21
    // UPDATE product SET stock = ?, version = version + 1
22
    //  WHERE id = ? AND version = 1
23
}

1
// 주의: 재시도 로직은 트랜잭션 밖에서 수행해야 한다.
2
// @Transactional 내에서 재시도하면 이미 롤백 마크된 트랜잭션에서 재시도하는 것이므로 의미 없다.
3
@Transactional
4
public void updateStockWithRetry(Long productId, int quantity) {
5
    int maxRetries = 3;
6
    int attempt = 0;
7

8
    while (attempt < maxRetries) {
9
        try {
10
            Product product = productRepository.findById(productId);
11
            product.decreaseStock(quantity);
12
            productRepository.save(product);
13
            return;  // 성공
14
        } catch (OptimisticLockException e) {
15
            attempt++;
16
            if (attempt >= maxRetries) {
17
                throw new RuntimeException("재고 업데이트 실패: 동시성 충돌");
18
            }
19
            // 잠시 대기 후 재시도
20
            Thread.sleep(100);
21
        }
22
    }
23
}

1
// 서버 A
2
@Transactional
3
public void processCoupon(String couponCode) {
4
    Coupon coupon = couponRepository.findByCode(couponCode);
5
    if (coupon.getUsageCount() < coupon.getMaxUsage()) {
6
        coupon.incrementUsage();  // 사용 횟수 증가
7
        couponRepository.save(coupon);
8
    }
9
}
10

11
// 서버 B (동시 실행)
12
@Transactional
13
public void processCoupon(String couponCode) {
14
    Coupon coupon = couponRepository.findByCode(couponCode);
15
    if (coupon.getUsageCount() < coupon.getMaxUsage()) {
16
        coupon.incrementUsage();  // 중복 사용!
17
        couponRepository.save(coupon);
18
    }
19
}

1
@Component
2
public class RedisLockService {
3

4
    @Autowired
5
    private RedisTemplate<String, String> redisTemplate;
6

7
    public boolean tryLock(String key, String value, long timeoutSeconds) {
8
        // SET key value NX EX timeout
9
        // NX: key가 없을 때만 설정 (원자적)
10
        // EX: 만료 시간 설정 (초 단위)
11
        return redisTemplate.opsForValue()
12
            .setIfAbsent(key, value, timeoutSeconds, TimeUnit.SECONDS);
13
    }
14

15
    public void unlock(String key, String value) {
16
        // Lua 스크립트로 원자적 삭제
17
        String script =
18
            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
19
            "    return redis.call('del', KEYS[1]) " +
20
            "else " +
21
            "    return 0 " +
22
            "end";
23

24
        redisTemplate.execute(
25
            new DefaultRedisScript<>(script, Long.class),
26
            Collections.singletonList(key),
27
            value
28
        );
29
    }
30
}

1
@Service
2
public class CouponService {
3

4
    @Autowired
5
    private RedisLockService lockService;
6

7
    public void processCoupon(String couponCode) {
8
        String lockKey = "coupon:lock:" + couponCode;
9
        String lockValue = UUID.randomUUID().toString();
10

11
        try {
12
            // 락 획득 시도 (30초 타임아웃)
13
            if (lockService.tryLock(lockKey, lockValue, 30)) {
14
                try {
15
                    // 임계영역
16
                    Coupon coupon = couponRepository.findByCode(couponCode);
17
                    if (coupon.getUsageCount() < coupon.getMaxUsage()) {
18
                        coupon.incrementUsage();
19
                        couponRepository.save(coupon);
20
                    }
21
                } finally {
22
                    // 반드시 락 해제
23
                    lockService.unlock(lockKey, lockValue);
24
                }
25
            } else {
26
                throw new RuntimeException("락 획득 실패: 다른 서버가 처리 중");
27
            }
28
        } catch (Exception e) {
29
            log.error("쿠폰 처리 실패", e);
30
            throw e;
31
        }
32
    }
33
}

1
@Configuration
2
public class RedissonConfig {
3

4
    @Bean
5
    public RedissonClient redissonClient() {
6
        Config config = new Config();
7
        config.useSingleServer()
8
            .setAddress("redis://localhost:6379");
9
        return Redisson.create(config);
10
    }
11
}
12

13
@Service
14
public class CouponService {
15

16
    @Autowired
17
    private RedissonClient redissonClient;
18

19
    public void processCoupon(String couponCode) {
20
        RLock lock = redissonClient.getLock("coupon:lock:" + couponCode);
21

22
        try {
23
            // 락 획득 시도 (대기 10초, 해제 30초)
24
            // 주의: leaseTime을 직접 지정하면 Watchdog 자동 갱신이 작동하지 않는다.
25
            // Watchdog을 사용하려면 leaseTime을 -1(기본값)로 두어야 한다.
26
            if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
27
                try {
28
                    // 임계영역
29
                    Coupon coupon = couponRepository.findByCode(couponCode);
30
                    if (coupon.getUsageCount() < coupon.getMaxUsage()) {
31
                        coupon.incrementUsage();
32
                        couponRepository.save(coupon);
33
                    }
34
                } finally {
35
                    lock.unlock();
36
                }
37
            } else {
38
                throw new RuntimeException("락 획득 타임아웃");
39
            }
40
        } catch (InterruptedException e) {
41
            Thread.currentThread().interrupt();
42
            throw new RuntimeException("락 획득 중단", e);
43
        }
44
    }
45
}

1
Redis 인스턴스 다운 → 모든 락 사라짐!

1
// Redisson Redlock 사용
2
@Service
3
public class CouponService {
4

5
    @Autowired
6
    private RedissonClient redisson1;
7
    @Autowired
8
    private RedissonClient redisson2;
9
    @Autowired
10
    private RedissonClient redisson3;
11

12
    public void processCoupon(String couponCode) {
13
        RLock lock1 = redisson1.getLock("coupon:lock:" + couponCode);
14
        RLock lock2 = redisson2.getLock("coupon:lock:" + couponCode);
15
        RLock lock3 = redisson3.getLock("coupon:lock:" + couponCode);
16

17
        // RedLock: 3개 중 2개 이상 획득해야 성공
18
        RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);
19

20
        try {
21
            if (redLock.tryLock(10, 30, TimeUnit.SECONDS)) {
22
                try {
23
                    // 임계영역
24
                    processCouponInternal(couponCode);
25
                } finally {
26
                    redLock.unlock();
27
                }
28
            }
29
        } catch (InterruptedException e) {
30
            Thread.currentThread().interrupt();
31
        }
32
    }
33
}

1
// 데드락 발생 예제
2
class BankAccount {
3
    private Lock lock = new ReentrantLock();
4
    private int balance;
5

6
    public void transfer(BankAccount target, int amount) {
7
        this.lock.lock();
8
        try {
9
            target.lock.lock();  // 데드락 가능!
10
            try {
11
                this.balance -= amount;
12
                target.balance += amount;
13
            } finally {
14
                target.lock.unlock();
15
            }
16
        } finally {
17
            this.lock.unlock();
18
        }
19
    }
20
}
21

22
// 사용
23
BankAccount accountA = new BankAccount(1000);
24
BankAccount accountB = new BankAccount(1000);
25

26
// 스레드 1
27
accountA.transfer(accountB, 100);  // A락 → B락 대기
28

29
// 스레드 2 (동시 실행)
30
accountB.transfer(accountA, 200);  // B락 → A락 대기
31

32
// 데드락!

1
class BankAccount {
2
    private final long id;
3
    private Lock lock = new ReentrantLock();
4
    private int balance;
5

6
    public void transfer(BankAccount target, int amount) {
7
        // 항상 작은 ID부터 락 획득
8
        BankAccount first = this.id < target.id ? this : target;
9
        BankAccount second = this.id < target.id ? target : this;
10

11
        first.lock.lock();
12
        try {
13
            second.lock.lock();
14
            try {
15
                this.balance -= amount;
16
                target.balance += amount;
17
            } finally {
18
                second.lock.unlock();
19
            }
20
        } finally {
21
            first.lock.unlock();
22
        }
23
    }
24
}

1
public boolean transfer(BankAccount target, int amount) {
2
    if (this.lock.tryLock()) {
3
        try {
4
            if (target.lock.tryLock()) {
5
                try {
6
                    this.balance -= amount;
7
                    target.balance += amount;
8
                    return true;
9
                } finally {
10
                    target.lock.unlock();
11
                }
12
            }
13
        } finally {
14
            this.lock.unlock();
15
        }
16
    }
17
    return false;  // 실패 시 재시도
18
}

1
// 잘못된 코드: 락 해제 누락
2
public void badMethod() {
3
    lock.lock();
4

5
    if (someCondition) {
6
        return;  // 락 해제 안 됨!
7
    }
8

9
    doSomething();
10
    lock.unlock();
11
}
12

13
// 올바른 코드: finally 사용
14
public void goodMethod() {
15
    lock.lock();
16
    try {
17
        if (someCondition) {
18
            return;  // finally에서 해제됨
19
        }
20
        doSomething();
21
    } finally {
22
        lock.unlock();  // 항상 실행됨
23
    }
24
}

1
// 잘못된 구현
2
public void processWithLock(String key) {
3
    while (!tryLock(key)) {
4
        // 무한 대기 가능!
5
    }
6
    try {
7
        doSomething();
8
    } finally {
9
        unlock(key);
10
    }
11
}

1
작업 시간: 300ms
2
동시 요청: 100개
3
락 요청 시도: 594회
4
초당 Redis 요청: 2000회
5

6
→ Redis 과부하!

1
// 잘못된 코드
2
boolean locked = tryLock(key);
3
try {
4
    if (locked) {
5
        doSomething();
6
    }
7
} finally {
8
    unlock(key);  // locked == false일 때도 실행!
9
}

1
RLock lock = redissonClient.getLock("myLock");
2

3
// waitTime: 락 획득을 대기할 최대 시간
4
// leaseTime: 락이 자동으로 만료되는 시간
5
if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
6
    try {
7
        doSomething();
8
    } finally {
9
        lock.unlock();
10
    }
11
} else {
12
    throw new RuntimeException("락 획득 실패");
13
}

1
기존: 초당 2000회 Redis 요청
2
Pub/Sub: 초당 2회 Redis 요청 (1000배 감소!)

1
-- Redisson의 락 획득 Lua 스크립트
2
if (redis.call('exists', KEYS[1]) == 0) then
3
    redis.call('hset', KEYS[1], ARGV[2], 1);
4
    redis.call('pexpire', KEYS[1], ARGV[1]);
5
    return nil;
6
end;
7
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
8
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
9
    redis.call('pexpire', KEYS[1], ARGV[1]);
10
    return nil;
11
end;
12
return redis.call('pttl', KEYS[1]);

1
// 카프카로 동시에 들어오는 중복된 발주를 수신
2
// → 동일한 발주가 여러 번 등록됨

1
// 검수/검품 이슈 등록 시:
2
// - 더블 클릭
3
// - 네트워크 지연으로 인한 재시도
4
// → 중복 이슈 생성

1
// 여러 작업자가 동시에 버튼 클릭
2
// → 잘못된 재고 트랜잭션 생성

1
// 1. 어노테이션 정의
2
@Target(ElementType.METHOD)
3
@Retention(RetentionPolicy.RUNTIME)
4
public @interface DistributedLock {
5
    String key();           // 락 이름 (SpEL 지원)
6
    long waitTime();        // 대기 시간 (초)
7
    long leaseTime();       // 임차 시간 (초)
8
    TimeUnit timeUnit() default TimeUnit.SECONDS;
9
}
10

11
// 2. 사용 예시
12
@DistributedLock(key = "#lockName", waitTime = 5, leaseTime = 3)
13
public void shipment(String lockName) {
14
    // 비즈니스 로직
15
    // lockName 값이 락 키로 사용됨 (예: "order:12345")
16
}

1
@Aspect
2
@Component
3
public class DistributedLockAop {
4
    private final RedissonClient redissonClient;
5
    private final AopForTransaction aopForTransaction;
6

7
    @Around("@annotation(distributedLock)")
8
    public Object lock(ProceedingJoinPoint joinPoint,
9
                       DistributedLock distributedLock) throws Throwable {
10

11
        // SpEL로 동적 락 키 생성
12
        String key = CustomSpringELParser.getDynamicValue(
13
            joinPoint.getSignature(),
14
            joinPoint.getArgs(),
15
            distributedLock.key()
16
        );
17

18
        RLock lock = redissonClient.getLock(key);
19

20
        try {
21
            // 락 획득 시도
22
            boolean available = lock.tryLock(
23
                distributedLock.waitTime(),
24
                distributedLock.leaseTime(),
25
                distributedLock.timeUnit()
26
            );
27

28
            if (!available) {
29
                throw new InterruptedException("락 획득 실패: " + key);
30
            }
31

32
            // 트랜잭션과 락을 함께 처리
33
            return aopForTransaction.proceed(joinPoint);
34

35
        } catch (InterruptedException e) {
36
            throw new RuntimeException("락 획득 중단", e);
37
        } finally {
38
            // 락 소유자인 경우에만 해제
39
            if (lock.isHeldByCurrentThread()) {
40
                lock.unlock();
41
            }
42
        }
43
    }
44
}

1
@Component
2
public class AopForTransaction {
3

4
    @Transactional(propagation = Propagation.REQUIRES_NEW)
5
    public Object proceed(ProceedingJoinPoint joinPoint) throws Throwable {
6
        return joinPoint.proceed();
7
    }
8
}

1
초기 쿠폰: 100개
2
동시 요청: 100명
3

4
[분산락 미적용]
5
최종 쿠폰: 21개 (79개만 차감, 21개 중복 차감 실패)
6

7
[분산락 적용]
8
최종 쿠폰: 0개 (정확히 100개 차감)

1
동일 발주 10건 동시 수신
2

3
[분산락 미적용]
4
등록된 발주: 3~5건 (중복 등록)
5

6
[분산락 적용]
7
등록된 발주: 1건 (정확!)

1
public void processOrder(String orderId) {
2
    RLock lock = redissonClient.getLock("order:" + orderId);
3
    try {
4
        if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
5
            try {
6
                // 비즈니스 로직
7
                validateOrder(orderId);
8
                updateStock(orderId);
9
                createShipment(orderId);
10
            } finally {
11
                lock.unlock();
12
            }
13
        } else {
14
            throw new RuntimeException("락 획득 실패");
15
        }
16
    } catch (InterruptedException e) {
17
        Thread.currentThread().interrupt();
18
        throw new RuntimeException(e);
19
    }
20
}

1
@DistributedLock(key = "'order:' + #orderId", waitTime = 10, leaseTime = 30)
2
public void processOrder(String orderId) {
3
    // 비즈니스 로직만 집중!
4
    validateOrder(orderId);
5
    updateStock(orderId);
6
    createShipment(orderId);
7
}