MENU
  1. ホーム
  2. C 언어
  3. C언어에서 멀티스레딩과 메모리 정합성 문제 해결

C언어에서 멀티스레딩과 메모리 정합성 문제 해결

C 언어

멀티스레딩은 C언어에서 복잡한 작업을 병렬로 처리하기 위해 널리 활용됩니다. 하지만 여러 스레드가 동일한 메모리 자원을 공유할 때 발생하는 정합성 문제는 디버깅을 어렵게 하고 프로그램의 안정성을 저하시킬 수 있습니다. 본 기사에서는 멀티스레딩의 기본 개념부터 메모리 정합성 문제의 원인과 이를 해결하기 위한 실질적인 방법까지 다룹니다. C언어로 안정적이고 효율적인 병렬 프로그램을 작성하려는 개발자들에게 유용한 정보를 제공합니다.

목차
  1. 멀티스레딩의 개념과 중요성
    1. 멀티스레딩이란?
    2. 멀티스레딩의 장점
    3. 사용 사례
  2. 메모리 정합성이란?
    1. 메모리 정합성의 정의
    2. 정합성 문제가 발생하는 이유
    3. 예제 시나리오
    4. 정합성 문제의 영향
  3. C언어에서 멀티스레딩을 구현하는 방법
    1. 스레드 생성과 종료
    2. 스레드 동기화
    3. 다중 스레드 관리
    4. 스레드 종료와 자원 관리
  4. 메모리 정합성 문제의 원인
    1. 1. 데이터 경합
    2. 2. 캐시 불일치
    3. 3. 메모리 가시성 문제
    4. 4. 명령 재배치
    5. 5. 동기화 부족
    6. 영향
  5. 정합성 문제 해결 방법
    1. 1. 뮤텍스(Mutex) 사용
    2. 2. 세마포어(Semaphore) 사용
    3. 3. 메모리 배리어(Memory Barrier)
    4. 4. C11 표준의 `_Atomic` 키워드 사용
    5. 5. 조건 변수(Condition Variable) 사용
    6. 6. 문제 해결의 종합적 접근
  6. 메모리 정합성과 C11 표준
    1. C11의 메모리 모델
    2. _Atomic 키워드
    3. 스레드 기능 추가
    4. Fence와 Memory Barriers
    5. 장점
  7. 문제 해결 응용 예시
    1. 경합 조건 문제 해결
    2. 명령 재배치 문제 해결
    3. 조건 변수 활용
  8. 요약

멀티스레딩의 개념과 중요성


멀티스레딩은 하나의 프로세스 내에서 여러 스레드가 동시에 실행되도록 하는 기술입니다. 이는 CPU 코어를 효율적으로 활용하여 성능을 극대화할 수 있게 합니다.

멀티스레딩이란?


멀티스레딩은 프로세스 내에서 실행되는 독립적인 코드 경로(스레드)를 의미합니다. 각 스레드는 메모리 공간을 공유하며 병렬로 작업을 수행합니다.

멀티스레딩의 장점

  • 성능 향상: CPU의 멀티코어 구조를 활용하여 처리 속도를 높입니다.
  • 응답성 개선: 사용자 인터페이스 프로그램에서 백그라운드 작업을 처리하여 응답성을 유지합니다.
  • 리소스 공유: 스레드 간 메모리와 자원을 공유하여 효율적인 작업 수행이 가능합니다.

사용 사례


멀티스레딩은 다음과 같은 분야에서 널리 사용됩니다.

  • 대규모 데이터 처리(예: 파일 읽기/쓰기)
  • 네트워크 서버(동시 연결 처리)
  • 게임 엔진(그래픽 처리와 물리 연산 분리)

멀티스레딩의 적절한 사용은 소프트웨어의 성능을 비약적으로 향상시킬 수 있지만, 메모리 정합성 문제를 포함한 여러 문제를 동반할 수 있습니다. 따라서 이를 이해하고 관리하는 것이 중요합니다.

메모리 정합성이란?


메모리 정합성(memory consistency)은 멀티스레딩 환경에서 여러 스레드가 공유 메모리를 읽고 쓸 때 데이터가 예상한 대로 일관성을 유지하는 것을 의미합니다.

