스레드 간의 데이터 공유 및 보호

멀티스레드 비동기 프로그래밍에서 스레드 간의 데이터 공유는 매우 중요한 주제다. 여러 스레드가 동시에 동일한 데이터에 접근할 수 있는 상황에서, 데이터 무결성을 유지하고 동시성 문제를 해결하는 것이 필수적이다. 이러한 문제를 다루기 위해 일반적으로 사용하는 기법으로는 뮤텍스(Mutex), 락(lock), 컨디션 변수(condition variable) 등이 있다.

경쟁 상태 (Race Condition)

스레드 간의 데이터 공유에서 가장 먼저 해결해야 할 문제는 경쟁 상태다. 경쟁 상태란 여러 스레드가 동시에 동일한 자원에 접근하면서 발생하는 오류를 의미한다. 이 경우, 한 스레드가 데이터를 수정하는 도중에 다른 스레드가 동일한 데이터에 접근하여 예상치 못한 결과를 초래할 수 있다.

이를 방지하기 위해서는 임계 영역(critical section)을 정의하고, 한 스레드가 임계 영역에 진입할 때 다른 스레드들이 해당 영역에 접근하지 못하도록 해야 한다. 이 역할을 하는 것이 바로 뮤텍스(Mutex)다.

뮤텍스(Mutex)

뮤텍스는 한 번에 하나의 스레드만 특정 코드 블록을 실행할 수 있도록 보장하는 기법이다. 기본적인 원리는 스레드가 뮤텍스를 획득하면 다른 스레드는 그 뮤텍스가 해제될 때까지 대기한다는 점이다. 이를 통해 스레드 간의 데이터 경쟁을 방지할 수 있다.

뮤텍스의 동작을 다음과 같이 수학적으로 표현할 수 있다. 스레드가 임계 영역에 진입하기 전에, 뮤텍스를 획득하고, 해당 임계 영역에서의 작업이 끝나면 뮤텍스를 해제해야 한다.

$\text{lock}(\mathbf{M}) \quad \text{critical section} \quad \text{unlock}(\mathbf{M})$

여기서 $\mathbf{M}$ 은 뮤텍스 객체를 나타내며, $\text{lock}$ 은 뮤텍스의 잠금을 의미하고 $\text{unlock}$ 은 잠금 해제를 의미한다.

뮤텍스를 사용하는 코드의 예는 다음과 같다.

std::mutex mtx;

void critical_section() {
    mtx.lock();  // 뮤텍스 잠금
    // 임계 영역 코드
    mtx.unlock();  // 뮤텍스 잠금 해제
}

데드락(Deadlock)

뮤텍스를 사용할 때 조심해야 할 문제가 데드락(Deadlock)이다. 데드락은 두 개 이상의 스레드가 서로 자원을 획득하려고 대기하면서 발생하는 상황으로, 그 결과 모든 스레드가 무한정 대기 상태에 빠지게 된다. 데드락은 다음과 같은 상황에서 발생할 수 있다.

두 개 이상의 스레드가 각각 서로 다른 자원에 대한 뮤텍스를 획득한 후, 다른 스레드가 가진 자원의 뮤텍스를 추가로 획득하려고 시도할 때
뮤텍스를 획득한 후 해제하지 않고 임계 영역에서 벗어날 때

이를 방지하기 위한 기법으로 타임아웃 기법이나 뮤텍스 순서 규칙을 적용할 수 있다.

뮤텍스 순서 규칙

뮤텍스 순서 규칙은 여러 뮤텍스를 사용할 때, 모든 스레드가 동일한 순서로 뮤텍스를 획득하도록 강제하는 기법이다. 이를 통해 데드락을 방지할 수 있다.

다음은 여러 개의 뮤텍스를 사용할 때의 순서를 표현한 수식이다. 각 스레드가 $\mathbf{M}_1, \mathbf{M}_2, \dots, \mathbf{M}_n$ 을 동일한 순서로 획득해야 한다.

