MENU
  1. ホーム
  2. C 언어
  3. C 언어에서 세마포어와 컴플리션 활용법: 동기화의 핵심 이해

C 언어에서 세마포어와 컴플리션 활용법: 동기화의 핵심 이해

C 언어

멀티스레드 환경에서 동기화는 필수 요소입니다. C 언어에서는 세마포어와 컴플리션과 같은 동기화 프리미티브를 제공하여, 데이터 무결성과 스레드 안전성을 보장합니다. 본 기사에서는 이 두 가지 동기화 도구의 원리, 구현 방법, 그리고 실제 활용 사례를 다루어 멀티스레드 프로그래밍의 필수적인 지식을 제공합니다.

목차
  1. 동기화란 무엇인가
    1. 동기화의 필요성
    2. 예시 상황
  2. 세마포어의 기본 개념
    1. 세마포어의 정의
    2. 세마포어의 주요 작업
    3. 세마포어의 역할
  3. 세마포어의 구현 및 사용법
    1. 세마포어 초기화
    2. 세마포어 사용: Wait와 Signal
    3. 출력 예시
    4. 세마포어 사용 시 주의점
  4. 컴플리션의 기본 개념
    1. 컴플리션의 정의
    2. 컴플리션의 주요 역할
    3. 컴플리션의 일반적인 사용 사례
    4. 예시
  5. 컴플리션의 구현 및 사용법
    1. 컴플리션 구현: 조건 변수와 뮤텍스
    2. 코드 예제: 간단한 컴플리션 구현
    3. 출력 예시
    4. 구현 설명
    5. 컴플리션 사용 시 유의점
  6. 세마포어와 컴플리션의 차이점
    1. 세마포어
    2. 컴플리션
    3. 세마포어와 컴플리션의 주요 차이
    4. 적합한 선택 기준
  7. 동기화 문제 해결 전략
    1. 교착 상태(Deadlock)
    2. 경쟁 조건(Race Condition)
    3. 자원 누수(Resource Starvation)
    4. 부적절한 동기화
    5. 요약
  8. 응용 예시: 실제 프로젝트에서의 동기화
    1. 사례 1: 서버의 연결 요청 처리
    2. 사례 2: 데이터 처리 파이프라인
    3. 사례 3: 병렬 작업의 결과 통합
    4. 결론
  9. 요약

동기화란 무엇인가


멀티스레드 프로그래밍에서 동기화는 여러 스레드가 동시에 동일한 리소스에 접근하거나 작업을 수행할 때 발생할 수 있는 충돌을 방지하는 메커니즘입니다. 동기화는 데이터 무결성을 유지하고, 스레드 간 협력과 조율을 가능하게 합니다.

동기화의 필요성

  • 데이터 무결성 보장: 공유 데이터에 대한 동시 접근으로 인해 발생하는 오류를 방지합니다.
  • 교착 상태 회피: 자원 할당 시 스레드 간 충돌로 인한 정체를 예방합니다.
  • 작업 조율: 특정 작업이 다른 작업보다 먼저 실행되도록 순서를 제어합니다.

예시 상황


예를 들어, 은행의 잔고를 처리하는 시스템에서 여러 스레드가 동일한 계좌에 동시에 접근할 경우, 동기화가 없으면 데이터가 손상될 수 있습니다. 동기화는 이런 문제를 해결하기 위해 필수적입니다.

세마포어의 기본 개념


세마포어(Semaphore)는 멀티스레드 환경에서 동기화를 구현하기 위해 사용되는 기본적인 동기화 프리미티브입니다. 주로 스레드가 공유 리소스에 접근할 수 있는 권한을 관리하고, 여러 스레드 간의 협력을 조율하는 데 사용됩니다.

세마포어의 정의


세마포어는 정수 값으로 표현되는 카운터를 기반으로 작동하며, 이를 통해 리소스에 접근할 수 있는 스레드의 수를 제한합니다.

  • 이진 세마포어(Binary Semaphore): 값이 0 또는 1로 제한되며, 뮤텍스(Mutex)와 유사하게 작동합니다.
  • 계수 세마포어(Counting Semaphore): 특정 값까지 증가할 수 있어 여러 스레드의 접근을 동시에 제어합니다.