메모리 정합성의 정의


메모리 정합성은 프로그램의 동작이 스레드 간에 일관되게 보장되는 속성입니다. 이를 통해 여러 스레드가 동일한 변수에 접근할 때, 수정된 값이 즉시 다른 스레드에도 반영되도록 합니다.

정합성 문제가 발생하는 이유


멀티스레딩 환경에서는 다음과 같은 이유로 정합성 문제가 발생할 수 있습니다.

  • 캐시 불일치: 각 스레드는 CPU 코어의 캐시를 활용하며, 메모리 변경 사항이 다른 캐시에 반영되지 않을 수 있습니다.
  • 명령 재배치: 컴파일러와 프로세서가 성능 최적화를 위해 명령 실행 순서를 재배치하는 경우.
  • 동기화 부족: 공유 자원에 대한 적절한 동기화 메커니즘 없이 접근하는 경우.

예제 시나리오


아래는 메모리 정합성 문제의 예를 보여줍니다.

#include <pthread.h>
#include <stdio.h>

int shared_var = 0;
void* thread_func(void* arg) {
    shared_var = 1;  // 쓰기
    return NULL;
}

int main() {
    pthread_t t1;
    pthread_create(&t1, NULL, thread_func, NULL);
    // 다른 스레드에서 shared_var을 읽음
    printf("Shared Variable: %d\n", shared_var);
    pthread_join(t1, NULL);
    return 0;
}

위 코드는 예상치 못한 출력을 생성할 수 있습니다. 이유는 shared_var에 대한 쓰기와 읽기가 적절히 동기화되지 않았기 때문입니다.

정합성 문제의 영향

  • 데이터 손실: 일부 업데이트가 반영되지 않아 잘못된 결과를 초래할 수 있습니다.
  • 예측 불가능한 동작: 실행 환경에 따라 결과가 달라질 수 있습니다.

메모리 정합성 문제를 방지하기 위해 동기화 메커니즘의 적절한 사용이 필수적입니다.

C언어에서 멀티스레딩을 구현하는 방법


C언어에서 멀티스레딩은 주로 POSIX 스레드(pthread) 라이브러리를 사용하여 구현됩니다. 이는 다양한 운영체제에서 멀티스레딩을 지원하는 표준 API입니다.

스레드 생성과 종료


스레드를 생성하려면 pthread_create 함수를 사용하며, 스레드 종료는 pthread_join으로 처리합니다.
아래는 간단한 예제입니다.

#include <pthread.h>
#include <stdio.h>

void* print_message(void* arg) {
    printf("Hello from thread!\n");
    return NULL;
}

int main() {
    pthread_t thread;
    // 스레드 생성
    pthread_create(&thread, NULL, print_message, NULL);
    // 스레드 종료 대기
    pthread_join(thread, NULL);
    return 0;
}

위 코드는 새로운 스레드를 생성하여 “Hello from thread!” 메시지를 출력합니다.

스레드 동기화


멀티스레딩 환경에서는 동기화가 필수입니다. 대표적인 동기화 메커니즘은 다음과 같습니다.

  • 뮤텍스(mutex): 공유 자원에 대한 동시 접근을 방지합니다.
  • 세마포어(semaphore): 제한된 리소스의 접근을 제어합니다.
  • 조건 변수(condition variable): 특정 조건에서 스레드를 대기시키거나 깨웁니다.

뮤텍스 사용 예시

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t lock;  // 뮤텍스 선언
int shared_data = 0;

void* increment_data(void* arg) {
    pthread_mutex_lock(&lock);  // 뮤텍스 잠금
    shared_data++;
    printf("Shared Data: %d\n", shared_data);
    pthread_mutex_unlock(&lock);  // 뮤텍스 잠금 해제
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&lock, NULL);  // 뮤텍스 초기화

    pthread_create(&t1, NULL, increment_data, NULL);
    pthread_create(&t2, NULL, increment_data, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    pthread_mutex_destroy(&lock);  // 뮤텍스 소멸
    return 0;
}

이 코드는 뮤텍스를 사용하여 shared_data에 대한 동시 접근을 방지합니다.

다중 스레드 관리