$\text{lock}(\mathbf{M}_1) \quad \text{lock}(\mathbf{M}_2) \quad \dots \quad \text{lock}(\mathbf{M}_n)$

이러한 규칙을 통해 스레드 간의 자원 경쟁 문제를 해결할 수 있다.

조건 변수(Condition Variable)

조건 변수는 뮤텍스와 함께 사용되며, 특정 조건이 충족될 때까지 스레드를 대기하게 하거나 신호를 보내어 스레드를 깨우는 데 사용된다. 조건 변수를 사용하면 스레드 간의 효율적인 데이터 공유 및 상태 변환 처리가 가능하다.

조건 변수는 일반적으로 다음과 같은 수식으로 표현할 수 있다.

$\mathbf{CV}.wait(\mathbf{M})$

$\mathbf{CV}.notify\_one() \quad \text{or} \quad \mathbf{CV}.notify\_all()$

여기서 $\mathbf{CV}$ 는 조건 변수를 의미하며, $\mathbf{M}$ 은 뮤텍스 객체다. $\text{wait}$ 함수는 조건이 만족될 때까지 대기하고, $\text{notify\_one}$ 이나 $\text{notify\_all}$ 함수는 대기 중인 스레드에게 신호를 보내 작업을 재개하도록 한다.

조건 변수를 사용하는 코드는 다음과 같다.

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void wait_for_signal() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });  // 조건이 만족될 때까지 대기
}

void send_signal() {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one();  // 신호 보내기
}

이 예제에서는 wait_for_signal 함수에서 조건 변수를 통해 ready 상태가 true가 될 때까지 대기하고, send_signal 함수에서 ready를 true로 설정한 후 신호를 보낸다.

락-프리 데이터 구조(Lock-Free Data Structure)

스레드 간의 데이터 공유 문제를 해결하는 또 다른 기법은 락-프리 데이터 구조(Lock-Free Data Structure)다. 이 방식에서는 뮤텍스나 락을 사용하지 않고도 스레드 간의 안전한 데이터 공유가 가능하다.

락-프리 알고리즘의 핵심은 비교와 교환(Compare-and-Swap, CAS) 연산이다. 이는 데이터의 현재 값을 확인하고, 특정 조건이 충족되면 값을 교체하는 방식으로 동작한다. 이를 수학적으로 표현하면 다음과 같다.

$\text{CAS}(\mathbf{V}, \mathbf{old}, \mathbf{new}) = \begin{cases} \mathbf{V} = \mathbf{new}, & \text{if } \mathbf{V} = \mathbf{old} \\ \text{false}, & \text{otherwise} \end{cases}$

여기서 $\mathbf{V}$ 는 공유 데이터의 현재 값, $\mathbf{old}$ 는 예상되는 값, $\mathbf{new}$ 는 변경하려는 값이다.

메모리 배리어(Memory Barrier)

멀티스레드 환경에서 스레드 간의 데이터 공유 시 또 다른 중요한 개념은 메모리 배리어(Memory Barrier)다. 컴파일러와 CPU는 코드의 실행 순서를 최적화하기 위해 명령어 순서를 변경할 수 있는데, 이는 멀티스레드 환경에서 의도하지 않은 동작을 유발할 수 있다.

메모리 배리어는 CPU와 컴파일러의 이러한 최적화를 제한하여, 특정 메모리 연산이 순서대로 수행되도록 강제하는 역할을 한다. 이를 통해 스레드 간의 데이터 공유 시 일관성을 보장할 수 있다.

메모리 배리어는 두 가지로 나눌 수 있다.

로드 배리어(Load Barrier): 이후의 읽기 연산이 이 배리어 앞의 모든 읽기 연산이 완료될 때까지 지연된다.
스토어 배리어(Store Barrier): 이후의 쓰기 연산이 이 배리어 앞의 모든 쓰기 연산이 완료될 때까지 지연된다.

메모리 배리어를 수식으로 표현하면 다음과 같다.