세마포어의 주요 작업

  1. Wait(잠금): 세마포어 값을 감소시키고, 값이 음수가 되면 스레드를 대기 상태로 만듭니다.
  2. Signal(해제): 세마포어 값을 증가시키며, 대기 중인 스레드가 있다면 이를 깨웁니다.

세마포어의 역할

  • 공유 리소스 관리: 데이터베이스 연결, 파일 접근 등 제한된 자원에 대해 동시 접근을 제어합니다.
  • 스레드 간 동기화: 작업 순서를 제어하거나 특정 작업이 완료될 때까지 대기하도록 설정합니다.

세마포어는 멀티스레드 환경에서 안정적이고 효율적인 동기화를 구현하기 위한 핵심 도구로 사용됩니다.

세마포어의 구현 및 사용법

C 언어에서 세마포어는 POSIX 표준을 기반으로 구현되며, <semaphore.h> 헤더 파일을 통해 제공됩니다. 세마포어를 사용하여 멀티스레드 환경에서 리소스 접근을 제어하는 방법을 아래 예제 코드와 함께 살펴보겠습니다.

세마포어 초기화


세마포어는 사용 전에 반드시 초기화되어야 합니다.

  • sem_init: 세마포어를 초기화합니다(동적 세마포어).
  • sem_destroy: 세마포어를 제거합니다.
#include <semaphore.h>

sem_t semaphore;

int main() {
    // 세마포어 초기화 (초기값 1, 공유 비활성화)
    sem_init(&semaphore, 0, 1);

    // 세마포어 사용 후 제거
    sem_destroy(&semaphore);

    return 0;
}

세마포어 사용: Wait와 Signal

  • sem_wait: 세마포어 값을 감소시켜 잠금을 설정합니다.
  • sem_post: 세마포어 값을 증가시켜 잠금을 해제합니다.

아래 예제에서는 두 스레드가 동일한 리소스에 접근할 때 세마포어를 활용하여 동기화를 구현합니다.

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

sem_t semaphore;

void* thread_function(void* arg) {
    sem_wait(&semaphore);  // 세마포어 잠금
    printf("Thread %d: Critical section\n", *(int*)arg);
    sem_post(&semaphore);  // 세마포어 해제
    return NULL;
}

int main() {
    pthread_t t1, t2;
    int id1 = 1, id2 = 2;

    sem_init(&semaphore, 0, 1);  // 세마포어 초기화

    pthread_create(&t1, NULL, thread_function, &id1);
    pthread_create(&t2, NULL, thread_function, &id2);

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

    sem_destroy(&semaphore);  // 세마포어 제거

    return 0;
}

출력 예시

Thread 1: Critical section  
Thread 2: Critical section

세마포어 사용 시 주의점

  • 교착 상태 방지: 여러 스레드가 세마포어를 서로 잠글 때 발생할 수 있는 교착 상태를 방지해야 합니다.
  • 올바른 초기값 설정: 리소스 수에 따라 적절한 초기값을 설정해야 합니다.

세마포어는 공유 리소스 접근을 제어하고 멀티스레드 프로그램의 안전성을 높이는 데 매우 유용한 도구입니다.

컴플리션의 기본 개념

컴플리션(Completion)은 멀티스레드 환경에서 작업의 완료를 추적하거나 특정 조건이 충족될 때까지 대기하도록 설계된 동기화 프리미티브입니다. 작업의 순서를 조율하거나 이벤트 기반 프로그래밍에서 주로 사용됩니다.

컴플리션의 정의


컴플리션은 특정 이벤트가 발생했음을 나타내는 신호로 사용되며, 이를 통해 한 스레드가 다른 스레드의 작업 완료를 기다릴 수 있도록 합니다. 일반적으로 작업의 완료 상태를 설정(set)하거나 확인(wait)하는 방식으로 동작합니다.

컴플리션의 주요 역할

  1. 작업 완료 확인: 특정 작업이 완료될 때까지 다른 스레드가 대기하도록 설정합니다.
  2. 이벤트 기반 동기화: 작업 완료 후 특정 동작을 실행하거나, 다음 단계로 진행하도록 제어합니다.
  3. 다중 스레드 협력: 여러 스레드가 동일한 완료 신호를 기다리거나, 특정 스레드만 작업을 이어서 진행하도록 설정할 수 있습니다.