여러 개의 스레드를 생성하려면 pthread_t 배열을 사용하여 각 스레드를 관리할 수 있습니다.

pthread_t threads[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
    pthread_create(&threads[i], NULL, thread_function, (void*)&data[i]);
}

스레드 종료와 자원 관리


스레드가 사용한 자원을 적절히 정리하지 않으면 메모리 누수가 발생할 수 있습니다.

  • pthread_join을 사용하여 스레드의 종료를 대기합니다.
  • pthread_mutex_destroy와 같은 함수를 사용하여 동기화 도구를 해제합니다.

C언어에서 멀티스레딩을 구현할 때는 효율적인 스레드 관리와 적절한 동기화가 안정적인 프로그램 개발의 핵심입니다.

메모리 정합성 문제의 원인


멀티스레딩 환경에서는 여러 스레드가 공유 메모리를 동시에 읽거나 쓰는 과정에서 예상치 못한 결과가 발생할 수 있습니다. 이러한 메모리 정합성 문제는 프로그램의 안정성과 신뢰성을 저해하는 주요 요인입니다.

1. 데이터 경합


여러 스레드가 동일한 메모리 위치에 동시에 접근할 때 발생하는 충돌 현상입니다.

  • 경합 조건(Race Condition): 특정 작업 순서가 보장되지 않아 결과가 비결정적일 때 발생합니다.
  • 예: 두 스레드가 같은 변수의 값을 증가시키려 할 때, 중간 작업이 겹치면 예상보다 낮은 값으로 설정될 수 있습니다.
shared_var++;  // 경합이 발생할 가능성이 있음

2. 캐시 불일치


멀티코어 프로세서에서는 각 코어가 고유의 캐시를 보유하고 있습니다. 스레드가 공유 변수를 수정하면 다른 코어의 캐시가 즉시 업데이트되지 않아 정합성이 깨질 수 있습니다.

  • 예: 한 스레드가 값을 변경했지만 다른 스레드가 이전 값을 읽는 경우.
  • 이를 방지하려면 메모리 동기화 명령어(예: memory barriers)를 사용해야 합니다.

3. 메모리 가시성 문제


한 스레드가 변경한 메모리 값이 다른 스레드에 즉시 보이지 않을 수 있습니다.

  • 지연 쓰기(Lazy Write): 값이 실제 메모리에 반영되기 전에 CPU 레지스터나 캐시에만 유지되는 경우.
  • 해결책: volatile 키워드 또는 동기화 도구를 사용해 값이 항상 메모리에서 읽히도록 강제.

4. 명령 재배치


컴파일러나 CPU는 성능 최적화를 위해 명령의 실행 순서를 변경할 수 있습니다. 이로 인해 코드가 논리적으로 예상한 순서대로 실행되지 않을 수 있습니다.

  • 예:
ready = true;
data = 42;  // 명령 재배치가 발생하면 예상 동작이 깨질 수 있음
  • 해결책: memory fences 또는 C11 표준의 _Atomic 변수 사용.

5. 동기화 부족


공유 자원에 접근할 때 동기화가 제대로 이루어지지 않으면 예상치 못한 결과가 발생합니다.

  • 예: 뮤텍스 또는 세마포어를 사용하지 않고 공유 변수에 접근하는 경우.
  • 문제: 데이터 경합, 불완전한 데이터 상태.

영향


메모리 정합성 문제가 발생하면 다음과 같은 문제가 나타납니다.

  • 프로그램 충돌
  • 데이터 손실
  • 비결정적 동작

메모리 정합성 문제를 방지하려면 철저한 동기화와 적절한 메모리 모델 이해가 필요합니다. 이를 통해 멀티스레딩 환경에서도 신뢰성 높은 프로그램을 작성할 수 있습니다.

정합성 문제 해결 방법


메모리 정합성 문제를 해결하기 위해 다양한 동기화 메커니즘과 프로그래밍 기법을 사용할 수 있습니다. 이러한 방법은 데이터의 일관성을 유지하고, 멀티스레딩 환경에서 안정적인 동작을 보장하는 데 필수적입니다.

1. 뮤텍스(Mutex) 사용


뮤텍스는 상호 배제를 통해 여러 스레드가 동시에 공유 자원에 접근하지 못하도록 합니다.

  • 사용법:
pthread_mutex_t lock;
pthread_mutex_init(&lock, NULL);  // 뮤텍스 초기화

pthread_mutex_lock(&lock);  // 자원 잠금
// 공유 자원 접근
pthread_mutex_unlock(&lock);  // 자원 해제

pthread_mutex_destroy(&lock);  // 뮤텍스 제거
  • 장점: 간단하고 효과적.
  • 단점: 잘못된 사용 시 데드락 발생 가능.

2. 세마포어(Semaphore) 사용


세마포어는 리소스의 접근 가능 수를 제한하며, 제한된 자원 공유에 적합합니다.

  • 사용법:
#include <semaphore.h>
sem_t semaphore;
sem_init(&semaphore, 0, 1);  // 초기화

sem_wait(&semaphore);  // 자원 사용 시작
// 공유 자원 접근
sem_post(&semaphore);  // 자원 사용 종료

sem_destroy(&semaphore);  // 세마포어 제거
  • 장점: 복수의 스레드가 자원을 제한적으로 접근 가능.

3. 메모리 배리어(Memory Barrier)


메모리 배리어는 명령 실행 순서를 제어하여 CPU와 컴파일러의 최적화로 인한 명령 재배치를 방지합니다.

  • 사용법:
    C11 표준에서 atomic_thread_fence를 사용해 메모리 배리어를 구현합니다.
#include <stdatomic.h>
atomic_thread_fence(memory_order_acquire);
  • 적용 사례: 메모리 쓰기 순서와 읽기 순서를 보장할 때 사용.

4. C11 표준의 `_Atomic` 키워드 사용


C11 표준은 원자적 연산을 제공하는 _Atomic 키워드를 도입하여 동기화 문제를 간단히 해결합니다.

  • 사용법:
#include <stdatomic.h>
_Atomic int shared_var = 0;

atomic_store(&shared_var, 1);  // 값 쓰기
int value = atomic_load(&shared_var);  // 값 읽기
  • 장점: 명령 재배치 방지 및 자동 메모리 동기화.

5. 조건 변수(Condition Variable) 사용


조건 변수는 특정 조건이 충족될 때까지 스레드를 대기시키는 동기화 도구입니다.

  • 사용법:
pthread_mutex_t lock;
pthread_cond_t cond;

pthread_mutex_lock(&lock);
pthread_cond_wait(&cond, &lock);  // 조건 대기
pthread_mutex_unlock(&lock);

pthread_cond_signal(&cond);  // 조건 발생 알림
  • 적용 사례: 스레드 간 이벤트 동기화.

6. 문제 해결의 종합적 접근

  • 동기화 메커니즘 결합: 뮤텍스와 조건 변수를 함께 사용해 정교한 동기화 구현.
  • 코드 리뷰 및 테스트: 동시성 문제를 사전에 식별.
  • 경량 동기화 사용: 필요할 때만 동기화 적용으로 성능 최적화.

이러한 해결 방법을 적절히 사용하면 C언어에서 멀티스레딩 환경의 메모리 정합성 문제를 효과적으로 관리할 수 있습니다.

메모리 정합성과 C11 표준


C언어의 C11 표준은 멀티스레딩 환경에서 메모리 정합성을 보장하기 위해 새로운 기능과 메모리 모델을 도입했습니다. 이러한 도구들은 동기화 문제를 해결하고, 개발자가 안전하고 효율적인 코드를 작성할 수 있도록 지원합니다.

C11의 메모리 모델


C11은 메모리 정합성을 관리하기 위해 명시적인 메모리 모델을 제공합니다. 이를 통해 다양한 메모리 순서를 제어할 수 있습니다.

  • 메모리 순서 유형:
  • memory_order_relaxed: 최소한의 동기화만 수행, 성능 중심.
  • memory_order_acquire: 읽기 동작의 순서를 보장.
  • memory_order_release: 쓰기 동작의 순서를 보장.
  • memory_order_acq_rel: 읽기 및 쓰기 동작의 순서를 모두 보장.
  • memory_order_seq_cst: 가장 강력한 동기화, 순차적 일관성을 유지.

_Atomic 키워드