$\text{load\_barrier}() \quad \Rightarrow \quad \text{all previous loads complete}$

$\text{store\_barrier}() \quad \Rightarrow \quad \text{all previous stores complete}$

원자적 연산(Atomic Operations)

원자적 연산(Atomic Operations)은 스레드 간의 데이터 공유 및 보호에서 중요한 개념으로, 하나의 연산이 분리되지 않고 한 번에 이루어지며 중간에 다른 연산이 끼어들 수 없다는 특성을 가진다. 원자적 연산은 락을 사용하지 않고도 스레드 간의 동시성 문제를 해결할 수 있다.

Boost에서는 std::atomic을 이용하여 원자적 변수를 정의하고 사용할 수 있다. 이를 수학적으로 표현하면 다음과 같다.

$\mathbf{A} \quad \text{is atomic if} \quad \text{operation}(\mathbf{A}) \quad \text{executes indivisibly}$

즉, 원자적 변수 $\mathbf{A}$ 에 대한 모든 연산은 중단되지 않고 한 번에 완료된다. 예를 들어, 다음과 같은 원자적 증가 연산은 락 없이 안전하게 실행된다.

std::atomic<int> counter(0);
counter++;

이와 같은 연산은 여러 스레드가 동시에 접근해도 안전하게 작동하며, 뮤텍스에 비해 성능이 우수할 수 있다. 원자적 연산은 매우 적은 자원을 사용하면서도 스레드 간의 데이터 동기화를 가능하게 한다.

메모리 모델과 가시성(Memory Model and Visibility)

C++의 메모리 모델은 스레드 간의 데이터 공유에서 매우 중요한 역할을 한다. 메모리 모델은 스레드 간의 변수 접근이 일관되게 이루어지는 방법을 정의하며, 이는 가시성(Visibility) 문제와도 직결된다. 가시성이란 한 스레드에서의 메모리 변경 사항이 다른 스레드에 언제 보이는지를 의미한다.

C++11 이후로, 표준 메모리 모델이 도입되었으며, 이를 통해 스레드 간의 데이터 일관성을 보장할 수 있는 다양한 기법이 제공된다. 메모리 모델의 주요 요소는 다음과 같다.

순차 일관성(Sequential Consistency): 모든 연산이 순서대로 수행되고, 모든 스레드에서 동일한 순서로 관찰되는 가장 강력한 메모리 모델이다.

이를 수식으로 표현하면:

$\forall \mathbf{S}_i, \mathbf{S}_j \quad \text{if } \mathbf{S}_i \text{ observes event } e_1 \quad \text{then} \quad \mathbf{S}_j \text{ observes } e_1 \quad \text{in the same order}$

Acquire/Release 모드: 데이터의 가시성을 제어하는 기법으로, acquire는 특정 메모리 연산을 읽은 후, 해당 스레드에서의 이후 연산이 모두 이 읽기 연산 뒤에 위치하도록 보장하고, release는 메모리 연산을 쓰기 전에 이전에 발생한 모든 쓰기 연산이 완료되었음을 보장한다.

이 원리를 적용한 예시는 다음과 같다.

std::atomic<int> flag(0);
int data;

void writer() {
    data = 42;
    flag.store(1, std::memory_order_release);  // 데이터 쓰기 후 release
}

void reader() {
    while (flag.load(std::memory_order_acquire) != 1);  // flag가 설정될 때까지 대기
    // flag가 1이면 data = 42가 보장됨
}

여기서 memory_order_release는 쓰기 연산이 완료된 후 flag가 설정됨을 보장하며, memory_order_acquire는 flag가 1이 되었을 때, 데이터의 일관성을 보장한다.

잠금 없는 동시성(Lock-Free Concurrency)

잠금 없는 동시성(Lock-Free Concurrency)은 여러 스레드가 락을 사용하지 않고도 안전하게 데이터를 공유하는 기법이다. 앞서 언급한 원자적 연산과 비교와 교환(CAS) 연산을 이용하여 구현할 수 있다.