컴플리션의 일반적인 사용 사례

  • 데이터 처리 완료 확인: 한 스레드가 데이터 처리를 완료하면 다른 스레드가 이를 확인하고 작업을 시작합니다.
  • 이벤트 드리븐(Event-driven) 시스템: 이벤트 발생 후 특정 작업을 트리거합니다.
  • 병렬 작업의 결과 통합: 병렬로 실행된 작업의 결과를 통합하거나, 작업이 모두 완료될 때까지 기다립니다.

예시


파일을 읽고 처리하는 멀티스레드 애플리케이션에서, 데이터 읽기 스레드가 완료 신호를 설정한 후 데이터 처리 스레드가 이를 기다렸다가 작업을 시작하는 구조가 대표적인 컴플리션의 활용 사례입니다.

컴플리션은 작업 완료의 명시적 신호를 통해 스레드 간의 협력을 효율적으로 관리하는 데 필수적인 도구입니다.

컴플리션의 구현 및 사용법

C 언어에서는 컴플리션과 유사한 동기화 기능을 구현하기 위해 POSIX 스레드(pthread)와 조건 변수(condition variable)를 활용합니다. 아래는 컴플리션을 구현하고 사용하는 방법을 예제와 함께 설명합니다.

컴플리션 구현: 조건 변수와 뮤텍스


조건 변수와 뮤텍스를 조합하여 컴플리션을 구현할 수 있습니다.

  • 조건 변수: 특정 조건이 충족될 때까지 대기하거나 이를 신호로 깨우는 역할을 합니다.
  • 뮤텍스: 공유 리소스에 대한 동기화와 조건 변수 사용 시 데이터 무결성을 보장합니다.

코드 예제: 간단한 컴플리션 구현


아래는 한 스레드가 작업을 완료한 후 다른 스레드가 이를 기다리는 구조를 구현한 코드입니다.

#include <stdio.h>
#include <pthread.h>
#include <unistd.h> // for sleep

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int is_completed = 0; // 작업 완료 상태 플래그

void* worker_thread(void* arg) {
    printf("Worker: 작업을 시작합니다.\n");
    sleep(2); // 작업 시뮬레이션
    pthread_mutex_lock(&mutex);
    is_completed = 1; // 작업 완료 상태 설정
    pthread_cond_signal(&cond); // 완료 신호 전송
    pthread_mutex_unlock(&mutex);
    printf("Worker: 작업을 완료했습니다.\n");
    return NULL;
}

void* waiting_thread(void* arg) {
    pthread_mutex_lock(&mutex);
    while (!is_completed) { // 작업 완료를 기다림
        pthread_cond_wait(&cond, &mutex);
    }
    pthread_mutex_unlock(&mutex);
    printf("Waiter: 작업 완료를 확인했습니다.\n");
    return NULL;
}

