tryLock과 시간 제한 락 획득
락이 이미 잡혀 있을 때 기다리지 않고 다른 길로 가거나 정한 시간만 기다리는 tryLock의 두 형태와, 획득에 성공했을 때만 unlock하는 올바른 사용법을 배우고 19장의 재고 예제를 완성합니다.
사용자가 새로 고침 버튼을 연달아 두 번 누르면, 두 번째 요청은 첫 번째 새로 고침이 끝나기를 기다릴 필요 없이 '이미 새로 고치는 중'이라고 알려 주면 됩니다. 응답 기한이 700ms인 요청이라면 락 하나를 기다리느라 그 시간을 다 써 버려서는 안 됩니다. 그런데 lock()은 락을 얻을 때까지 기다리고, 앞 글의 lockInterruptibly()도 다른 스레드가 interrupt로 끊어 주기 전까지는 기다립니다. 기다리는 쪽이 스스로 '100ms까지만'이나 '누가 쓰고 있으면 아예 안 기다림'을 정할 방법이 필요합니다.
이 글을 읽고 나면 다음을 할 수 있습니다.
tryLock()의 결과를 확인하지 않고unlock()하는 버그를 재현하고, 성공했을 때만 해제하는 구조로 고칩니다.- 시간 제한
tryLock의 세 결과(성공, 시간 초과, 중단)를 서로 다른 값으로 돌려줍니다. - 19장에서 키워 온
LockedInventory를 기다리는 방식 세 가지를 모두 갖춘 재고 창구로 완성합니다.
준비물은 앞 글까지 고친 java-board 폴더의 src/LockedInventory.java입니다. 앞 글 3번 연습 문제의 ReserveResult와 reserveOrCancel()을 이어서 쓰므로, 아직 풀지 않았다면 그 해설의 코드를 먼저 붙여 둡니다. 정상 동작하는 예제는 src, 일부러 문제를 재현하는 예제는 lab에 저장하고, java-board 폴더에서 javac -d out src/ImmediateTryLockService.java로 컴파일한 뒤 java -cp out ImmediateTryLockService로 실행합니다. 다른 폴더의 파일은 경로의 src만 바꿉니다.
tryLock의 두 가지 형태
tryLock에는 인자가 없는 형태와 기다릴 시간을 받는 형태가 있습니다. 인자 없는 tryLock()은 호출한 순간 락이 비어 있는지 한 번만 확인합니다. 비어 있으면 락을 얻고 true를, 다른 스레드가 쥐고 있으면 기다리지 않고 바로 false를 돌려줍니다. tryLock(long time, TimeUnit unit)은 time만큼 락이 풀리기를 기다립니다. 그 안에 얻으면 true, 시간이 다 지나면 false를 돌려주고, 기다리는 도중에 interrupt()를 받으면 InterruptedException을 던집니다. 이 글에서는 앞의 것을 즉시 tryLock, 뒤의 것을 시간 제한 tryLock이라고 부르겠습니다.
| 메서드 | 락이 비어 있으면 | 다른 스레드가 쥐고 있으면 | 기다리는 중 interrupt를 받으면 |
|---|---|---|---|
tryLock() | 얻고 true | 바로 false | 기다리지 않으므로 해당 없음 |
tryLock(time, unit) | 얻고 true | 최대 time까지 기다린 뒤 false | InterruptedException |
호출 전에 플래그가 켜져 있을 때의 차이는 앞 글의 표에 있습니다. 시간 제한 tryLock은 락이 비어 있어도 곧바로 예외를 던지고, 즉시 tryLock()은 플래그를 보지 않습니다. 또 같은 스레드가 이미 쥐고 있는 락이라면 두 tryLock 모두 재진입으로 보고 true를 돌려주며 획득 횟수를 1 늘립니다. true를 받았다면 그 한 번에 대해 unlock()도 한 번 불러야 합니다.
얻지 못했는데 unlock하면 생기는 일
tryLock은 결과를 반환값으로만 알려 줍니다. 그래서 그 값을 확인하지 않으면 락을 얻었는지 모르는 채로 다음 코드가 실행됩니다. 다음 예제는 이 실수를 일부러 재현합니다. short-holder 스레드가 락을 얻어 50ms 동안 쥐고 있는 사이에 main이 tryLock()을 호출하고, 결과와 상관없이 finally에서 unlock()을 부릅니다.
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;
public final class UnlockWithoutAcquisitionFailure {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
CountDownLatch acquired = new CountDownLatch(1);
Thread holder = new Thread(() -> {
lock.lock();
try {
acquired.countDown();
Thread.sleep(50);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
}, "short-holder");
holder.start();
acquired.await();
boolean mine = lock.tryLock();
try {
System.out.println("acquired=" + mine);
} finally {
lock.unlock(); // 잘못된 코드: 얻지 못했어도 해제한다
}
}
}acquired 래치는 holder가 락을 얻은 다음에 열리므로, main이 acquired.await()에서 돌아왔다면 holder는 이미 락을 쥐고 있습니다. holder는 그 뒤 50ms를 잔 다음 락을 놓습니다. 따라서 main이 곧바로 tryLock()을 부르면 대개 holder가 아직 락을 쥐고 있어서 다음과 같이 출력됩니다.
acquired=false
Exception in thread "main" java.lang.IllegalMonitorStateException첫 줄은 tryLock()이 false를 돌려줬다는 뜻인데, 그런데도 try 블록은 실행됐습니다. 이 자리가 계좌 잔액을 바꾸는 코드였다면 holder가 락 안에서 같은 잔액을 다루는 동안 락 없이 끼어든 셈입니다. 이어서 finally의 unlock()이 예외를 던집니다. ReentrantLock은 락을 쥔 스레드만 해제할 수 있고, 쥐지 않은 스레드가 unlock()을 부르면 IllegalMonitorStateException을 던지기 때문입니다. 아무도 잡지 않은 이 예외는 main 밖으로 빠져나가고, 스택 트레이스가 이어진 뒤 프로그램이 종료 코드 1로 끝납니다.
그런데 이 결과가 매번 나오지는 않습니다. 50ms 잠은 main이 tryLock()을 부를 때까지 holder가 락을 쥐고 있게 만드는 장치가 아닙니다. 운영체제가 main 스레드를 50ms 넘게 실행하지 않고 미뤄 두면 그사이 holder가 락을 놓고, tryLock()은 true를 돌려줍니다. 그러면 acquired=true가 출력되고 unlock()도 자기 락을 정상적으로 해제하므로 프로그램은 아무 문제 없이 끝납니다. tryLock() 바로 앞에 Thread.sleep(200)을 넣어 main을 일부러 늦추면 이 경우를 직접 볼 수 있습니다. 같은 코드가 타이밍에 따라 예외로 끝나기도 하고 멀쩡히 끝나기도 하니, 테스트를 몇 번 통과했다고 안전한 코드라고 볼 수 없습니다.
획득 실패 뒤 unlock하면 소유권 예외가 납니다
tryLock의 false/true에 따라 무조건 unlock의 예외/정상 결과가 갈립니다. sleep이 순서를 보장하지 않는 조건 아래 획득→해제를 추적합니다.
UnlockWithoutAcquisitionFailure에서 실제로 나온 false와 IllegalMonitorStateException, 코드상 가능한 true 정상 종료를 구분합니다.
해제 조건 · 소유권
획득 실패 뒤 unlock하면 소유권 예외가 납니다
false를 받은 시도는 락을 소유하지 않습니다. 무조건 unlock하면 예외가 나며, 지연되어 true를 받은 경로도 가능합니다.
acquired=false
- 그 시도의 소유권
- 시도 때 소유자가 아직 보유 · main은 미소유
- 무조건 unlock하는 예제의 결과
IllegalMonitorStateException· 이번 실행에서 출력됨
acquired=true
- 그 시도의 소유권
- 소유자가 먼저 해제 · main이 획득
- 무조건 unlock하는 예제의 결과
- 정상 해제 가능 · 이번 실행에서는 나오지 않음
래치는 소유자가 한 번 획득했음을 알릴 뿐, main의 시도까지 보유를 유지하지 않습니다. main이 지연되어 소유자가 먼저 해제하면 두 번째 경로도 가능합니다.
이 예의 조건
- sleep 50은 main 시도까지 holder 보유를 보장하지 않습니다. false·true는 대안입니다.
관계도의 보충 설명
| 구분 | 내용 |
|---|---|
| 2 | sleep 50은 시도까지 보유를 고정하지 않아 false의 예외와 지연된 true의 정상 해제가 둘 다 가능합니다. 실제 소유한 획득분만 반납해야 합니다. |
| 4 | sleep 50은 보유 유지 아님 |
| 구분 | 내용 |
|---|---|
| 설명 | sleep 50은 시도까지 보유를 고정하지 않아 false의 예외와 지연된 true의 정상 해제가 둘 다 가능합니다. 실제 소유한 획득분만 반납해야 합니다. |
| 전체 읽기 정보 | 획득 실패 뒤 unlock하면 소유권 예외가 납니다 획득 실패 뒤 unlock하면 소유권 예외가 납니다 UnlockWithoutAcquisitionFailure에서 실제로 나온 false와 IllegalMonitorStateException, 코드상 가능한 true 정상 종료를 구분합니다. 해제 조건 · 소유권 획득 실패 뒤 unlock하면 소유권 예외가 납니다 false를 받은 시도는 락을 소유하지 않습니다. 무조건 unlock하면 예외가 나며, 지연되어 true를 받은 경로도 가능합니다. acquired=false 그 시도의 소유권 시도 때 소유자가 아직 보유 · main은 미소유 무조건 unlock하는 예제의 결과 IllegalMonitorStateException · 이번 실행에서 출력됨 acquired=true 그 시도의 소유권 소유자가 먼저 해제 · main이 획득 무조건 unlock하는 예제의 결과 정상 해제 가능 · 이번 실행에서는 나오지 않음 래치는 소유자가 한 번 획득했음을 알릴 뿐, main의 시도까지 보유를 유지하지 않습니다. main이 지연되어 소유자가 먼저 해제하면 두 번째 경로도 가능합니다. |
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 공통 즉시 시도 main의 tryLock 시점과 holder 반납 시점이 갈립니다. |
|
|
| 무조건 반납 호출 예제 코드가 두 결과 모두에서 unlock을 호출합니다. |
|
|
| 각 실행 결과 미소유·소유 상태의 해제 결과를 비교합니다. |
|
|
획득 실패 뒤 unlock하면 소유권 예외가 납니다
tryLock의 false/true에 따라 무조건 unlock의 예외/정상 결과가 갈립니다. sleep이 순서를 보장하지 않는 조건 아래 획득→해제를 추적합니다.
UnlockWithoutAcquisitionFailure에서 실제로 나온 false와 IllegalMonitorStateException, 코드상 가능한 true 정상 종료를 구분합니다.
해제 조건 · 소유권
획득 실패 뒤 unlock하면 소유권 예외가 납니다
false를 받은 시도는 락을 소유하지 않습니다. 무조건 unlock하면 예외가 나며, 지연되어 true를 받은 경로도 가능합니다.
acquired=false
- 그 시도의 소유권
- 시도 때 소유자가 아직 보유 · main은 미소유
- 무조건 unlock하는 예제의 결과
IllegalMonitorStateException· 이번 실행에서 출력됨
acquired=true
- 그 시도의 소유권
- 소유자가 먼저 해제 · main이 획득
- 무조건 unlock하는 예제의 결과
- 정상 해제 가능 · 이번 실행에서는 나오지 않음
래치는 소유자가 한 번 획득했음을 알릴 뿐, main의 시도까지 보유를 유지하지 않습니다. main이 지연되어 소유자가 먼저 해제하면 두 번째 경로도 가능합니다.
이 예의 조건
- sleep 50은 main 시도까지 holder 보유를 보장하지 않습니다. false·true는 대안입니다.
관계도의 보충 설명
| 구분 | 내용 |
|---|---|
| 2 | sleep 50은 시도까지 보유를 고정하지 않아 false의 예외와 지연된 true의 정상 해제가 둘 다 가능합니다. 실제 소유한 획득분만 반납해야 합니다. |
| 4 | sleep 50은 보유 유지 아님 |
| 구분 | 내용 |
|---|---|
| 설명 | sleep 50은 시도까지 보유를 고정하지 않아 false의 예외와 지연된 true의 정상 해제가 둘 다 가능합니다. 실제 소유한 획득분만 반납해야 합니다. |
| 전체 읽기 정보 | 획득 실패 뒤 unlock하면 소유권 예외가 납니다 획득 실패 뒤 unlock하면 소유권 예외가 납니다 UnlockWithoutAcquisitionFailure에서 실제로 나온 false와 IllegalMonitorStateException, 코드상 가능한 true 정상 종료를 구분합니다. 해제 조건 · 소유권 획득 실패 뒤 unlock하면 소유권 예외가 납니다 false를 받은 시도는 락을 소유하지 않습니다. 무조건 unlock하면 예외가 나며, 지연되어 true를 받은 경로도 가능합니다. acquired=false 그 시도의 소유권 시도 때 소유자가 아직 보유 · main은 미소유 무조건 unlock하는 예제의 결과 IllegalMonitorStateException · 이번 실행에서 출력됨 acquired=true 그 시도의 소유권 소유자가 먼저 해제 · main이 획득 무조건 unlock하는 예제의 결과 정상 해제 가능 · 이번 실행에서는 나오지 않음 래치는 소유자가 한 번 획득했음을 알릴 뿐, main의 시도까지 보유를 유지하지 않습니다. main이 지연되어 소유자가 먼저 해제하면 두 번째 경로도 가능합니다. |
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 공통 즉시 시도 main의 tryLock 시점과 holder 반납 시점이 갈립니다. |
|
|
| 무조건 반납 호출 예제 코드가 두 결과 모두에서 unlock을 호출합니다. |
|
|
| 각 실행 결과 미소유·소유 상태의 해제 결과를 비교합니다. |
|
|
도표는 같은 main 코드가 holder의 반납 전에 시도했을 때와 반납 뒤에 시도했을 때를 나란히 놓습니다. mine=false인 쪽은 남의 락을 해제하려다 예외가 나고, mine=true인 쪽은 자기 락을 정상적으로 풉니다. 해제할 자격은 시도했는지가 아니라 획득에 성공했는지로 정해집니다.
성공했을 때만 try로 들어가기
고치는 원칙은 앞에서 본 lock()-try-finally 구조와 같습니다. 락을 얻는 데 성공한 다음에야 try를 열고 finally에서 해제합니다. 그러면 finally는 락을 쥐고 있을 때만 실행되고, 얻지 못한 경우는 try 밖의 다른 분기로 빠집니다. Lock 인터페이스의 API 문서도 tryLock()의 대표적인 사용법으로 이 구조를 보여 줍니다. 앞 예제의 main에서 tryLock() 아래를 이렇게 바꿉니다.
boolean mine = lock.tryLock();
if (!mine) {
System.out.println("acquired=false");
return;
}
try {
System.out.println("acquired=true");
} finally {
lock.unlock();
}이제 평소처럼 실행하면 acquired=false, main을 200ms 늦추면 acquired=true가 나오고 두 경우 모두 정상 종료합니다. 결과는 여전히 타이밍에 따라 갈리지만, 어느 쪽이든 락 없이 임계 영역에 들어가거나 남의 락을 해제하는 일은 생기지 않습니다.
바쁘면 바로 돌아오는 tryLock()
즉시 tryLock()이 어울리는 곳은 '지금 누가 하고 있으면 나는 하지 않아도 되는' 작업입니다. 새로 고침 요청, 앞의 실행과 겹치면 안 되는 주기 작업, 여유가 있을 때만 하는 캐시 정리가 그런 예입니다. 다음 예제의 refresh()는 락을 얻지 못하면 기다리지 않고 "busy"를 돌려줍니다.
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;
public final class ImmediateTryLockService {
private final ReentrantLock lock = new ReentrantLock();
String refresh() {
if (!lock.tryLock()) return "busy";
try {
return "refreshed"; // 실제로는 여기서 데이터를 다시 읽어 온다
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
ImmediateTryLockService service = new ImmediateTryLockService();
CountDownLatch held = new CountDownLatch(1);
CountDownLatch release = new CountDownLatch(1);
Thread owner = new Thread(() -> {
service.lock.lock();
try {
held.countDown();
await(release);
} finally {
service.lock.unlock();
}
}, "refresh-owner");
owner.start();
held.await();
System.out.println("while-held=" + service.refresh());
release.countDown();
owner.join();
System.out.println("after-release=" + service.refresh());
}
private static void await(CountDownLatch latch) {
try {
latch.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}main은 두 래치로 실행 순서를 고정합니다. refresh-owner 스레드는 락을 얻은 뒤 held 래치를 열고, main이 release 래치를 열어 줄 때까지 락을 쥔 채 기다립니다. main은 owner가 락을 얻은 것을 확인한 뒤 첫 번째 refresh()를 부르고, 그다음에야 release를 열고 owner가 끝나기를 기다렸다가 두 번째 refresh()를 부릅니다. 람다로 만든 Runnable의 run()은 검사 예외를 던질 수 없으므로, owner 안에서는 await 도우미 메서드가 InterruptedException을 받아 플래그를 복원합니다.
두 번의 refresh()는 각각 무엇을 돌려줄까요? 먼저 예상해 보세요.
결과 확인하기
while-held=busy
after-release=refreshed첫 번째 refresh()가 실행될 때 owner는 release를 기다리며 락을 쥐고 있으므로 tryLock()은 false이고 결과는 busy입니다. 이 분기는 락을 얻지 않았으니 unlock()도 부르지 않습니다. 두 번째 호출 때는 owner가 이미 락을 놓고 종료했으므로 tryLock()이 성공하고, finally가 이번 호출이 얻은 락을 해제합니다. 첫 예제와 달리 이 출력은 실행할 때마다 같습니다. owner가 락을 놓는 시점을 sleep 시간이 아니라 main이 여는 release 래치가 정하기 때문입니다.
래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다
held 래치로 고정한 busy 시도 뒤 release·owner join을 거쳐 다음 tryLock 성공합니다. 실제 획득 조건 변화가 단계형에 적합합니다.
ImmediateTryLockService의 두 호출은 sleep 추정이 아니라 release 래치와 owner join으로 구분됩니다.
즉시 시도 · 해제 전후
래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다
release 래치 전에는 owner가 락을 유지합니다. 래치를 풀고 owner를 회수한 뒤 main이 다시 시도합니다.
실선: 래치·종료·시도의 필요 순서sleep50의 추정과 다른 고정 조건즉시거부가 무한재시도를 허용하진 않음
실선: 래치·종료·시도의 필요순서sleep50의 추정과 다른 고정조건즉시거부가 무한재시도를허용하진 않음
release 래치 해제 전
- 락을 가진 스레드
- owner가 락을 유지함 · main은 획득하지 못함
- 반환 출력
while-held=busy
래치 해제와 owner join 뒤
- 락을 가진 스레드
- main이 획득하고 finally에서 해제함
- 반환 출력
after-release=refreshed
busy는 즉시 거부 결과입니다. 이를 재시도하는 반복문은 이 예제에 없습니다.
이 예의 조건
- held와 release 래치가 두 시도의 보유 조건을 고정합니다.
관계도의 보충 설명
| 구분 | 내용 |
|---|---|
| 2 | held/release 래치와 owner join은 보유 중의 busy와 반납 뒤의 refreshed를 구분합니다. 소유하지 않은 분기는 해제하지 않고 재시도 정책은 이 예제 밖입니다. |
| 4 | held 신호 후 release 대기 |
| 9 | main이 release 해제 |
| 10 | owner가 unlock 후 종료 |
| 13 | tryLock=true |
| 14 | refreshed |
| 17 | sleep 50의 추정과 다른 고정 조건 |
| 18 | 즉시 거부가 무한 재시도를 허용하진 않음 |
| 구분 | 내용 |
|---|---|
| 설명 | held/release 래치와 owner join은 보유 중의 busy와 반납 뒤의 refreshed를 구분합니다. 소유하지 않은 분기는 해제하지 않고 재시도 정책은 이 예제 밖입니다. |
| 전체 읽기 정보 | 래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다 래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다 ImmediateTryLockService의 두 호출은 sleep 추정이 아니라 release 래치와 owner join으로 구분됩니다. 즉시 시도 · 해제 전후 래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다 release 래치 전에는 owner가 락을 유지합니다. 래치를 풀고 owner를 회수한 뒤 main이 다시 시도합니다. release 래치 해제 전 락을 가진 스레드 owner가 락을 유지함 · main은 획득하지 못함 반환 출력 while-held=busy 래치 해제와 owner join 뒤 락을 가진 스레드 main이 획득하고 finally에서 해제함 반환 출력 after-release=refreshed busy는 즉시 거부 결과입니다. 이를 재시도하는 반복문은 이 예제에 없습니다. |
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 보유 중 즉시 시도 owner가 획득 후 held를 알리고 release를 기다립니다. |
|
|
| 반납 회수 main이 release를 해제하고 owner.join을 끝냅니다. |
|
|
| 다음 즉시 시도 main이 tryLock에 성공하고 refresh를 수행합니다. |
|
|
래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다
held 래치로 고정한 busy 시도 뒤 release·owner join을 거쳐 다음 tryLock 성공합니다. 실제 획득 조건 변화가 단계형에 적합합니다.
ImmediateTryLockService의 두 호출은 sleep 추정이 아니라 release 래치와 owner join으로 구분됩니다.
즉시 시도 · 해제 전후
래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다
release 래치 전에는 owner가 락을 유지합니다. 래치를 풀고 owner를 회수한 뒤 main이 다시 시도합니다.
실선: 래치·종료·시도의 필요 순서sleep50의 추정과 다른 고정 조건즉시거부가 무한재시도를 허용하진 않음
실선: 래치·종료·시도의 필요순서sleep50의 추정과 다른 고정조건즉시거부가 무한재시도를허용하진 않음
release 래치 해제 전
- 락을 가진 스레드
- owner가 락을 유지함 · main은 획득하지 못함
- 반환 출력
while-held=busy
래치 해제와 owner join 뒤
- 락을 가진 스레드
- main이 획득하고 finally에서 해제함
- 반환 출력
after-release=refreshed
busy는 즉시 거부 결과입니다. 이를 재시도하는 반복문은 이 예제에 없습니다.
이 예의 조건
- held와 release 래치가 두 시도의 보유 조건을 고정합니다.
관계도의 보충 설명
| 구분 | 내용 |
|---|---|
| 2 | held/release 래치와 owner join은 보유 중의 busy와 반납 뒤의 refreshed를 구분합니다. 소유하지 않은 분기는 해제하지 않고 재시도 정책은 이 예제 밖입니다. |
| 4 | held 신호 후 release 대기 |
| 9 | main이 release 해제 |
| 10 | owner가 unlock 후 종료 |
| 13 | tryLock=true |
| 14 | refreshed |
| 17 | sleep 50의 추정과 다른 고정 조건 |
| 18 | 즉시 거부가 무한 재시도를 허용하진 않음 |
| 구분 | 내용 |
|---|---|
| 설명 | held/release 래치와 owner join은 보유 중의 busy와 반납 뒤의 refreshed를 구분합니다. 소유하지 않은 분기는 해제하지 않고 재시도 정책은 이 예제 밖입니다. |
| 전체 읽기 정보 | 래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다 래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다 ImmediateTryLockService의 두 호출은 sleep 추정이 아니라 release 래치와 owner join으로 구분됩니다. 즉시 시도 · 해제 전후 래치 해제 전과 소유자 종료 뒤에 한 번씩 시도합니다 release 래치 전에는 owner가 락을 유지합니다. 래치를 풀고 owner를 회수한 뒤 main이 다시 시도합니다. release 래치 해제 전 락을 가진 스레드 owner가 락을 유지함 · main은 획득하지 못함 반환 출력 while-held=busy 래치 해제와 owner join 뒤 락을 가진 스레드 main이 획득하고 finally에서 해제함 반환 출력 after-release=refreshed busy는 즉시 거부 결과입니다. 이를 재시도하는 반복문은 이 예제에 없습니다. |
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 보유 중 즉시 시도 owner가 획득 후 held를 알리고 release를 기다립니다. |
|
|
| 반납 회수 main이 release를 해제하고 owner.join을 끝냅니다. |
|
|
| 다음 즉시 시도 main이 tryLock에 성공하고 refresh를 수행합니다. |
|
|
도표는 두 시도 사이에 무엇이 바뀌었는지를 단계로 보여 줍니다. 래치를 열고 join()으로 owner의 반납을 확인한 것이, 다음 tryLock()이 성공할 조건을 만듭니다.
busy를 받은 호출자가 할 일
busy는 오류가 아니라 '지금은 다른 요청이 같은 일을 하고 있다'는 정상적인 결과입니다. 새로 고침이라면 진행 중인 작업이 곧 최신 데이터를 가져올 테니 이번 요청은 버려도 됩니다. 사용자 요청이라면 잠시 후 다시 시도하라고 알릴 수 있습니다. 피해야 할 것은 busy를 받자마자 다시 시도하는 다음과 같은 반복문입니다.
while (!lock.tryLock()) {
// 아무것도 하지 않고 곧바로 다시 시도한다
}이 코드는 락이 풀릴 때까지 쉬지 않고 같은 확인을 되풀이합니다. 기다리는 동안에도 CPU를 계속 쓰기 때문에 이런 방식을 바쁜 대기(busy waiting)라고 부릅니다. 락을 쥔 스레드가 써야 할 CPU 시간을 빼앗을 수 있고, 여러 스레드가 함께 이렇게 돌면 경합도 커집니다. 기다릴 생각이라면 스레드를 대기 상태로 두는 lock()이나 시간 제한 tryLock을 처음부터 쓰는 편이 낫습니다. 꼭 다시 시도해야 한다면 횟수에 상한을 두고, 시도 사이의 간격을 점점 늘리는 백오프(backoff)를 넣습니다.
여기까지가 즉시 tryLock()입니다. 결과를 확인한 뒤에만 try로 들어가고, 실패는 busy 같은 정상 결과로 돌려줍니다. 다음 절부터는 정한 시간만 기다리는 형태를 재고 예제에 붙입니다. 쉬어 가기 좋은 지점입니다.
재고 예약에 기다릴 시간 정하기
시간 제한 tryLock의 결과는 세 가지입니다. 시간 안에 락을 얻으면 true, 시간이 다 지나면 false, 기다리는 중에 interrupt()를 받으면 InterruptedException입니다. 앞 글에서 만든 ReserveResult에는 이미 CANCELLED가 있으니, 시간 초과를 뜻하는 TIMED_OUT만 더하면 세 결과를 모두 담을 수 있습니다. src/LockedInventory.java를 다음처럼 고칩니다.
import java.time.Duration;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;enum ReserveResult { RESERVED, SOLD_OUT, TIMED_OUT, CANCELLED }public ReserveResult tryReserve(String item, int quantity, Duration wait) {
if (quantity <= 0) throw new IllegalArgumentException();
boolean acquired = false;
try {
acquired = lock.tryLock(wait.toNanos(), TimeUnit.NANOSECONDS);
if (!acquired) return ReserveResult.TIMED_OUT;
int current = stock.getOrDefault(item, 0);
if (current < quantity) return ReserveResult.SOLD_OUT;
stock.put(item, current - quantity);
return ReserveResult.RESERVED;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return ReserveResult.CANCELLED;
} finally {
if (acquired) lock.unlock();
}
}tryReserve()는 refresh()와 구조가 다릅니다. tryLock(...)이 던지는 InterruptedException을 같은 메서드 안에서 잡으려고 획득 호출을 try 안에 넣었기 때문입니다. 이러면 락을 얻지 못한 경로에서도 finally가 실행되므로, 거기서 무조건 unlock()을 부르면 첫 예제와 같은 실수가 됩니다. 그래서 지역 변수 acquired에 이번 호출이 락을 얻었는지 기록하고, finally에서는 acquired가 true일 때만 해제합니다. 시간이 초과되면 false가 대입되고, 예외가 나면 대입 자체가 일어나지 않아 처음 값 false가 남습니다.
main은 세 결과를 차례로 만들어 봅니다. 아무도 락을 쥐지 않았을 때, 다른 스레드가 기다리는 시간 내내 락을 쥐고 있을 때, 호출하기 전에 이미 중단 요청을 받았을 때입니다. 둘째 경우의 owner 스레드는 ImmediateTryLockService와 같은 두 래치 방식입니다.
public static void main(String[] args) throws InterruptedException {
LockedInventory inventory = new LockedInventory();
inventory.put("book", 3);
Duration wait = Duration.ofMillis(20);
System.out.println("free: " + inventory.tryReserve("book", 2, wait));
CountDownLatch held = new CountDownLatch(1);
CountDownLatch release = new CountDownLatch(1);
Thread owner = new Thread(() -> {
inventory.lock.lock();
try {
held.countDown();
release.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
inventory.lock.unlock();
}
}, "owner");
owner.start();
held.await();
System.out.println("held: " + inventory.tryReserve("book", 1, wait));
release.countDown();
owner.join();
Thread.currentThread().interrupt();
System.out.println("interrupted: " + inventory.tryReserve("book", 1, wait));
System.out.println("flag=" + Thread.currentThread().isInterrupted()
+ ", " + inventory.snapshot());
}javac -d out src/LockedInventory.java
java -cp out LockedInventoryfree: RESERVED
held: TIMED_OUT
interrupted: CANCELLED
flag=true, {book=1}첫 줄은 락이 비어 있으니 바로 얻어 3권에서 2권을 뺀 결과입니다. 둘째 줄에서는 owner가 release를 기다리며 락을 계속 쥐고 있으므로, tryReserve()는 20ms를 다 기다린 뒤 TIMED_OUT을 돌려줍니다. 락을 얻지 못했으니 재고는 그대로이고 finally의 해제도 건너뜁니다.
셋째 줄은 owner가 이미 끝나 락이 비어 있었는데도 CANCELLED입니다. ReentrantLock의 API 문서에 따르면 시간 제한 tryLock은 락을 얻거나 시간 초과를 알리는 것보다 interrupt에 응답하는 것을 우선합니다. 예외가 던져질 때 플래그는 지워지지만 catch가 다시 켜 두었으므로 flag=true이고, 재고는 1권 그대로입니다. snapshot()은 플래그를 보지 않는 lock()을 쓰므로 플래그가 켜져 있어도 정상적으로 동작합니다.
시간 초과와 중단을 따로 돌려주는 이유
TIMED_OUT과 CANCELLED는 둘 다 락을 얻지 못했다는 점에서는 같아 보이지만, 호출자가 해야 할 일은 정반대입니다. TIMED_OUT은 지금 락이 바빴다는 뜻이므로 잠시 뒤 다시 시도하거나 다른 길로 갈 수 있습니다. CANCELLED는 누군가 이 스레드에게 하던 일을 멈추라고 요청했다는 뜻이므로, 다시 시도하지 말고 정리한 뒤 빠져나와야 합니다. 둘을 false 하나로 합치면 호출자는 종료 요청을 받은 스레드까지 재시도하게 되고, 프로그램을 끄려 해도 작업이 계속 돌 수 있습니다. 결과를 CANCELLED로 알리면서 플래그도 되살리는 것은, 결과를 보는 호출자와 플래그를 보는 더 바깥의 코드가 모두 요청을 알 수 있게 하려는 것입니다.
요청 전체의 기한 안에서 기다리기
시간 제한은 락 하나만 보지 말고 요청 전체의 기한을 보고 정합니다. 응답 기한이 700ms인 요청이 락에 500ms, DB 조회에 500ms를 각각 따로 준다면, 둘 다 한도까지 걸리는 경우 1000ms가 걸려 기한을 넘깁니다. 그래서 요청을 받을 때 마감 시각을 한 번 정해 두고, 각 단계에는 남은 시간만 넘깁니다.
long deadline = System.nanoTime() + Duration.ofMillis(700).toNanos(); // 요청을 받을 때 한 번
// ... 앞 단계들이 시간을 쓴다 ...
Duration left = Duration.ofNanos(deadline - System.nanoTime());
ReserveResult result = inventory.tryReserve("book", 1, left); // 남은 시간만 기다린다System.nanoTime()은 현재 시각이 아니라 경과 시간을 재는 용도의 시계라서, 컴퓨터의 시계를 맞추느라 시각이 바뀌어도 영향을 받지 않습니다. 남은 시간이 0 이하이면 tryLock은 전혀 기다리지 않고 한 번만 시도합니다. 또 시간 초과는 이 호출자가 기다리기를 그만뒀다는 뜻일 뿐, 락을 쥔 스레드의 작업이 취소되는 것은 아닙니다. 사용자가 늦은 요청을 다시 보내면 락을 쥔 스레드가 바로 그 요청의 이전 시도를 처리하고 있을 수 있으므로, 다시 시도할 때는 같은 작업이 이미 끝났는지 확인해야 합니다. 여러 번 실행해도 한 번 실행한 것과 결과가 같도록 만드는 이 성질을 멱등성(idempotency)이라고 합니다.
실패 분기에서 보호된 상태를 읽지 않는다
tryReserve()의 TIMED_OUT과 CANCELLED 분기는 재고를 읽지 않고 결과만 돌려줍니다. 이것이 왜 중요한지는 실패 분기에서 카운터를 읽는 다음 예제로 보겠습니다. 결과 상태와 함께 지금까지 게시한 횟수를 레코드로 돌려주는데, 실행해 보면 문제가 없어 보입니다.
import java.time.Duration;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public final class BoundedPublisher {
private record Outcome(String status, int published) {}
private final ReentrantLock lock = new ReentrantLock();
private int published;
Outcome publish(Duration wait) {
boolean acquired = false;
try {
acquired = lock.tryLock(wait.toNanos(), TimeUnit.NANOSECONDS);
if (!acquired) return new Outcome("timed-out", published);
published++;
return new Outcome("published", published);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return new Outcome("interrupted", published);
} finally {
if (acquired) lock.unlock();
}
}
public static void main(String[] args) {
BoundedPublisher publisher = new BoundedPublisher();
System.out.println(publisher.publish(Duration.ofMillis(10)));
System.out.println(publisher.publish(Duration.ZERO));
}
}Outcome[status=published, published=1]
Outcome[status=published, published=2]main은 아무도 락을 쥐지 않은 상태에서 publish()를 두 번 부르므로 둘 다 성공합니다. 두 번째 호출의 Duration.ZERO는 기다리지 않겠다는 뜻이지만 락이 비어 있으니 바로 얻습니다. Outcome[...] 형식은 레코드가 자동으로 만들어 주는 toString()의 결과입니다. 이 main은 timed-out과 interrupted 분기를 한 번도 실행하지 않습니다.
결함은 실행되지 않은 그 두 분기에 있습니다. 두 분기는 락을 얻지 못한 채 published 필드를 읽어 결과에 담는데, 이 분기들은 하필 다른 스레드가 그 락을 쥐고 published를 바꾸고 있을지도 모르는 바로 그때 실행됩니다.
미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다
성공 경로는 보호된 증가·반환, 실패 분기는 획득 없이 plain 카운터를 읽습니다. 분기별 획득 여부·갱신·읽기·반납을 단계로 설명합니다. 예제 main은 성공 경로만 실행합니다.
BoundedPublisher의 실제 두 성공 출력과 timed-out/interrupted 소스 분기를 나눕니다. 실패 분기의 plain published 무잠금 조회 결함은 그대로 존재합니다.
결과와 결함 · 미획득 읽기
미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다
실패 상태를 반환해도 락 없이 published를 읽는 것이 안전해지지는 않습니다. 미획득 두 분기의 카운터는 무잠금 조회입니다.
published
- 카운터 변경과 해제
- 획득 뒤 증가 · finally에서 unlock
- 예제와 실행의 범위
- main의 두 성공 결과:
published=1,published=2
timed-out
- 카운터 변경과 해제
- 증가와 unlock 없음
- 예제와 실행의 범위
- 미실행 분기 · published를 락 없이 읽어 반환
interrupted
- 카운터 변경과 해제
- 플래그 복원 · 증가와 unlock 없음
- 예제와 실행의 범위
- 미실행 분기 · published를 락 없이 읽어 반환
실패 결과의 published는 다른 스레드의 갱신을 동기화해 읽은 값이 아닙니다. 정확한 실패 스냅샷으로 해석할 수 없습니다. 성공 경로도 숫자 증가만 하며 실제 게시 I/O는 없습니다.
이 예의 조건
- 예제 main은 성공 반환 1·2만 실행합니다. 시간 만료·중단은 미실행 조건입니다.
관계도의 보충 설명
| 구분 | 내용 |
|---|---|
| 2 | 예제가 실행한 성공 경로 1/2와 실행하지 않은 두 실패 분기를 구분합니다. 실패의 plain published 읽기는 정확한 스냅샷이 아니며 본문의 별도 버전은 실패 카운터를 출력하지 않습니다. |
| 13 | 획득 없이 published 반환 |
| 23 | 본문의 별도 버전은 실패 숫자를 안 읽음 |
| 구분 | 내용 |
|---|---|
| 설명 | 예제가 실행한 성공 경로 1/2와 실행하지 않은 두 실패 분기를 구분합니다. 실패의 plain published 읽기는 정확한 스냅샷이 아니며 본문의 별도 버전은 실패 카운터를 출력하지 않습니다. |
| 전체 읽기 정보 | 미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다 미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다 BoundedPublisher의 실제 두 성공 출력과 timed-out/interrupted 소스 분기를 나눕니다. 실패 분기의 plain published 무잠금 조회 결함은 그대로 존재합니다. 결과와 결함 · 미획득 읽기 미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다 실패 상태를 반환해도 락 없이 published를 읽는 것이 안전해지지는 않습니다. 미획득 두 분기의 카운터는 무잠금 조회입니다. published 카운터 변경과 해제 획득 뒤 증가 · finally에서 unlock 예제와 실행의 범위 main의 두 성공 결과: published=1 , published=2 timed-out 카운터 변경과 해제 증가와 unlock 없음 예제와 실행의 범위 미실행 분기 · published를 락 없이 읽어 반환 interrupted 카운터 변경과 해제 플래그 복원 · 증가와 unlock 없음 예제와 실행의 범위 미실행 분기 · published를 락 없이 읽어 반환 실패 결과의 published는 다른 스레드의 갱신을 동기화해 읽은 값이 아닙니다. 정확한 실패 스냅샷으로 해석할 수 없습니다. 성공 경로도 숫자 증가만 하며 실제 게시 I/O는 없습니다. |
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 공통 획득 시도 timed tryLock의 성공·false·중단 예외를 비교합니다. |
|
|
| 각 상태 접근 성공만 락 안에서 published를 증가시킵니다. |
|
|
| 반환과 해제 각 분기의 결과와 해제 여부를 함께 둡니다. |
|
|
미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다
성공 경로는 보호된 증가·반환, 실패 분기는 획득 없이 plain 카운터를 읽습니다. 분기별 획득 여부·갱신·읽기·반납을 단계로 설명합니다. 예제 main은 성공 경로만 실행합니다.
BoundedPublisher의 실제 두 성공 출력과 timed-out/interrupted 소스 분기를 나눕니다. 실패 분기의 plain published 무잠금 조회 결함은 그대로 존재합니다.
결과와 결함 · 미획득 읽기
미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다
실패 상태를 반환해도 락 없이 published를 읽는 것이 안전해지지는 않습니다. 미획득 두 분기의 카운터는 무잠금 조회입니다.
published
- 카운터 변경과 해제
- 획득 뒤 증가 · finally에서 unlock
- 예제와 실행의 범위
- main의 두 성공 결과:
published=1,published=2
timed-out
- 카운터 변경과 해제
- 증가와 unlock 없음
- 예제와 실행의 범위
- 미실행 분기 · published를 락 없이 읽어 반환
interrupted
- 카운터 변경과 해제
- 플래그 복원 · 증가와 unlock 없음
- 예제와 실행의 범위
- 미실행 분기 · published를 락 없이 읽어 반환
실패 결과의 published는 다른 스레드의 갱신을 동기화해 읽은 값이 아닙니다. 정확한 실패 스냅샷으로 해석할 수 없습니다. 성공 경로도 숫자 증가만 하며 실제 게시 I/O는 없습니다.
이 예의 조건
- 예제 main은 성공 반환 1·2만 실행합니다. 시간 만료·중단은 미실행 조건입니다.
관계도의 보충 설명
| 구분 | 내용 |
|---|---|
| 2 | 예제가 실행한 성공 경로 1/2와 실행하지 않은 두 실패 분기를 구분합니다. 실패의 plain published 읽기는 정확한 스냅샷이 아니며 본문의 별도 버전은 실패 카운터를 출력하지 않습니다. |
| 13 | 획득 없이 published 반환 |
| 23 | 본문의 별도 버전은 실패 숫자를 안 읽음 |
| 구분 | 내용 |
|---|---|
| 설명 | 예제가 실행한 성공 경로 1/2와 실행하지 않은 두 실패 분기를 구분합니다. 실패의 plain published 읽기는 정확한 스냅샷이 아니며 본문의 별도 버전은 실패 카운터를 출력하지 않습니다. |
| 전체 읽기 정보 | 미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다 미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다 BoundedPublisher의 실제 두 성공 출력과 timed-out/interrupted 소스 분기를 나눕니다. 실패 분기의 plain published 무잠금 조회 결함은 그대로 존재합니다. 결과와 결함 · 미획득 읽기 미획득 결과의 카운터 읽기는 락으로 보호되지 않습니다 실패 상태를 반환해도 락 없이 published를 읽는 것이 안전해지지는 않습니다. 미획득 두 분기의 카운터는 무잠금 조회입니다. published 카운터 변경과 해제 획득 뒤 증가 · finally에서 unlock 예제와 실행의 범위 main의 두 성공 결과: published=1 , published=2 timed-out 카운터 변경과 해제 증가와 unlock 없음 예제와 실행의 범위 미실행 분기 · published를 락 없이 읽어 반환 interrupted 카운터 변경과 해제 플래그 복원 · 증가와 unlock 없음 예제와 실행의 범위 미실행 분기 · published를 락 없이 읽어 반환 실패 결과의 published는 다른 스레드의 갱신을 동기화해 읽은 값이 아닙니다. 정확한 실패 스냅샷으로 해석할 수 없습니다. 성공 경로도 숫자 증가만 하며 실제 게시 I/O는 없습니다. |
| 관찰·상황 | 값·보충 정보 | 변화·이유 |
|---|---|---|
| 공통 획득 시도 timed tryLock의 성공·false·중단 예외를 비교합니다. |
|
|
| 각 상태 접근 성공만 락 안에서 published를 증가시킵니다. |
|
|
| 반환과 해제 각 분기의 결과와 해제 여부를 함께 둡니다. |
|
|
도표는 세 분기를 같은 반환 지점에서 비교합니다. 성공 분기만 락 안에서 published를 늘리고 읽으며, 시간 초과와 중단 분기는 락 없이 같은 필드를 읽습니다. 세 결과를 차례로 실행하는 흐름이 아니라 분기별 비교라는 점에 주의해서 보세요.
락이 다른 스레드의 쓰기를 보이게 해 주는 것은 '한 스레드의 unlock은 그 뒤에 같은 락을 얻는 lock보다 먼저 일어난다(happens-before)'는 규칙 덕분입니다. Lock 인터페이스의 API 문서는 성공한 lock과 unlock에 이 효과를 요구하면서, 실패한 획득 시도에는 그런 효과가 필요하지 않다고 밝힙니다. 따라서 실패 분기의 읽기와 다른 스레드가 락 안에서 한 쓰기 사이에는 아무 순서 관계가 없고, 이는 앞 글에서 본 데이터 경합(data race)입니다(JLS 17.4.5). 그런 읽기는 이미 지나간 옛 값을 볼 수 있고, 운 좋게 최신 값을 읽었더라도 바로 다음 순간 바뀔 수 있으니 실패한 시점의 정확한 개수라고 볼 수 없습니다.
고치는 방법은 실패 분기에서 카운터를 아예 읽지 않는 것입니다. 결과 필드를 Integer로 바꾸고, 락을 얻지 못한 경우에는 '이번 시도에서는 읽지 않았다'는 뜻으로 null을 담습니다. 바뀌는 곳은 다음 세 줄뿐입니다.
private record Outcome(String status, Integer observedPublished) {}
// ...
if (!acquired) return new Outcome("timed-out", null);
// ...
return new Outcome("interrupted", null);여기서 null은 '0개'가 아닙니다. 실패했을 때도 정확한 개수가 꼭 필요하다면, 락을 얻은 뒤에 값을 읽는 별도의 조회 메서드를 두고 그 조회가 얼마나 기다릴지도 따로 정해야 합니다. 재고 예제의 snapshot()이 그런 조회 메서드입니다.
어떤 획득 방법을 고를까
락 API를 고를 때는 '기다리지 못하면 무엇을 할 것인가'에서 출발하면 됩니다.
| 상황 | 알맞은 방법 |
|---|---|
| 임계 영역이 짧고 항상 기다려도 된다 | synchronized 또는 lock() |
| 기다리다가 취소 요청을 받으면 그만둬야 한다 | lockInterruptibly() |
| 누가 쓰고 있으면 기다리지 않고 다른 길로 간다 | tryLock() |
| 정해진 시간까지만 기다린다 | tryLock(time, unit) |
특별한 요구가 없다면 synchronized가 가장 단순합니다. 블록을 벗어나면 자동으로 해제되므로 finally를 빠뜨릴 걱정이 없습니다. ReentrantLock은 표의 아래 세 줄처럼 기다리는 방식을 제어해야 할 때 고릅니다. 여러 락을 차례로 얻어야 하는 코드에서는 시간 제한 tryLock이 실패하면 이미 얻은 락을 모두 놓고 물러났다가 다시 시도하는 방식으로 교착 상태(deadlock)를 피하기도 합니다.
락이 아예 필요 없는 경우도 있습니다. 한 스레드가 바꾼 값을 다른 스레드가 보기만 하면 되는 종료 플래그 하나라면 19장 첫 글에서 본 volatile로 충분합니다. 다른 값과 함께 바뀔 일이 없는 카운터 하나라면 AtomicInteger 같은 원자 클래스가 더 간결합니다.
19장 마무리: 기다리는 방식을 고르는 재고 창구
이제 이 장의 조각을 하나로 모읍니다. LockedInventory에는 ReentrantLock 사용법과 try-finally에서 만든 put(), reserve(), snapshot()과, 취소할 수 있는 reserveOrCancel(), 시간을 정해 기다리는 tryReserve()가 있습니다. 마지막 main은 서점의 재고 창구를 흉내 냅니다. 직원(clerk)이 재고를 정리하느라 락을 쥐고 있는 동안, 급한 손님은 20ms만 기다리고, 느긋한 손님은 기다리다가 영업 종료 요청으로 취소되며, 정리가 끝난 뒤에는 예약이 성공합니다.
시작 상태는 앞 절까지 고친 src/LockedInventory.java입니다. main만 다음으로 바꿉니다.
public static void main(String[] args) throws InterruptedException {
LockedInventory inventory = new LockedInventory();
inventory.put("book", 3);
// 1. 직원이 재고를 정리하느라 락을 쥔다
CountDownLatch held = new CountDownLatch(1);
CountDownLatch release = new CountDownLatch(1);
Thread clerk = new Thread(() -> {
inventory.lock.lock();
try {
held.countDown();
release.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
inventory.lock.unlock();
}
}, "clerk");
clerk.start();
held.await();
// 2. 급한 손님은 20ms만 기다린다
System.out.println("hurry: " + inventory.tryReserve("book", 1, Duration.ofMillis(20)));
// 3. 느긋한 손님은 기다리다가 영업 종료 요청을 받는다
ReserveResult[] patient = new ReserveResult[1];
Thread patientBuyer = new Thread(
() -> patient[0] = inventory.reserveOrCancel("book", 2), "patient");
patientBuyer.start();
patientBuyer.interrupt();
patientBuyer.join();
System.out.println("patient: " + patient[0]);
// 4. 정리가 끝난 뒤 두 번 예약한다
release.countDown();
clerk.join();
System.out.println("after: " + inventory.tryReserve("book", 2, Duration.ofMillis(20)));
System.out.println("after: " + inventory.tryReserve("book", 2, Duration.ofMillis(20)));
System.out.println(inventory.snapshot());
}컴파일하고 실행하는 명령은 앞 절과 같습니다. 마지막 출력이 어떻게 나올지 단계별로 먼저 적어 본 뒤 실행해 보세요.
결과 확인하기
hurry: TIMED_OUT
patient: CANCELLED
after: RESERVED
after: SOLD_OUT
{book=1}단계마다 확인할 것은 다음과 같습니다. 1단계가 끝나면 clerk가 락을 쥐고 있으므로, 2단계의 tryReserve()는 20ms를 다 기다린 뒤 TIMED_OUT을 돌려줍니다. 3단계의 patient 스레드는 reserveOrCancel()의 lockInterruptibly()에서 기다리거나 막 들어가려던 참에 interrupt를 받으므로, 어느 경우든 락을 얻지 못하고 CANCELLED로 끝납니다. main은 join()이 돌아온 뒤 결과를 읽으므로 patient[0]에 쓴 값이 보입니다. 4단계에서는 락이 비었으니 첫 예약이 3권에서 2권을 빼고, 두 번째 예약은 1 < 2라서 SOLD_OUT입니다. 재고에 손을 댄 것은 4단계의 첫 예약뿐이므로 마지막 줄은 {book=1}입니다.
출력이 다르다면 다음을 먼저 봅니다.
| 증상 | 먼저 볼 곳 |
|---|---|
hurry: RESERVED가 나온다 | clerk가 held.countDown()을 락을 얻은 뒤에 부르는지, main이 held.await()를 부르는지 |
프로그램이 patient 단계에서 멈춘다 | reserveOrCancel()이 lock()이 아니라 lockInterruptibly()를 쓰는지 |
IllegalMonitorStateException이 난다 | tryReserve()의 finally가 acquired를 확인하는지, reserveOrCancel()의 획득이 unlock()하는 try보다 앞에 있는지 |
after: TIMED_OUT이 나온다 | release.countDown()과 clerk.join()을 예약보다 먼저 부르는지 |
컴파일 오류 cannot find symbol | Duration, TimeUnit, CountDownLatch의 import와 ReserveResult의 TIMED_OUT |
여기까지의 전체 파일 src/LockedInventory.java
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public final class LockedInventory {
enum ReserveResult { RESERVED, SOLD_OUT, TIMED_OUT, CANCELLED }
private final Map<String, Integer> stock = new LinkedHashMap<>();
private final ReentrantLock lock = new ReentrantLock();
public void put(String item, int quantity) {
if (quantity < 0) throw new IllegalArgumentException();
lock.lock();
try {
stock.put(item, quantity);
} finally {
lock.unlock();
}
}
// 항상 기다린다 (19-5)
public boolean reserve(String item, int quantity) {
if (quantity <= 0) throw new IllegalArgumentException();
lock.lock();
try {
int current = stock.getOrDefault(item, 0);
if (current < quantity) return false;
stock.put(item, current - quantity);
return true;
} finally {
lock.unlock();
}
}
// 기다리다가 취소될 수 있다 (19-6)
public ReserveResult reserveOrCancel(String item, int quantity) {
if (quantity <= 0) throw new IllegalArgumentException();
try {
lock.lockInterruptibly();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return ReserveResult.CANCELLED;
}
try {
int current = stock.getOrDefault(item, 0);
if (current < quantity) return ReserveResult.SOLD_OUT;
stock.put(item, current - quantity);
return ReserveResult.RESERVED;
} finally {
lock.unlock();
}
}
// 정한 시간만 기다린다 (19-7)
public ReserveResult tryReserve(String item, int quantity, Duration wait) {
if (quantity <= 0) throw new IllegalArgumentException();
boolean acquired = false;
try {
acquired = lock.tryLock(wait.toNanos(), TimeUnit.NANOSECONDS);
if (!acquired) return ReserveResult.TIMED_OUT;
int current = stock.getOrDefault(item, 0);
if (current < quantity) return ReserveResult.SOLD_OUT;
stock.put(item, current - quantity);
return ReserveResult.RESERVED;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return ReserveResult.CANCELLED;
} finally {
if (acquired) lock.unlock();
}
}
public Map<String, Integer> snapshot() {
lock.lock();
try {
return Map.copyOf(stock);
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
LockedInventory inventory = new LockedInventory();
inventory.put("book", 3);
CountDownLatch held = new CountDownLatch(1);
CountDownLatch release = new CountDownLatch(1);
Thread clerk = new Thread(() -> {
inventory.lock.lock();
try {
held.countDown();
release.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
inventory.lock.unlock();
}
}, "clerk");
clerk.start();
held.await();
System.out.println("hurry: " + inventory.tryReserve("book", 1, Duration.ofMillis(20)));
ReserveResult[] patient = new ReserveResult[1];
Thread patientBuyer = new Thread(
() -> patient[0] = inventory.reserveOrCancel("book", 2), "patient");
patientBuyer.start();
patientBuyer.interrupt();
patientBuyer.join();
System.out.println("patient: " + patient[0]);
release.countDown();
clerk.join();
System.out.println("after: " + inventory.tryReserve("book", 2, Duration.ofMillis(20)));
System.out.println("after: " + inventory.tryReserve("book", 2, Duration.ofMillis(20)));
System.out.println(inventory.snapshot());
}
}앞 글에서 추가한 reserveInterruptibly()나 연습 문제의 restock()이 남아 있어도 그대로 두면 됩니다. 이 main은 쓰지 않습니다.
완성한 뒤에는 다음을 스스로 붙여 보세요.
- 즉시
tryLock()을 쓰는reserveIfIdle(item, quantity)를 만들고, 락이 바쁘면ReserveResult에 새로 더한BUSY를 돌려주게 합니다. - 마감 시각
deadline을 받아 남은 시간만 기다리는reserveBefore(item, quantity, deadline)을tryReserve()를 이용해 만듭니다. tryReserve()가wait로null을 받으면IllegalArgumentException으로 거절하게 합니다. 지금은wait.toNanos()에서NullPointerException이 납니다.
더 깊이: isHeldByCurrentThread()로 해제 여부를 정하면 안 되는 이유
acquired 변수 대신 finally에서 if (lock.isHeldByCurrentThread()) lock.unlock();처럼 '지금 이 스레드가 락을 쥐고 있는가'를 물어보면 되지 않을까 싶을 수 있습니다. 하지만 이 메서드는 이번 호출이 락을 얻었는지가 아니라, 이 스레드가 어떤 경로로든 락을 쥐고 있는지를 알려 줍니다. 차이는 재진입에서 드러납니다. 바깥 메서드가 이미 같은 락을 쥔 상태에서 안쪽 메서드의 시간 제한 tryLock이 interrupt 때문에 예외를 던지면, 안쪽은 락을 새로 얻지 못했는데도 isHeldByCurrentThread()는 true입니다. 그래서 안쪽의 finally가 바깥 메서드의 몫을 풀어 버리고, 바깥 메서드는 락 없이 임계 영역을 계속 실행하다가 자기 finally의 unlock()에서 IllegalMonitorStateException을 만납니다. API 문서도 이 메서드를 주로 디버깅과 테스트에 쓰는 것으로 설명합니다.
더 깊이: tryLock()과 tryLock(0, TimeUnit.SECONDS)의 차이
기다릴 시간을 0으로 준 시간 제한 tryLock은 즉시 tryLock()과 비슷하지만 두 가지가 다릅니다. 첫째는 공정성입니다. 공정 락을 다룬 글에서 본 것처럼 new ReentrantLock(true)로 만든 공정 락은 오래 기다린 스레드에게 먼저 락을 줍니다. 그런데 즉시 tryLock()은 공정 락에서도 이 순서를 따르지 않고, 락이 비어 있기만 하면 다른 스레드가 기다리고 있어도 바로 가져갑니다. ReentrantLock의 API 문서는 이를 끼어들기(barging)라고 부르며, 공정성을 지키고 싶다면 거의 같은 동작인 tryLock(0, TimeUnit.SECONDS)를 쓰라고 안내합니다.
둘째는 interrupt입니다. 시간 제한 형태는 들어오자마자 플래그를 확인하지만, 즉시 tryLock()은 확인하지 않습니다.
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public final class ZeroWaitComparison {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread.currentThread().interrupt(); // 중단 요청을 미리 받아 둔다
boolean immediate = lock.tryLock();
System.out.println("tryLock()=" + immediate
+ ", flag=" + Thread.currentThread().isInterrupted());
if (immediate) lock.unlock();
try {
boolean timed = lock.tryLock(0, TimeUnit.SECONDS);
System.out.println("tryLock(0)=" + timed);
if (timed) lock.unlock();
} catch (InterruptedException e) {
System.out.println("tryLock(0)=InterruptedException, flag="
+ Thread.currentThread().isInterrupted());
Thread.currentThread().interrupt();
}
}
}tryLock()=true, flag=true
tryLock(0)=InterruptedException, flag=false플래그가 켜져 있어도 즉시 tryLock()은 비어 있는 락을 얻고 플래그도 건드리지 않습니다. 반면 tryLock(0, TimeUnit.SECONDS)는 같은 상황에서 예외를 던지고 플래그를 지웁니다. 어느 형태를 쓰든 락의 공정성은 락을 요청한 순서에 관한 것일 뿐, 요청이 서버에 도착한 순서나 사용자가 버튼을 누른 순서까지 지켜 주지는 않습니다.
정리
tryLock()은 락이 비어 있으면 얻고true를, 다른 스레드가 쥐고 있으면 기다리지 않고false를 돌려줍니다. 공정 락에서도 줄을 서지 않고, interrupt 플래그도 확인하지 않습니다.tryLock(time, unit)의 결과는true,false(시간 초과),InterruptedException(중단 요청) 세 가지이며, 플래그가 켜져 있으면 락이 비어 있어도 예외를 던집니다.unlock()은 획득에 성공한 경우에만 부릅니다. 성공한 다음에try를 열거나, 이번 호출이 얻었는지를 지역 변수에 기록해finally에서 확인합니다.- 시간 초과와 중단은 서로 다른 결과로 돌려주고,
InterruptedException을 잡았다면 플래그를 복원합니다. 기다릴 시간은 요청 전체의 기한에서 남은 시간으로 정합니다. - 획득에 실패한 분기에서는 락이 지키는 상태를 읽지 않습니다. 실패한 시도는 다른 스레드의 쓰기를 보이게 해 주지 않습니다.
연습 문제
1. 상황에 맞는 획득 방법 고르기
다음 세 상황에 알맞은 획득 방법을 고르고 이유를 설명하세요.
- 매분 실행되는 정산 작업이 앞의 실행과 겹치면 이번 실행은 건너뛴다.
- 결제 요청 전체의 기한은 2초이고, 락은 남은 시간 안에서만 기다린다.
- 종료 요청이 오면 락을 기다리던 작업자가 바로 빠져나와야 하지만, 기다리는 시간에 상한은 없다.
해설 보기
첫 번째 상황에는 즉시 tryLock()이 맞습니다. 앞의 실행이 아직 락을 쥐고 있으면 false를 받아 이번 실행을 건너뛰면 되므로 기다릴 이유가 없습니다. 두 번째 상황에는 시간 제한 tryLock을 쓰되, 고정된 2초가 아니라 요청을 받을 때 정한 마감 시각에서 지금까지 쓴 시간을 뺀 나머지를 넘깁니다. 세 번째 상황은 시간 제한 없이 기다리되 interrupt에는 응답해야 하므로 lockInterruptibly()가 맞습니다. lock()은 interrupt를 받아도 계속 기다리기 때문에 종료 요청에 응답하지 못합니다.
2. 이미 락을 쥔 스레드의 tryReserve
마무리 절의 LockedInventory에서 main을 다음처럼 바꿨습니다. 출력을 예상해 보세요.
public static void main(String[] args) {
LockedInventory inventory = new LockedInventory();
inventory.put("book", 3);
inventory.lock.lock();
try {
System.out.println(inventory.tryReserve("book", 1, Duration.ZERO)
+ ", hold=" + inventory.lock.getHoldCount());
} finally {
inventory.lock.unlock();
}
System.out.println("locked=" + inventory.lock.isLocked() + ", " + inventory.snapshot());
}해설 보기
RESERVED, hold=1
locked=false, {book=2}main이 이미 락을 쥐고 있으므로 tryReserve()의 시간 제한 tryLock은 재진입으로 보고 기다리지 않고 true를 돌려줍니다. 획득 횟수는 2가 되고, 예약 뒤 tryReserve()의 finally가 자기 몫 한 번을 풀어 1로 돌아옵니다. 그래서 hold=1입니다. 이어서 main의 finally가 처음 얻은 한 번을 풀어 락이 완전히 풀리고, 재고는 3권에서 1권을 뺀 2권입니다. Duration.ZERO라도 재진입은 기다릴 일이 없으니 성공합니다.
3. 시간 초과가 예외로 바뀌는 save()
다음 save()에는 버그가 있습니다. 이 프로그램이 무엇을 출력할지 예상하고, 별도로 interrupt 플래그가 꺼진 호출자가 save()를 부르고, 다른 스레드가 tryLock의 대기 내내 락을 쥐고 있어 시간 초과가 났을 때 무엇을 받을지 답한 뒤, 코드를 고치세요.
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public final class TimedSaveExercise {
private final ReentrantLock lock = new ReentrantLock();
private int count;
String save() throws InterruptedException {
try {
if (!lock.tryLock(100, TimeUnit.MILLISECONDS)) return "timeout";
count++;
return "saved";
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
TimedSaveExercise service = new TimedSaveExercise();
Thread.currentThread().interrupt();
try {
System.out.println(service.save());
} catch (InterruptedException e) {
System.out.println("caller saw InterruptedException");
} catch (IllegalMonitorStateException e) {
System.out.println("caller saw IllegalMonitorStateException, flag="
+ Thread.currentThread().isInterrupted());
}
}
}힌트
tryLock이 try 안에 있으면, 예외로 끝나든 false를 돌려받든 finally가 실행됩니다. finally를 다룬 글에서 본 것처럼 finally에서 새 예외가 나면 무슨 일이 생기는지 떠올려 보세요.
해설 보기
caller saw IllegalMonitorStateException, flag=falsemain이 미리 interrupt를 걸어 두었으므로 tryLock은 들어오자마자 InterruptedException을 던지고 플래그를 지웁니다. 그런데 tryLock이 try 안에 있으니 finally가 실행되고, 락을 쥐지 않은 채 부른 unlock()이 IllegalMonitorStateException을 던집니다. finally에서 난 새 예외는 전파되던 원래 예외를 덮어쓰므로, 호출자는 InterruptedException 대신 IllegalMonitorStateException을 받고 중단 요청은 흔적 없이 사라집니다.
별도 상황에서도 반환값이 가려집니다. interrupt 요청이 없고 다른 스레드가 대기 내내 락을 쥐고 있어 tryLock이 시간 초과로 false를 돌려주면 return "timeout"이 실행되지만, 메서드가 끝나기 전에 finally의 unlock()이 예외를 던져 반환값을 덮어씁니다. 고치려면 tryLock을 try 밖으로 옮겨, 락을 얻은 다음에만 try가 시작되게 합니다.
String save() throws InterruptedException {
if (!lock.tryLock(100, TimeUnit.MILLISECONDS)) return "timeout";
try {
count++;
return "saved";
} finally {
lock.unlock();
}
}이렇게 고치면 같은 main은 caller saw InterruptedException을 출력하고, 락이 바쁠 때는 "timeout"이 그대로 호출자에게 돌아갑니다. InterruptedException은 save()의 throws 절을 따라 호출자에게 전달되므로 그 뒤의 처리는 호출자가 정합니다.
4. 시간 안에 못 얻으면 캐시를 돌려주는 load()
계산 결과를 보호하는 락을 최대 30ms 기다리는 load() 메서드를 가진 TimedCacheFallback 클래스를 src에 작성하세요.
- 락을 얻으면
"fresh", 시간 안에 얻지 못하면"cached", 기다리는 중 interrupt를 받으면"cancelled"를 돌려줍니다. InterruptedException을 잡았다면 플래그를 복원합니다.- 획득에 성공한 경우에만 락을 해제합니다.
main에서 한 번 부르고, 이어서 플래그를 켠 뒤 한 번 더 불러 두 결과와 플래그를 출력합니다.
힌트
tryReserve()와 같은 모양입니다. acquired 변수를 false로 시작해 tryLock의 결과를 대입하고, finally에서 그 값을 확인합니다.
해설 보기
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public final class TimedCacheFallback {
private final ReentrantLock lock = new ReentrantLock();
String load() {
boolean acquired = false;
try {
acquired = lock.tryLock(30, TimeUnit.MILLISECONDS);
if (!acquired) return "cached";
return "fresh";
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return "cancelled";
} finally {
if (acquired) lock.unlock();
}
}
public static void main(String[] args) {
TimedCacheFallback cache = new TimedCacheFallback();
System.out.println(cache.load());
Thread.currentThread().interrupt();
System.out.println(cache.load() + ", flag=" + Thread.currentThread().isInterrupted());
}
}fresh
cancelled, flag=true첫 호출은 경합도 중단 요청도 없으니 락을 바로 얻어 fresh입니다. 두 번째 호출은 락이 비어 있어도 시간 제한 tryLock이 켜진 플래그를 보고 예외를 던지므로 cancelled이고, catch가 플래그를 되살렸으므로 flag=true입니다. cached를 보려면 다른 스레드가 30ms 넘게 락을 쥐고 있게 만들어야 하며, 이 장의 owner와 같은 두 래치 방식을 쓰면 됩니다. 30ms는 락을 기다리는 시간의 상한일 뿐, load() 전체가 30ms 안에 끝난다는 뜻은 아닙니다.
다음 글
이것으로 19장을 마칩니다. 다음 장에서는 생산자·소비자 문제와 조건 대기를 다룹니다. 락을 얻은 다음에도 '큐에 빈자리가 생길 때까지'처럼 어떤 조건이 맞을 때까지 기다려야 하는 경우가 있습니다. 이때 락을 쥔 채 잠들면 어떤 일이 생기는지, 그리고 조건을 올바르게 기다리는 방법이 무엇인지 살펴봅니다.