잠금 없는 알고리즘은 보통 세 가지 카테고리로 나눌 수 있다.

잠금 없는(lock-free): 어떤 스레드도 무한정 대기하지 않음이 보장되는 알고리즘.
경합 없는(wait-free): 모든 스레드가 유한 시간 내에 작업을 완료하는 알고리즘.
비차단(non-blocking): 어떤 스레드도 다른 스레드의 실패로 인해 중단되지 않는 알고리즘.

이러한 기법들은 스레드 간의 데이터 동기화를 좀 더 효율적으로 처리할 수 있는 방법을 제공하며, 뮤텍스를 사용하는 것보다 성능이 뛰어날 수 있다. 특히 고성능 시스템에서는 이러한 잠금 없는 동시성 기법이 중요한 역할을 한다.

메모리 정렬 및 캐시 일관성 (Memory Alignment and Cache Coherence)

스레드 간의 데이터 공유에서 메모리 정렬(Memory Alignment)과 캐시 일관성(Cache Coherence)도 매우 중요한 요소다. 멀티스레드 환경에서 여러 스레드가 같은 캐시 라인을 공유하는 경우, 성능 저하를 일으킬 수 있는 거짓 공유(False Sharing) 문제가 발생할 수 있다. 이는 캐시 일관성 프로토콜이 작동하면서 필요 이상의 데이터가 여러 번 갱신되기 때문에 발생한다.

거짓 공유는 두 개 이상의 스레드가 서로 다른 데이터를 처리하지만, 해당 데이터가 동일한 캐시 라인에 위치할 때 발생한다. 이를 해결하기 위해서는 데이터를 적절하게 정렬하고, 각 스레드가 사용하는 데이터가 별도의 캐시 라인에 할당되도록 해야 한다.

메모리 정렬 (Memory Alignment)

메모리 정렬은 데이터가 메모리에서 특정 기준에 맞게 배치되는 것을 의미한다. 특히, 캐시 라인과의 정렬이 성능에 큰 영향을 미칠 수 있다. C++에서는 alignas 키워드를 사용하여 메모리 정렬을 제어할 수 있다.

다음은 메모리 정렬을 통해 거짓 공유를 방지하는 예이다.

struct alignas(64) SharedData {
    int value;
};

이 예제에서 alignas(64)는 데이터가 64바이트 경계에 맞춰 정렬되도록 하여, 캐시 라인 간의 경합을 줄인다.

캐시 일관성(Cache Coherence)

캐시 일관성 문제는 여러 CPU 코어가 동일한 메모리 위치를 캐시에 로드하여 동시에 접근할 때 발생할 수 있다. 이를 해결하기 위한 프로토콜에는 대표적으로 MESI 프로토콜이 있다. MESI 프로토콜은 다음과 같은 상태를 통해 캐시 라인의 일관성을 유지한다.

Modified: 캐시 라인이 현재 CPU에서만 수정되었으며, 메모리와 일치하지 않음.
Exclusive: 캐시 라인이 현재 CPU에서만 사용되고 있으며, 메모리와 일치함.
Shared: 캐시 라인이 여러 CPU에서 공유되며, 메모리와 일치함.
Invalid: 캐시 라인이 더 이상 유효하지 않음.

이를 수학적으로 표현하면, 캐시 라인의 상태 $S$ 는 다음과 같은 트랜지션을 가질 수 있다.

$S(\mathbf{CPU}_i) \quad \Rightarrow \quad \text{Modified}, \text{Exclusive}, \text{Shared}, \text{Invalid}$

여기서 $\mathbf{CPU}_i$ 는 해당 CPU 코어를 나타낸다. 각 코어가 캐시 라인을 수정하거나 다른 코어가 동일한 라인에 접근할 때 상태가 변화하며, 이를 통해 일관성을 유지한다.

CAS를 이용한 잠금 없는 큐 (Lock-Free Queue using CAS)

