C++ scoped_lock | "범위 락" 가이드
이 글의 핵심
scoped_lock은 std::lock으로 여러 뮤텍스를 한 번에 잠그는 C++17 RAII 락입니다. lock_guard·unique_lock과 무엇이 다른지, 데드락 회피 한계, 다중 잠금 실전 예와 성능까지 정리합니다.
scoped_lock이란?
std::scoped_lock (C++17)은 여러 뮤텍스를 한 번에 잠그고, 범위를 벗어날 때 자동으로 모두 해제하는 RAII 락입니다. lock_guard의 다중 뮤텍스 버전이며, 데드락 방지를 위해 항상 같은 순서로 잠급니다. 스레드 기초와 데이터 레이스·뮤텍스를 먼저 보면 좋습니다.
#include <mutex>
std::mutex m1, m2;
void func() {
std::scoped_lock lock(m1, m2); // 데드락 방지
// ...
}왜 필요한가?:
- 데드락 방지: 여러 뮤텍스를 안전하게 잠금
- RAII: 자동 해제로 예외 안전
- 간결성: C++11의 복잡한 코드를 단순화
- 범용성: 단일 및 다중 뮤텍스 모두 지원
// ❌ 수동 잠금: 데드락 위험
std::mutex m1, m2;
void transfer1() {
m1.lock();
m2.lock(); // 데드락 가능!
// ...
m2.unlock();
m1.unlock();
}
void transfer2() {
m2.lock();
m1.lock(); // 데드락 가능!
// ...
m1.unlock();
m2.unlock();
}
// ✅ scoped_lock: 데드락 방지
void transfer1() {
std::scoped_lock lock(m1, m2); // 안전
// ...
}
void transfer2() {
std::scoped_lock lock(m2, m1); // 안전 (순서 무관)
// ...
}scoped_lock의 동작 원리:
scoped_lock은 내부적으로 std::lock()을 사용하여 데드락 회피 알고리즘으로 모든 뮤텍스를 잠급니다. 소멸자에서 자동으로 모든 뮤텍스를 해제합니다.
// 개념적 구현
template<typename... Mutexes>
class scoped_lock {
std::tuple<Mutexes&...> mutexes_;
public:
scoped_lock(Mutexes&... mutexes) : mutexes_(mutexes...) {
std::lock(mutexes...); // 데드락 회피 알고리즘
}
~scoped_lock() {
// 역순으로 해제
unlock_all(mutexes_);
}
// 복사/이동 불가
scoped_lock(const scoped_lock&) = delete;
scoped_lock& operator=(const scoped_lock&) = delete;
};데드락 회피 알고리즘:
std::lock()은 try-lock 기반 알고리즘을 사용하여 데드락을 방지합니다:
- 첫 번째 뮤텍스를 잠금
- 나머지 뮤텍스를
try_lock()으로 시도 - 실패 시 모두 해제하고 재시도
- 모두 성공할 때까지 반복
// std::lock의 개념적 동작
void lock(Mutex& m1, Mutex& m2) {
while (true) {
m1.lock();
if (m2.try_lock()) {
return; // 성공
}
m1.unlock(); // 실패, 재시도
std::this_thread::yield();
}
}기본 사용
std::mutex mtx;
void func() {
std::scoped_lock lock(mtx);
// 자동 잠금/해제
}실전 예시
예시 1: 계좌 이체
class Account {
std::mutex mtx;
int balance;
public:
Account(int b) : balance(b) {}
friend void transfer(Account& from, Account& to, int amount) {
// 데드락 방지
std::scoped_lock lock(from.mtx, to.mtx);
from.balance -= amount;
to.balance += amount;
}
int getBalance() const {
std::scoped_lock lock(mtx);
return balance;
}
};예시 2: 여러 자원
std::mutex m1, m2, m3;
int data1, data2, data3;
void update() {
std::scoped_lock lock(m1, m2, m3);
data1++;
data2++;
data3++;
}예시 3: 단일 뮤텍스
std::mutex mtx;
void func() {
std::scoped_lock lock(mtx); // lock_guard와 동일
// ...
}예시 4: 조건부 잠금
std::mutex m1, m2;
void func(bool needBoth) {
if (needBoth) {
std::scoped_lock lock(m1, m2);
// ...
} else {
std::scoped_lock lock(m1);
// ...
}
}lock_guard vs scoped_lock
// lock_guard: 단일 뮤텍스
std::lock_guard<std::mutex> lock(mtx);
// scoped_lock: 여러 뮤텍스
std::scoped_lock lock(m1, m2, m3);
// scoped_lock이 더 범용적자주 발생하는 문제
문제 1: 데드락
// ❌ 수동 잠금 (데드락 가능)
m1.lock();
m2.lock();
// ✅ scoped_lock
std::scoped_lock lock(m1, m2);문제 2: 순서
// Thread 1
std::scoped_lock lock(m1, m2);
// Thread 2
std::scoped_lock lock(m2, m1); // OK: 데드락 방지문제 3: 예외 안전성
std::scoped_lock lock(m1, m2);
process(); // 예외 발생해도 자동 unlock문제 4: 이동 불가
std::scoped_lock lock(mtx);
// ❌ 이동 불가
// auto lock2 = std::move(lock);
// unique_lock 사용 필요
std::unique_lock<std::mutex> ulock(mtx);
auto ulock2 = std::move(ulock); // OKC++11 대안
// C++11: std::lock + lock_guard
std::mutex m1, m2;
void func() {
std::lock(m1, m2);
std::lock_guard<std::mutex> lock1(m1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(m2, std::adopt_lock);
}
// C++17: scoped_lock (간단)
void func() {
std::scoped_lock lock(m1, m2);
}실무 패턴
패턴 1: 안전한 스왑
template<typename T>
class ThreadSafeContainer {
mutable std::mutex mtx_;
T data_;
public:
void swap(ThreadSafeContainer& other) {
if (this == &other) return;
// 데드락 방지
std::scoped_lock lock(mtx_, other.mtx_);
std::swap(data_, other.data_);
}
T get() const {
std::scoped_lock lock(mtx_);
return data_;
}
};패턴 2: 다중 자원 업데이트
class ResourceManager {
std::mutex cpuMtx_, memMtx_, diskMtx_;
int cpuUsage_, memUsage_, diskUsage_;
public:
void updateAll(int cpu, int mem, int disk) {
std::scoped_lock lock(cpuMtx_, memMtx_, diskMtx_);
cpuUsage_ = cpu;
memUsage_ = mem;
diskUsage_ = disk;
}
void updateCpu(int cpu) {
std::scoped_lock lock(cpuMtx_);
cpuUsage_ = cpu;
}
};패턴 3: 계층적 잠금
class BankSystem {
std::mutex accountsMtx_;
std::mutex transactionsMtx_;
std::mutex auditMtx_;
public:
void transfer(int from, int to, double amount) {
// 계좌와 트랜잭션 잠금
std::scoped_lock lock(accountsMtx_, transactionsMtx_);
// 계좌 이체
}
void audit() {
// 모든 자원 잠금
std::scoped_lock lock(accountsMtx_, transactionsMtx_, auditMtx_);
// 감사 수행
}
};lock_guard vs scoped_lock vs unique_lock (한눈에 비교)
세 클래스 모두 RAII로 뮤텍스를 잠그지만, 역할과 비용이 다릅니다.
| 구분 | lock_guard | scoped_lock | unique_lock |
|---|---|---|---|
| C++ 버전 | C++11 | C++17 | C++11 |
| 뮤텍스 개수 | 1개 | 1개 이상 (가변 인자) | 1개 |
std::lock 다중 잠금 | 직접 조합 필요 | 내장 (std::lock 호출) | std::unique_lock + std::lock 패턴 |
수동 unlock / defer_lock | 불가 | 불가 | 가능 (defer_lock, try_to_lock 등) |
condition_variable | mutex만으로는 제한적 | 보통 CV와 함께 쓰기엔 unique_lock | 표준 조합 |
| 이동 | 불가 | 불가 | 가능 |
선택 가이드
- 단일 뮤텍스, 잠금 범위가 블록 전체 →
lock_guard또는scoped_lock한 개 인자. 스타일 통일을 위해 팀이scoped_lock만 쓰기도 합니다. - 두 개 이상 뮤텍스를 항상 같이 잠가야 함 →
scoped_lock이 가장 단순하고 데드락 회피 알고리즘이 한 번에 들어갑니다. - 중간에 잠금 해제, 재잠금, 조건 변수 대기, 타임아웃 시도 →
unique_lock이 필수입니다.
std::mutex m;
std::condition_variable cv;
bool ready = false;
void wait_ready() {
std::unique_lock<std::mutex> lk(m); // scoped_lock으로 대체 불가
cv.wait(lk, [] { return ready; });
}데드락 방지: 잠금 순서만으로 부족할 때
scoped_lock은 같은 호출에서 잡는 여러 뮤텍스에 대해 std::lock 기반으로 순서를 정리해 줍니다. 하지만 다음은 여전히 위험합니다.
- 한 스레드은
scoped_lock(m1,m2), 다른 스레드는m1만 잡고 블로킹된 채m2를 기다리는 식으로 설계가 어긋난 경우. - 락 없이 공유 자료를 읽고, 다른 곳에서는 락을 잡고 쓰는 혼합 사용.
- 콜백·가상 함수 안에서 모르는 사이 다른 락을 잡는 비재진입(non-reentrant) 뮤텍스 중첩.
실무에서는 “전역 순서 번호”를 자원에 매기고, 항상 번호가 작은 뮤텍스부터 잠그는 규칙과 scoped_lock을 같이 쓰면 이해와 검증이 쉬워집니다. 이미 scoped_lock이 순서를 자동으로 맞춰 주더라도, 코드 리뷰 시 잠금 경로를 한눈에 보이게 하는 데 도움이 됩니다.
여러 뮤텍스를 동시에 잠글 때의 실무 체크
- 같은 두 객체를 서로 다른 순서로 잠그는 코드가 있다면
scoped_lock(a,b)와scoped_lock(b,a)모두 안전하지만, 일부만 잠그는 경로가 섞이지 않았는지 확인하세요. - **
std::shared_mutex**와 일반mutex를 함께 쓸 때는 읽기/쓰기 규칙을 문서화하세요.scoped_lock은 타입이 달라도 여러 개를 한 번에 잠글 수 있습니다(각각이 BasicLockable이면 됨). - 락 보유 시간을 최소화하세요.
scoped_lock으로 넓은 범위를 잡아 두고 I/O나 네트워크 호출을 하면 전체 처리량이 떨어집니다.
실전 예제 보강: 인접 노드 두 개를 동시에 갱신
그래프에서 엣지 (u, v)를 갱신할 때 두 정점의 내부 뮤텍스를 모두 잠가야 한다면, 정점 id 순으로만 잠그도록 하거나 scoped_lock(mtx[u], mtx[v])를 사용합니다.
struct Vertex {
std::mutex mtx;
int value{};
};
std::vector<Vertex> graph;
void add_edge_value(size_t u, size_t v, int delta) {
if (u == v) return;
// 정점별 뮤텍스 — 순서가 매번 바뀌어도 데드락 회피
std::scoped_lock lk(graph[u].mtx, graph[v].mtx);
graph[u].value += delta;
graph[v].value += delta;
}성능 비교: 무엇이 비싼가
- 단일
mutex, 경쟁이 심하지 않을 때:lock_guard와scoped_lock(mtx)는 동일한 수준의 비용(뮤텍스 잠금 자체가 지배적)입니다. - 다중 뮤텍스:
std::lock은 필요 시 try_lock·언락·재시도를 하므로, 최선 경로(한 번에 모두 잠김)보다 약간 더 나쁠 수 있습니다. 그 대신 데드락 없음이라는 비용으로 보는 것이 맞습니다. - 벤치마크 시 주의: 나노초 단위로만 비교하기보다, 실제 임계 구역 길이·경쟁 스레드 수에서 전체 응답 시간을 재는 편이 의미 있습니다.
요약하면, 단일 락이면 세 타입 중 “가장 단순한 것”, 다중 락이면 scoped_lock, **조건 변수·유연한 잠금이면 unique_lock**이 기본 선택입니다.
FAQ
Q1: scoped_lock은 무엇인가요?
A: C++17에서 도입된 여러 뮤텍스를 동시에 잠그는 RAII 락입니다. 데드락을 방지하고 자동으로 해제합니다.
std::mutex m1, m2;
void func() {
std::scoped_lock lock(m1, m2); // 데드락 방지
// 자동 해제
}Q2: 데드락을 어떻게 방지하나요?
A: 내부적으로 std::lock()의 데드락 회피 알고리즘을 사용합니다. 여러 뮤텍스를 안전하게 잠급니다.
// Thread 1
std::scoped_lock lock(m1, m2);
// Thread 2
std::scoped_lock lock(m2, m1); // OK: 데드락 방지동작 원리: try_lock() 기반으로 모든 뮤텍스를 원자적으로 잠급니다.
Q3: lock_guard와 어떤 차이가 있나요?
A:
- lock_guard: 단일 뮤텍스만 지원
- scoped_lock: 단일 및 다중 뮤텍스 모두 지원
// lock_guard: 단일만
std::lock_guard<std::mutex> lock(mtx);
// scoped_lock: 단일 및 다중
std::scoped_lock lock1(mtx); // 단일
std::scoped_lock lock2(m1, m2, m3); // 다중권장: C++17 이상에서는 scoped_lock 사용
Q4: 이동할 수 있나요?
A: 불가능합니다. scoped_lock은 복사와 이동이 모두 금지됩니다. 이동이 필요하면 unique_lock을 사용하세요.
std::scoped_lock lock(mtx);
// auto lock2 = std::move(lock); // 에러
// unique_lock 사용
std::unique_lock<std::mutex> ulock(mtx);
auto ulock2 = std::move(ulock); // OKQ5: 성능은 어떤가요?
A: 단일 뮤텍스의 경우 lock_guard와 동일합니다. 다중 뮤텍스의 경우 데드락 회피 알고리즘으로 인한 약간의 오버헤드가 있지만, 안전성을 고려하면 무시할 수 있습니다.
// 단일: lock_guard와 동일한 성능
std::scoped_lock lock(mtx);
// 다중: 약간의 오버헤드 (데드락 회피)
std::scoped_lock lock(m1, m2, m3);Q6: C++11/14에서는 어떻게 하나요?
A: std::lock()과 lock_guard를 조합하여 사용합니다.
// C++11/14
std::mutex m1, m2;
void func() {
std::lock(m1, m2); // 데드락 회피
std::lock_guard<std::mutex> lock1(m1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(m2, std::adopt_lock);
}
// C++17: 훨씬 간단
void func() {
std::scoped_lock lock(m1, m2);
}Q7: 조건부로 여러 뮤텍스를 잠글 수 있나요?
A: 가능하지만, 각 경우마다 별도의 scoped_lock을 사용해야 합니다.
void func(bool needBoth) {
if (needBoth) {
std::scoped_lock lock(m1, m2);
// 둘 다 잠금
} else {
std::scoped_lock lock(m1);
// m1만 잠금
}
}Q8: scoped_lock 학습 리소스는?
A:
- “C++ Concurrency in Action” (2nd Edition) by Anthony Williams
- “C++17 The Complete Guide” by Nicolai Josuttis
- cppreference.com - std::scoped_lock
관련 글: 뮤텍스·lock_guard, shared_mutex, 데이터 레이스·뮤텍스, 스레드 기초.
한 줄 요약: std::scoped_lock은 여러 뮤텍스를 데드락 없이 안전하게 잠그는 C++17 RAII 락입니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ Mutex & Lock | “뮤텍스와 락” 가이드
- C++ shared_mutex | “읽기-쓰기 락” 가이드
- C++ Data Race | “Mutex 대신 Atomic을 써야 하는 상황은?” 면접 단골 질문 정리
- C++ std::thread 입문 | join 누락·디태치 남용 등 자주 하는 실수 3가지와 해결법
관련 글
- C++ Data Race |
- C++ any |
- 모던 C++ (C++11~C++20) 핵심 문법 치트시트 | 현업에서 자주 쓰는 한눈에 보기
- C++ CTAD |
- C++ string vs string_view |