C++ Lock-Free Programming | "락 프리 프로그래밍" 가이드

락 프리란?

락 없이 동시성 제어

// ❌ 락 사용
std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard lock(mtx);
    counter++;
}

// ✅ 락 프리
std::atomic<int> counter{0};

void increment() {
    counter.fetch_add(1);
}

CAS (Compare-And-Swap)

std::atomic<int> value{0};

void update() {
    int expected = 0;
    int desired = 10;
    
    while (!value.compare_exchange_weak(expected, desired)) {
        // 재시도
        expected = value.load();
        desired = compute(expected);
    }
}

실전 예시

예시 1: 락 프리 스택

template<typename T>
class LockFreeStack {
    struct Node {
        T data;
        Node* next;
    };
    
    std::atomic<Node*> head{nullptr};
    
public:
    void push(T value) {
        Node* newNode = new Node{value, head.load()};
        
        while (!head.compare_exchange_weak(newNode->next, newNode)) {
            // 재시도
        }
    }
    
    bool pop(T& result) {
        Node* oldHead = head.load();
        
        while (oldHead && 
               !head.compare_exchange_weak(oldHead, oldHead->next)) {
            // 재시도
        }
        
        if (oldHead) {
            result = oldHead->data;
            delete oldHead;
            return true;
        }
        return false;
    }
};

예시 2: 스핀락

class SpinLock {
    std::atomic_flag flag = ATOMIC_FLAG_INIT;
    
public:
    void lock() {
        while (flag.test_and_set(std::memory_order_acquire)) {
            // 스핀
            std::this_thread::yield();
        }
    }
    
    void unlock() {
        flag.clear(std::memory_order_release);
    }
};

예시 3: 락 프리 큐

template<typename T>
class LockFreeQueue {
    struct Node {
        T data;
        std::atomic<Node*> next{nullptr};
    };
    
    std::atomic<Node*> head;
    std::atomic<Node*> tail;
    
public:
    LockFreeQueue() {
        Node* dummy = new Node{};
        head.store(dummy);
        tail.store(dummy);
    }
    
    void enqueue(T value) {
        Node* newNode = new Node{value};
        Node* oldTail = tail.exchange(newNode);
        oldTail->next.store(newNode);
    }
    
    bool dequeue(T& result) {
        Node* oldHead = head.load();
        Node* next = oldHead->next.load();
        
        if (next == nullptr) {
            return false;
        }
        
        result = next->data;
        head.store(next);
        delete oldHead;
        return true;
    }
};

예시 4: 카운터

class LockFreeCounter {
    std::atomic<int> count{0};
    
public:
    void increment() {
        count.fetch_add(1, std::memory_order_relaxed);
    }
    
    int get() const {
        return count.load(std::memory_order_relaxed);
    }
};

ABA 문제

// A -> B -> A 변경 탐지 못함
std::atomic<Node*> head;

Node* oldHead = head.load();  // A
// 다른 스레드: A -> B -> A
head.compare_exchange_strong(oldHead, newNode);  // 성공 (문제)

// ✅ 버전 카운터
struct Pointer {
    Node* ptr;
    size_t version;
};

std::atomic<Pointer> head;

자주 발생하는 문제

문제 1: 메모리 재사용

// ❌ 즉시 삭제
Node* oldHead = head.load();
head.compare_exchange_strong(oldHead, oldHead->next);
delete oldHead;  // 다른 스레드가 사용 중일 수 있음

// ✅ 지연 삭제 (Hazard Pointer, Epoch-Based Reclamation)

문제 2: ABA 문제

// ✅ 버전 카운터
struct VersionedPointer {
    Node* ptr;
    uint64_t version;
};

std::atomic<VersionedPointer> head;

문제 3: 메모리 순서

// ❌ relaxed (순서 보장 안됨)
data.store(42, std::memory_order_relaxed);
ready.store(true, std::memory_order_relaxed);

// ✅ acquire-release
data.store(42, std::memory_order_relaxed);
ready.store(true, std::memory_order_release);

문제 4: 복잡성

// 락 프리는 복잡함
// 간단한 경우만 사용

// ✅ 간단: 카운터, 플래그
std::atomic<int> counter;

// ❌ 복잡: 자료구조
// mutex 사용 권장

성능 비교

// 락 프리: 대기 없음
std::atomic<int> counter;
counter++;

// 뮤텍스: 대기 가능
std::mutex mtx;
std::lock_guard lock(mtx);
counter++;

FAQ

Q1: 락 프리는?

A: 락 없이 동시성 제어.

Q2: 장점?

A:

• 대기 없음
• 데드락 없음
• 성능

Q3: 단점?

A:

• 복잡함
• ABA 문제
• 디버깅 어려움

Q4: 언제 사용?

A:

• 간단한 카운터
• 플래그
• 고성능 필요

Q5: ABA 문제?

A: 버전 카운터로 해결.

Q6: 락 프리 학습 리소스는?

A:

• “C++ Concurrency in Action”
• “The Art of Multiprocessor Programming”
• “Lock-Free Programming”

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ Atomic Operations | “원자적 연산” 가이드
• C++ Memory Order | “메모리 순서” 가이드
• C++ Atomic | “메모리 순서” 완벽 가이드

관련 글

• C++ Atomic Operations |
• C++ Lock-Free 프로그래밍 실전 | CAS·ABA·메모리 순서·고성능 큐 [#34-3]
• C++ Lock-Free 프로그래밍 실전 | CAS·ABA·메모리 순서·고성능 큐 [#51-5]
• C++ Atomic |
• C++ Memory Order |