CAS(비교와 교환)를 활용한 대표적인 예로 잠금 없는 큐(Lock-Free Queue)를 들 수 있다. 잠금 없는 큐는 여러 스레드가 동시에 접근할 수 있지만, 락을 사용하지 않고 안전하게 데이터를 추가하거나 제거할 수 있는 큐다.

다음은 CAS를 이용하여 큐의 원소를 추가하는 과정의 수식 표현이다. 큐의 꼬리 포인터 $\mathbf{tail}$ 이 가리키는 노드에 새로운 노드를 추가하려면 다음과 같은 조건을 만족해야 한다.

$\text{CAS}(\mathbf{tail}, \mathbf{old\_tail}, \mathbf{new\_tail})$

여기서: - $\mathbf{tail}$ 은 현재 꼬리 포인터. - $\mathbf{old\_tail}$ 은 예상했던 꼬리 포인터의 이전 값. - $\mathbf{new\_tail}$ 은 새로운 꼬리 포인터 값이다.

이 연산이 성공하면 꼬리 포인터가 업데이트되며, 다른 스레드들은 업데이트된 꼬리 포인터를 기반으로 데이터를 추가할 수 있게 된다. 만약 실패하면, 다시 시도하여 현재 꼬리 포인터 값을 기반으로 새로운 값을 계산하게 된다.

struct Node {
    int value;
    std::atomic<Node*> next;
};

std::atomic<Node*> tail;

void enqueue(int value) {
    Node* new_node = new Node{value, nullptr};
    Node* old_tail = tail.load();
    while (!tail.compare_exchange_weak(old_tail, new_node)) {
        // 다른 스레드가 tail을 변경했을 경우, 다시 시도
    }
}

이러한 방식으로 락을 사용하지 않으면서도 큐에 안전하게 원소를 추가할 수 있다. 이 방법은 락을 사용하는 것보다 성능이 훨씬 뛰어나며, 특히 많은 스레드가 동시에 데이터를 처리할 때 유리하다.

부하 분산 및 성능 최적화 (Load Balancing and Performance Optimization)

멀티스레드 환경에서 성능을 극대화하려면 부하 분산(Load Balancing)이 매우 중요하다. 모든 스레드가 균등하게 작업을 처리하지 않으면 특정 스레드에 과도한 부하가 걸릴 수 있으며, 이는 성능 저하로 이어질 수 있다. 부하 분산은 주로 다음과 같은 두 가지 방법으로 이루어진다.

정적 부하 분산: 작업을 미리 균등하게 나눠서 각 스레드에 할당하는 방식.
동적 부하 분산: 실행 중에 각 스레드의 부하 상태를 확인하고, 작업을 실시간으로 재할당하는 방식.

스레드 풀(Thread Pool)

부하 분산과 관련하여 많이 사용하는 개념이 스레드 풀(Thread Pool)이다. 스레드 풀은 미리 생성된 스레드 집합으로, 각 스레드가 대기 상태에 있다가 새로운 작업이 들어오면 이를 할당받아 처리하는 구조다. 스레드 풀을 이용하면 스레드 생성 및 소멸에 드는 오버헤드를 줄일 수 있으며, 작업을 효율적으로 처리할 수 있다.

std::vector<std::thread> thread_pool;
std::queue<std::function<void()>> tasks;

void thread_function() {
    while (true) {
        std::function<void()> task;
        // 작업을 가져와 실행
    }
}

스레드 풀을 통해 각 작업이 균등하게 분배되도록 하고, 스레드가 최적화된 방식으로 작업을 처리할 수 있게 된다.

Strand를 이용한 동기화 (Synchronization with Strand)

Strand는 Boost.Asio에서 제공하는 동기화 메커니즘으로, 멀티스레드 환경에서 데드락(Deadlock)이나 경쟁 상태(Race Condition) 없이 비동기 작업을 안전하게 처리할 수 있도록 해준다. Strand는 한 번에 하나의 작업만이 실행되도록 보장하며, 이를 통해 데이터 경합을 방지할 수 있다.