int main() {
    pthread_t worker, waiter;

    pthread_create(&worker, NULL, worker_thread, NULL);
    pthread_create(&waiter, NULL, waiting_thread, NULL);

    pthread_join(worker, NULL);
    pthread_join(waiter, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

출력 예시

Worker: 작업을 시작합니다.  
Worker: 작업을 완료했습니다.  
Waiter: 작업 완료를 확인했습니다.

구현 설명

  1. 조건 변수 대기: pthread_cond_wait를 사용해 완료 신호를 기다립니다.
  2. 완료 신호 전송: pthread_cond_signal로 작업 완료 상태를 알립니다.
  3. 뮤텍스 잠금/해제: 동시성 문제를 방지하기 위해 조건 변수와 함께 사용합니다.

컴플리션 사용 시 유의점

  • 조건 플래그 관리: 완료 상태를 나타내는 플래그(is_completed)를 정확히 설정해야 합니다.
  • 뮤텍스와 조건 변수의 조합: 올바르게 사용하지 않으면 교착 상태가 발생할 수 있습니다.
  • 성능 최적화: 필요 이상으로 대기 상태를 만들지 않도록 설계해야 합니다.

컴플리션은 조건 변수와 뮤텍스를 사용하여 간단하게 구현할 수 있으며, 멀티스레드 환경에서 작업 완료를 추적하고 조율하는 데 매우 유용합니다.

세마포어와 컴플리션의 차이점

세마포어와 컴플리션은 모두 동기화를 위해 사용되는 도구지만, 그 목적과 동작 방식에는 명확한 차이가 있습니다. 이 두 동기화 프리미티브를 비교하여 적합한 사용 사례를 이해할 수 있습니다.

세마포어

  1. 목적:
  • 공유 리소스에 대한 접근을 제한하거나 관리합니다.
  • 리소스의 동시 접근을 제어할 수 있습니다(계수 세마포어).
  1. 동작 방식:
  • 세마포어는 카운터를 기반으로 하며, Wait(감소)와 Signal(증가) 연산으로 작동합니다.
  • 값이 0이면 스레드는 대기 상태가 됩니다.
  1. 사용 사례:
  • 데이터베이스 연결 풀 관리
  • 제한된 자원(예: 파일 핸들)에 대한 동시 접근 제어
  1. 예제 상황:
    여러 스레드가 동일한 데이터베이스에 접근할 때 최대 연결 수를 제어하기 위해 사용됩니다.

컴플리션

  1. 목적:
  • 특정 작업의 완료를 기다리거나 작업 순서를 제어합니다.
  • 이벤트 기반의 동작 조율에 사용됩니다.
  1. 동작 방식:
  • 조건 변수나 완료 신호를 통해 특정 상태가 만족될 때까지 대기하거나 신호를 보내는 방식으로 작동합니다.
  1. 사용 사례:
  • 스레드 간 작업 완료 신호 전송
  • 비동기 작업의 완료를 기다리며 후속 작업을 실행
  1. 예제 상황:
    데이터 처리 스레드가 완료 신호를 보낸 후 결과를 다른 스레드가 읽고 추가 작업을 수행합니다.

세마포어와 컴플리션의 주요 차이

특징세마포어컴플리션
목적리소스 접근 관리작업 완료 상태 추적 및 조율
동작 방식카운터 기반 (Wait, Signal)조건 변수 및 신호 기반
사용 사례제한된 자원 동시 접근 제어이벤트 기반 작업 순서 조율
대기 방식자원이 가용할 때까지 대기작업 완료 신호를 받을 때까지 대기

적합한 선택 기준

  • 리소스 관리가 주목적이라면: 세마포어가 적합합니다.
  • 작업 완료를 추적하거나 순서를 조율해야 한다면: 컴플리션을 사용합니다.

두 프리미티브는 서로 보완적이며, 적절한 상황에서 사용하면 멀티스레드 환경에서 효율적이고 안정적인 동기화를 구현할 수 있습니다.

동기화 문제 해결 전략

멀티스레드 프로그래밍에서는 교착 상태와 경쟁 조건 같은 동기화 문제가 흔히 발생할 수 있습니다. 이러한 문제는 프로그램의 안정성과 성능에 심각한 영향을 미칩니다. C 언어에서 발생할 수 있는 주요 동기화 문제와 이를 해결하기 위한 전략을 살펴보겠습니다.

교착 상태(Deadlock)


정의:
교착 상태는 두 개 이상의 스레드가 서로 자원을 잠근 채 대기하는 상태를 말합니다. 이로 인해 프로그램이 멈춥니다.

해결 전략:

  1. 자원 할당 순서 고정:
  • 모든 스레드가 동일한 순서로 자원을 요청하도록 설계합니다.
   pthread_mutex_lock(&mutex1);
   pthread_mutex_lock(&mutex2);
   // 작업 수행
   pthread_mutex_unlock(&mutex2);
   pthread_mutex_unlock(&mutex1);
  1. 타임아웃 사용:
  • 일정 시간 동안 자원을 얻지 못하면 대기 중인 작업을 포기하도록 설정합니다.
  • pthread_mutex_timedlock을 사용하여 구현할 수 있습니다.
  1. 교착 상태 회피 알고리즘:
  • 자원이 부족할 경우, 교착 상태를 회피하는 알고리즘(예: 은행원 알고리즘)을 적용합니다.

경쟁 조건(Race Condition)


정의:
경쟁 조건은 두 스레드가 동시에 공유 데이터를 읽거나 수정하려고 할 때 발생하며, 데이터의 무결성을 손상시킬 수 있습니다.

해결 전략:

  1. 뮤텍스(Mutex) 사용:
  • 공유 자원을 접근할 때 뮤텍스를 사용하여 동시 접근을 방지합니다.
   pthread_mutex_lock(&mutex);
   shared_data++;
   pthread_mutex_unlock(&mutex);
  1. 원자적 연산 사용:
  • 간단한 연산의 경우 __sync_add_and_fetch 같은 원자적 연산을 사용하여 경쟁 조건을 방지합니다.
   __sync_add_and_fetch(&shared_data, 1);
  1. 리드-라이트 락(Read-Write Lock):
  • 읽기 작업이 많은 경우, pthread_rwlock을 사용하여 읽기 스레드는 공유 리소스에 동시 접근할 수 있도록 설정합니다.

자원 누수(Resource Starvation)


정의:
특정 스레드가 자원을 획득하지 못해 영구적으로 대기 상태에 빠지는 현상입니다.

해결 전략:

  1. 우선순위 할당:
  • 낮은 우선순위의 스레드도 일정 시간이 지나면 자원을 획득할 수 있도록 우선순위를 조정합니다.
  1. 페어니스(Fairness) 보장:
  • 공정한 자원 할당을 위해 FIFO(선입선출) 방식의 큐를 사용합니다.

부적절한 동기화


정의:
동기화가 적절하지 않거나 불필요하게 사용되면 성능 저하와 비효율이 발생할 수 있습니다.

해결 전략:

  1. 필요 최소한의 동기화:
  • 불필요한 락 사용을 줄이고, 중요한 코드 블록에만 동기화를 적용합니다.
  1. 락 분할(Lock Splitting):
  • 하나의 락 대신 여러 락을 사용하여 병렬성을 높입니다.
   pthread_mutex_lock(&mutex1);
   // 작업 1
   pthread_mutex_unlock(&mutex1);
   pthread_mutex_lock(&mutex2);
   // 작업 2
   pthread_mutex_unlock(&mutex2);

요약


동기화 문제는 잘못된 설계로 인해 쉽게 발생할 수 있지만, 적절한 전략과 도구를 사용하면 예방하고 해결할 수 있습니다. 교착 상태, 경쟁 조건, 자원 누수 같은 문제를 인식하고 위에서 설명한 해결책을 적용하여 안정적이고 효율적인 멀티스레드 프로그램을 개발할 수 있습니다.

응용 예시: 실제 프로젝트에서의 동기화

세마포어와 컴플리션은 실제 프로젝트에서 동기화 문제를 해결하기 위한 핵심 도구로 사용됩니다. 아래는 이러한 프리미티브를 활용한 사례를 통해 동기화의 응용 방법을 살펴봅니다.

사례 1: 서버의 연결 요청 처리


문제 상황:
웹 서버는 다수의 클라이언트 요청을 동시에 처리해야 합니다. 그러나 요청 처리 스레드 수를 제한하지 않으면 리소스가 고갈될 수 있습니다.

해결 방법:
세마포어를 사용하여 최대 처리 가능한 스레드 수를 제어합니다.

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

#define MAX_CONNECTIONS 5
sem_t semaphore;

void* handle_request(void* arg) {
    sem_wait(&semaphore);  // 연결 처리 가능 여부 확인
    printf("Processing request %d\n", *(int*)arg);
    sleep(2);  // 요청 처리 시간 시뮬레이션
    printf("Completed request %d\n", *(int*)arg);
    sem_post(&semaphore);  // 세마포어 해제
    return NULL;
}

int main() {
    pthread_t threads[10];
    int request_ids[10];

    sem_init(&semaphore, 0, MAX_CONNECTIONS);  // 최대 5개의 연결 허용

    for (int i = 0; i < 10; i++) {
        request_ids[i] = i + 1;
        pthread_create(&threads[i], NULL, handle_request, &request_ids[i]);
    }

    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }

    sem_destroy(&semaphore);
    return 0;
}

출력 예시:

Processing request 1  
Processing request 2  
Processing request 3  
Processing request 4  
Processing request 5  
Completed request 1  
Processing request 6  
...

사례 2: 데이터 처리 파이프라인


문제 상황:
멀티스레드 환경에서 데이터 생성 스레드와 처리 스레드 간의 작업 조율이 필요합니다. 데이터가 준비되지 않은 상태에서 처리 스레드가 실행되면 문제가 발생합니다.

해결 방법:
컴플리션을 사용하여 데이터 준비 완료 신호를 전달합니다.

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int data_ready = 0;

void* produce_data(void* arg) {
    pthread_mutex_lock(&mutex);
    printf("Producing data...\n");
    sleep(2);  // 데이터 생성 시뮬레이션
    data_ready = 1;
    pthread_cond_signal(&cond);  // 데이터 준비 완료 신호
    pthread_mutex_unlock(&mutex);
    return NULL;
}

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

int main() {
    pthread_t producer, consumer;

    pthread_create(&producer, NULL, produce_data, NULL);
    pthread_create(&consumer, NULL, consume_data, NULL);

    pthread_join(producer, NULL);
    pthread_join(consumer, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

출력 예시:

Producing data...  
Consuming data...

사례 3: 병렬 작업의 결과 통합


문제 상황:
병렬로 실행되는 작업들이 모두 완료된 후 결과를 통합해야 하는 경우가 있습니다.

해결 방법:
컴플리션을 사용하여 병렬 작업이 완료되었음을 추적한 후 결과를 통합합니다.

예제:

  • 데이터 분석에서 각 병렬 작업의 결과를 통합하는 상황에 활용 가능.

결론


세마포어와 컴플리션은 실제 프로젝트에서 멀티스레드 환경의 문제를 해결하는 데 매우 유용합니다. 자원 제한, 작업 순서 조율, 병렬 작업 통합 등 다양한 응용 시나리오에서 효과적으로 활용할 수 있습니다. 이러한 프리미티브를 올바르게 사용하면 프로그램의 안정성과 효율성을 극대화할 수 있습니다.

요약


본 기사에서는 C 언어의 동기화 프리미티브인 세마포어와 컴플리션의 기본 개념과 사용법, 그리고 실제 프로젝트에서의 응용 사례를 다뤘습니다. 세마포어는 리소스 접근 관리에, 컴플리션은 작업 완료 조율에 적합하며, 두 프리미티브는 멀티스레드 환경에서 필수적인 도구입니다. 적절한 동기화 전략과 구현을 통해 효율적이고 안정적인 프로그램을 설계할 수 있습니다.

C 언어
C 언어 동기화 세마포어 컴플리션
목차
  1. 동기화란 무엇인가
    1. 동기화의 필요성
    2. 예시 상황
  2. 세마포어의 기본 개념
    1. 세마포어의 정의
    2. 세마포어의 주요 작업
    3. 세마포어의 역할
  3. 세마포어의 구현 및 사용법
    1. 세마포어 초기화
    2. 세마포어 사용: Wait와 Signal
    3. 출력 예시
    4. 세마포어 사용 시 주의점
  4. 컴플리션의 기본 개념
    1. 컴플리션의 정의
    2. 컴플리션의 주요 역할
    3. 컴플리션의 일반적인 사용 사례
    4. 예시
  5. 컴플리션의 구현 및 사용법
    1. 컴플리션 구현: 조건 변수와 뮤텍스
    2. 코드 예제: 간단한 컴플리션 구현
    3. 출력 예시
    4. 구현 설명
    5. 컴플리션 사용 시 유의점
  6. 세마포어와 컴플리션의 차이점
    1. 세마포어
    2. 컴플리션
    3. 세마포어와 컴플리션의 주요 차이
    4. 적합한 선택 기준
  7. 동기화 문제 해결 전략
    1. 교착 상태(Deadlock)
    2. 경쟁 조건(Race Condition)
    3. 자원 누수(Resource Starvation)
    4. 부적절한 동기화
    5. 요약
  8. 응용 예시: 실제 프로젝트에서의 동기화
    1. 사례 1: 서버의 연결 요청 처리
    2. 사례 2: 데이터 처리 파이프라인
    3. 사례 3: 병렬 작업의 결과 통합
    4. 결론
  9. 요약