C11은 _Atomic 키워드를 도입하여 원자적 변수를 선언할 수 있습니다. 이를 통해 경합 조건을 방지하고, 정합성을 보장할 수 있습니다.

  • 사용법:
#include <stdatomic.h>

_Atomic int shared_var = 0;

// 원자적 쓰기
atomic_store(&shared_var, 42);

// 원자적 읽기
int value = atomic_load(&shared_var);
  • _Atomic 변수는 컴파일러와 프로세서가 자동으로 동기화를 처리하므로 동기화 문제를 줄일 수 있습니다.

스레드 기능 추가


C11 표준은 스레드 생성을 위한 thread.h 라이브러리를 포함합니다.

  • thrd_create와 thrd_join을 사용해 스레드를 생성하고 관리할 수 있습니다.
  • 예:
#include <threads.h>
#include <stdio.h>

int thread_func(void* arg) {
    printf("Hello from thread!\n");
    return 0;
}

int main() {
    thrd_t t;
    thrd_create(&t, thread_func, NULL);
    thrd_join(t, NULL);
    return 0;
}

Fence와 Memory Barriers


C11 표준은 메모리 장벽을 통해 명령 재배치를 방지합니다.

  • Memory Fences:
  • atomic_thread_fence(memory_order_seq_cst)를 사용하여 코드의 동기화를 강제.
  • 사용 예:
    c atomic_thread_fence(memory_order_acquire); // 읽기 동기화 atomic_thread_fence(memory_order_release); // 쓰기 동기화

장점

  • 표준화된 방식으로 동기화 문제 해결.
  • 복잡한 동기화 메커니즘의 필요성 감소.
  • 성능 최적화와 코드 가독성 향상.

C11 표준은 멀티스레딩과 메모리 정합성을 보다 쉽게 다룰 수 있도록 강력한 도구를 제공하며, 이를 활용하면 고성능 멀티스레드 애플리케이션을 보다 안정적으로 개발할 수 있습니다.

문제 해결 응용 예시


멀티스레딩 환경에서 메모리 정합성 문제를 해결하는 실질적인 방법을 코드 예제를 통해 알아봅니다. 아래 예제는 C11 표준과 동기화 메커니즘을 활용하여 문제를 해결하는 사례를 보여줍니다.

경합 조건 문제 해결


두 개의 스레드가 동일한 변수에 동시에 접근하여 값을 증가시키는 상황을 살펴봅니다.

#include <stdio.h>
#include <pthread.h>

#define NUM_ITERATIONS 1000000

int shared_counter = 0;
pthread_mutex_t lock;

void* increment_counter(void* arg) {
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        pthread_mutex_lock(&lock);  // 뮤텍스 잠금
        shared_counter++;
        pthread_mutex_unlock(&lock);  // 뮤텍스 잠금 해제
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    pthread_mutex_init(&lock, NULL);  // 뮤텍스 초기화

    pthread_create(&thread1, NULL, increment_counter, NULL);
    pthread_create(&thread2, NULL, increment_counter, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    pthread_mutex_destroy(&lock);  // 뮤텍스 제거

    printf("Final Counter Value: %d\n", shared_counter);
    return 0;
}
  • 문제: 동시 접근으로 인해 shared_counter 값이 올바르게 증가하지 않을 수 있습니다.
  • 해결책: 뮤텍스를 사용하여 한 번에 하나의 스레드만 shared_counter에 접근하도록 제한합니다.

명령 재배치 문제 해결


C11 표준의 메모리 모델을 사용하여 명령 재배치로 인한 문제를 방지합니다.

#include <stdatomic.h>
#include <stdio.h>
#include <pthread.h>

_Atomic int ready = 0;
int data = 0;

void* writer_thread(void* arg) {
    data = 42;
    atomic_store(&ready, 1);  // ready 값을 원자적으로 변경
    return NULL;
}

void* reader_thread(void* arg) {
    while (atomic_load(&ready) == 0);  // ready 값이 변경될 때까지 대기
    printf("Data: %d\n", data);  // data의 최신 값을 읽음
    return NULL;
}

int main() {
    pthread_t writer, reader;

    pthread_create(&writer, NULL, writer_thread, NULL);
    pthread_create(&reader, NULL, reader_thread, NULL);

    pthread_join(writer, NULL);
    pthread_join(reader, NULL);

    return 0;
}
  • 문제: 명령 재배치로 인해 ready 값이 업데이트되기 전에 data를 읽을 수 있습니다.
  • 해결책: _Atomic과 atomic_store/atomic_load를 사용하여 메모리 순서를 보장합니다.

조건 변수 활용


조건 변수를 사용해 생산자-소비자 문제를 해결하는 방법입니다.

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

pthread_mutex_t lock;
pthread_cond_t cond;
int data_ready = 0;

void* producer(void* arg) {
    sleep(1);  // 데이터를 준비하는 데 시간이 걸린다고 가정
    pthread_mutex_lock(&lock);
    data_ready = 1;
    printf("Producer: Data is ready.\n");
    pthread_cond_signal(&cond);  // 소비자에게 알림
    pthread_mutex_unlock(&lock);
    return NULL;
}

void* consumer(void* arg) {
    pthread_mutex_lock(&lock);
    while (!data_ready) {
        pthread_cond_wait(&cond, &lock);  // 데이터 준비 완료 대기
    }
    printf("Consumer: Consuming data.\n");
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t prod, cons;

    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);

    pthread_join(prod, NULL);
    pthread_join(cons, NULL);

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);

    return 0;
}
  • 문제: 소비자가 데이터가 준비되기 전에 작업을 시도할 수 있음.
  • 해결책: 조건 변수와 뮤텍스를 사용해 데이터 준비 상태를 동기화합니다.