Strand의 개념은 스레드 간의 락을 사용하지 않고도 안전하게 비동기 작업을 순차적으로 처리할 수 있다는 점에서 매우 유용하다. 이는 특히 네트워크 프로그래밍에서 여러 비동기 작업이 동시에 실행될 때 데이터 일관성을 보장하는 데 도움을 준다.

Strand의 동작 원리

Strand는 내부적으로 작업을 FIFO(First In, First Out) 순서대로 처리하여, 여러 작업이 동시에 실행되지 않도록 보장한다. 이때 Boost.Asio는 스레드 간의 락을 사용하지 않고도 Strand가 큐에 있는 작업을 하나씩 처리하게 된다.

Strand의 동작을 수식적으로 표현하면, 주어진 두 작업 $T_1$ 과 $T_2$ 가 있을 때, 다음 조건이 성립한다.

$T_1 \text{ 실행 시 } T_2 \text{ 는 반드시 } T_1 \text{ 의 완료 이후에 실행된다.}$

즉, 두 작업이 겹치지 않고 순차적으로 실행되므로, Strand를 사용하면 스레드 간의 동기화 문제를 해결할 수 있다.

Strand의 사용 예

Strand를 사용하여 여러 비동기 작업을 안전하게 처리하는 방법은 다음과 같다. 다음 코드 예시에서는 두 개의 비동기 작업을 Strand를 통해 안전하게 실행하고 있다.

boost::asio::io_service io_service;
boost::asio::strand strand(io_service);

void async_task1() {
    // 비동기 작업 1
}

void async_task2() {
    // 비동기 작업 2
}

strand.post(async_task1);
strand.post(async_task2);

io_service.run();

위 코드에서 async_task1과 async_task2는 Strand에 의해 순차적으로 실행되며, 두 작업이 동시에 실행되지 않도록 보장된다. 이는 데이터 경합 문제를 예방하고, 복잡한 동기화 메커니즘을 사용하지 않도록 한다.

스레드 풀과 Strand의 결합

Strand는 스레드 풀(Thread Pool)과 함께 사용될 때 더욱 유용하다. 여러 스레드가 동일한 데이터를 처리해야 할 때, Strand를 통해 동기화 문제를 해결하면서 동시에 스레드 풀의 장점을 이용해 성능을 극대화할 수 있다.

스레드 풀 내에서 각 스레드가 Strand를 사용하여 동기화된 작업을 처리하는 방식은 다음과 같다.

boost::asio::io_service io_service;
boost::asio::strand strand(io_service);

std::vector<std::thread> thread_pool;

for (int i = 0; i < num_threads; ++i) {
    thread_pool.emplace_back([&io_service]{
        io_service.run();
    });
}

strand.post(async_task1);
strand.post(async_task2);

for (auto& thread : thread_pool) {
    thread.join();
}

이 구조에서 각 스레드는 Strand를 통해 동기화된 작업을 받아서 처리하며, 데이터 일관성이 유지된다. 즉, 여러 작업이 동시에 실행될 수는 있지만, 동일한 Strand 내에서는 한 번에 하나의 작업만이 실행되므로 데이터 경합을 방지할 수 있다.

메모리 순서와 잠금 없는 데이터 구조 (Memory Ordering and Lock-Free Data Structures)

메모리 순서(Memory Ordering)는 스레드 간의 데이터 공유에서 중요한 역할을 한다. 앞서 언급한 바와 같이, 현대 CPU는 성능 최적화를 위해 명령어의 실행 순서를 변경할 수 있다. 이러한 동작이 스레드 간의 동기화에 문제를 일으키지 않으려면, 적절한 메모리 순서 제어가 필요하다.

C++11 이후로, 표준 라이브러리에서는 다양한 메모리 순서 지정 방법을 제공한다. 대표적인 메모리 순서는 다음과 같다.

memory_order_relaxed: 메모리 순서를 제어하지 않으며, 성능 최적화에 중점을 둔다.
memory_order_acquire: 이후의 모든 읽기 연산이 이전의 쓰기 연산이 완료된 후에 실행되도록 보장한다.
memory_order_release: 이전의 모든 쓰기 연산이 이후의 읽기 연산 전에 완료되도록 보장한다.
memory_order_seq_cst: 순차 일관성을 보장하며, 모든 스레드에서 동일한 순서로 메모리 연산을 관찰할 수 있다.

다음은 잠금 없는 큐에서 memory_order를 사용하는 예시다.

std::atomic<int> counter(0);

void increment() {
    counter.fetch_add(1, std::memory_order_relaxed);
}

위 코드에서는 memory_order_relaxed를 사용하여 메모리 순서를 제어하지 않고, 성능을 극대화하는 방식으로 원자적 증가 연산을 수행하고 있다.

메모리 순서를 적절히 사용하면 성능과 동기화의 균형을 맞출 수 있으며, 특히 잠금 없는 데이터 구조에서 이러한 기법을 적용하면 효율적으로 스레드 간의 데이터 공유가 가능하다.

비동기 작업과 오류 처리 (Error Handling in Asynchronous Operations)

멀티스레드 비동기 프로그래밍에서는 오류 처리가 매우 중요한 요소다. 비동기 작업 중에 발생할 수 있는 오류를 적절히 처리하지 않으면, 스레드 간의 데이터 일관성 문제뿐만 아니라 시스템 전체의 안정성에도 영향을 미칠 수 있다.

Boost.Asio에서는 비동기 작업에서 발생한 오류를 콜백 함수 내에서 처리할 수 있도록 설계되어 있다. 오류 처리는 주로 boost::system::error_code를 사용하여 수행된다.

다음은 비동기 작업에서 오류를 처리하는 예시다.

void async_task(const boost::system::error_code& ec) {
    if (!ec) {
        // 정상적인 작업 처리
    } else {
        // 오류 처리
        std::cerr << "Error: " << ec.message() << std::endl;
    }
}

잠금 없는 동기화 기법 (Lock-Free Synchronization Techniques)

스레드 간의 데이터 공유에서 동기화 문제를 해결하기 위해 락-프리(Lock-Free) 기법을 사용할 수 있다. 락-프리 기법은 잠금을 사용하지 않고도 안전하게 데이터를 공유하는 방법으로, 여러 스레드가 동시에 작업을 수행할 때 성능을 극대화할 수 있다.

대표적인 락-프리 기법으로는 CAS(Compare-and-Swap), Futures/Promises, 그리고 Atomic Operations를 들 수 있다.

CAS를 이용한 락-프리 스택

CAS(비교와 교환)를 이용하여 락-프리 스택을 구현할 수 있다. CAS는 다음과 같은 방식으로 동작한다.

$\text{CAS}(\mathbf{V}, \mathbf{expected}, \mathbf{new}) = \begin{cases} \mathbf{V} = \mathbf{new}, & \text{if } \mathbf{V} = \mathbf{expected} \\ \text{false}, & \text{otherwise} \end{cases}$

여기서: - $\mathbf{V}$ 는 변수의 현재 값. - $\mathbf{expected}$ 는 예상된 값. - $\mathbf{new}$ 는 새로운 값이다.

CAS 연산은 한 번에 실행되며, 다른 스레드의 개입 없이 안전하게 값을 업데이트할 수 있다. 이를 통해 락을 사용하지 않고도 스레드 간의 동기화를 처리할 수 있다.

struct Node {
    int value;
    std::atomic<Node*> next;
};

std::atomic<Node*> head;

void push(int value) {
    Node* new_node = new Node{value, nullptr};
    new_node->next = head.load();
    while (!head.compare_exchange_weak(new_node->next, new_node)) {
        // CAS 실패 시 재시도
    }
}

이와 같은 방식으로 락-프리 스택을 구현하면, 여러 스레드가 동시에 스택에 데이터를 추가할 때도 안전하게 처리할 수 있다.