이러한 응용 예제는 실제 개발 환경에서 발생할 수 있는 멀티스레딩 및 메모리 정합성 문제를 예방하고 해결하는 데 유용합니다.

요약


C언어에서 멀티스레딩과 메모리 정합성 문제는 프로그램의 안정성과 성능에 큰 영향을 미칩니다. 본 기사에서는 멀티스레딩의 기본 개념부터 메모리 정합성 문제의 원인, 동기화 메커니즘, C11 표준의 활용법, 그리고 실제 코드 응용 사례까지 다루었습니다.

뮤텍스, 세마포어, 조건 변수, _Atomic 키워드, 메모리 배리어 등의 도구를 사용하여 정합성을 보장하고 경합 조건 및 명령 재배치 문제를 해결할 수 있습니다. 이를 통해 멀티스레딩 환경에서도 안정적이고 신뢰할 수 있는 프로그램을 개발할 수 있습니다.

C 언어
C언어 멀티스레딩 메모리 정합성
목차
  1. 멀티스레딩의 개념과 중요성
    1. 멀티스레딩이란?
    2. 멀티스레딩의 장점
    3. 사용 사례
  2. 메모리 정합성이란?
    1. 메모리 정합성의 정의
    2. 정합성 문제가 발생하는 이유
    3. 예제 시나리오
    4. 정합성 문제의 영향
  3. C언어에서 멀티스레딩을 구현하는 방법
    1. 스레드 생성과 종료
    2. 스레드 동기화
    3. 다중 스레드 관리
    4. 스레드 종료와 자원 관리
  4. 메모리 정합성 문제의 원인
    1. 1. 데이터 경합
    2. 2. 캐시 불일치
    3. 3. 메모리 가시성 문제
    4. 4. 명령 재배치
    5. 5. 동기화 부족
    6. 영향
  5. 정합성 문제 해결 방법
    1. 1. 뮤텍스(Mutex) 사용
    2. 2. 세마포어(Semaphore) 사용
    3. 3. 메모리 배리어(Memory Barrier)
    4. 4. C11 표준의 `_Atomic` 키워드 사용
    5. 5. 조건 변수(Condition Variable) 사용
    6. 6. 문제 해결의 종합적 접근
  6. 메모리 정합성과 C11 표준
    1. C11의 메모리 모델
    2. _Atomic 키워드
    3. 스레드 기능 추가
    4. Fence와 Memory Barriers
    5. 장점
  7. 문제 해결 응용 예시
    1. 경합 조건 문제 해결
    2. 명령 재배치 문제 해결
    3. 조건 변수 활용
  8. 요약