C언어에서 뮤텍스를 활용한 동기화 가이드

뮤텍스(pthread_mutex_t)는 멀티스레드 환경에서 공유 자원의 동시 접근을 제어하기 위해 사용하는 동기화 도구입니다. 이를 통해 여러 스레드가 동일한 자원을 동시에 수정하여 발생할 수 있는 데이터 불일치와 충돌을 효과적으로 방지할 수 있습니다. 본 기사에서는 C언어에서 뮤텍스를 활용해 안전한 동기화를 구현하는 방법과 실용적인 코드 예제를 통해 이를 심도 있게 탐구합니다.

뮤텍스란 무엇인가
1. 뮤텍스의 동작 원리
2. 뮤텍스의 주요 기능
뮤텍스 초기화 및 사용법
뮤텍스를 사용한 스레드 동기화
데드락 문제와 해결책
재귀적 뮤텍스 사용법
뮤텍스를 활용한 실제 코드 예제
뮤텍스와 다른 동기화 도구 비교
학습을 위한 연습 문제
요약

뮤텍스란 무엇인가

뮤텍스(Mutex, Mutual Exclusion)는 멀티스레드 환경에서 자원 충돌을 방지하기 위한 동기화 도구입니다. 뮤텍스는 이름 그대로 상호 배제를 의미하며, 공유 자원을 하나의 스레드만 접근할 수 있도록 보장합니다.

뮤텍스의 동작 원리

뮤텍스는 잠금(Lock)과 해제(Unlock) 메커니즘으로 작동합니다.

잠금: 한 스레드가 공유 자원을 사용하기 위해 뮤텍스를 잠그면 다른 스레드는 해당 자원의 접근이 차단됩니다.
해제: 사용이 끝난 자원은 뮤텍스를 해제하여 다른 스레드가 접근할 수 있도록 합니다.

뮤텍스의 주요 기능

상호 배제: 공유 자원을 하나의 스레드만 사용할 수 있도록 제한.
경쟁 상태 방지: 여러 스레드가 동시에 자원을 변경하여 발생할 수 있는 데이터 불일치를 방지.
스레드 간 협력: 자원 접근 순서를 명확히 하여 프로그램 안정성을 확보.

뮤텍스는 간단하면서도 강력한 동기화 도구로, 멀티스레드 프로그래밍에서 중요한 역할을 합니다.

뮤텍스 초기화 및 사용법

뮤텍스를 효과적으로 사용하기 위해서는 초기화, 잠금, 해제의 단계적 사용이 필요합니다. C언어의 POSIX 스레드 라이브러리에서는 pthread_mutex_t와 관련된 여러 함수를 제공합니다.

뮤텍스 초기화

뮤텍스는 두 가지 방법으로 초기화할 수 있습니다.

정적 초기화

   pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

간단한 초기화 방식으로 전역 또는 파일 범위의 뮤텍스에 사용됩니다.

동적 초기화

   pthread_mutex_t mutex;
   pthread_mutex_init(&mutex, NULL);

동적으로 초기화하며, 두 번째 인자는 뮤텍스 속성을 지정합니다. 기본 속성을 사용할 경우 NULL을 전달합니다.

뮤텍스 잠금과 해제

잠금(Lock)
공유 자원을 사용하기 전에 뮤텍스를 잠가야 합니다.

   pthread_mutex_lock(&mutex);

해제(Unlock)
자원 사용이 끝난 후 뮤텍스를 해제합니다.

   pthread_mutex_unlock(&mutex);

뮤텍스 파괴

사용이 끝난 뮤텍스는 메모리 누수를 방지하기 위해 반드시 파괴해야 합니다.

pthread_mutex_destroy(&mutex);

간단한 예제 코드

다음은 뮤텍스 초기화와 잠금, 해제 과정을 포함한 간단한 예제입니다.

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

pthread_mutex_t mutex;

void* thread_function(void* arg) {
    pthread_mutex_lock(&mutex);
    printf("Thread %d: Critical section\n", *(int*)arg);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t threads[2];
    int thread_ids[2] = {1, 2};

    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < 2; i++) {
        pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]);
    }

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

    pthread_mutex_destroy(&mutex);
    return 0;
}

결론

뮤텍스 초기화와 기본 사용법은 멀티스레드 프로그래밍의 필수 기초입니다. 올바른 초기화와 정리 단계를 통해 자원 충돌을 방지하고 프로그램 안정성을 유지할 수 있습니다.

뮤텍스를 사용한 스레드 동기화

멀티스레드 환경에서 공유 자원에 대한 접근은 스레드 간 충돌을 초래할 수 있습니다. 뮤텍스를 사용하면 이러한 충돌을 방지하고 자원 사용 순서를 제어할 수 있습니다.

스레드 동기화의 필요성

공유 자원을 동시에 여러 스레드가 접근하면 경쟁 상태(Race Condition)가 발생할 수 있습니다. 이는 데이터의 불일치와 프로그램 비정상을 초래합니다.
뮤텍스를 통해 스레드 동기화를 구현하면 다음과 같은 이점을 얻을 수 있습니다:

자원 접근 순서 보장
데이터 일관성 유지
프로그램 안정성 확보

뮤텍스 기반 동기화 구현

뮤텍스를 활용하여 스레드 동기화를 구현하는 과정은 아래와 같습니다.

뮤텍스 잠금
공유 자원 접근 전, 뮤텍스를 잠급니다.

   pthread_mutex_lock(&mutex);

공유 자원 사용
잠금을 설정한 스레드만 공유 자원을 사용할 수 있습니다.

   shared_variable++;

뮤텍스 해제
자원 사용이 끝난 후 뮤텍스를 해제하여 다른 스레드가 접근할 수 있도록 합니다.

   pthread_mutex_unlock(&mutex);

동기화 예제 코드

다음 코드는 뮤텍스를 사용하여 공유 변수를 안전하게 증가시키는 스레드 동기화를 보여줍니다.

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

#define NUM_THREADS 5

int shared_variable = 0;
pthread_mutex_t mutex;

void* increment_function(void* arg) {
    pthread_mutex_lock(&mutex);
    for (int i = 0; i < 1000; i++) {
        shared_variable++;
    }
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, increment_function, NULL);
    }

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

    pthread_mutex_destroy(&mutex);

    printf("Final value of shared_variable: %d\n", shared_variable);
    return 0;
}

결과 분석

위 코드는 뮤텍스를 사용하여 다중 스레드 간의 공유 변수 증가 연산을 안전하게 수행합니다.

뮤텍스 없이 실행하면 공유 변수의 최종 값이 예측 불가한 값으로 나타날 수 있습니다.
뮤텍스를 추가하면 모든 스레드가 순차적으로 접근하여 데이터 일관성을 보장합니다.

결론

뮤텍스를 사용한 스레드 동기화는 멀티스레드 프로그래밍에서 필수적인 기법입니다. 올바른 사용으로 프로그램의 안정성과 신뢰성을 확보할 수 있습니다.

데드락 문제와 해결책

뮤텍스를 사용한 동기화는 자원 충돌 방지에 효과적이지만, 잘못된 설계는 데드락(Deadlock) 문제를 초래할 수 있습니다. 데드락은 두 개 이상의 스레드가 서로의 자원을 기다리며 영원히 멈추는 상태를 말합니다.

데드락이 발생하는 원인

데드락은 다음과 같은 조건이 모두 충족될 때 발생합니다:

상호 배제: 자원은 한 번에 하나의 스레드만 접근 가능합니다.
점유 대기: 스레드는 이미 할당받은 자원을 유지하면서 추가 자원을 기다립니다.
비선점성: 자원을 점유 중인 스레드는 강제로 자원을 빼앗길 수 없습니다.
순환 대기: 자원을 점유한 스레드들이 서로 다른 자원을 요청하며 순환적으로 기다립니다.

데드락 방지 전략

데드락을 방지하려면 다음 방법을 활용할 수 있습니다.

자원 획득 순서 지정
모든 스레드가 자원을 동일한 순서로 획득하도록 강제하여 순환 대기를 방지합니다.

   pthread_mutex_lock(&mutex1);
   pthread_mutex_lock(&mutex2);

타임아웃 사용
pthread_mutex_timedlock를 사용하여 지정된 시간 동안만 뮤텍스를 잠급니다.

   struct timespec ts;
   clock_gettime(CLOCK_REALTIME, &ts);
   ts.tv_sec += 1; // 1초 타임아웃 설정
   if (pthread_mutex_timedlock(&mutex, &ts) == 0) {
       // 성공적으로 잠금
   } else {
       // 타임아웃 처리
   }

데드락 감지 및 회복
데드락을 감지하고 회복하는 알고리즘을 구현합니다. 이는 고급 기술로 일반적으로 운영 체제 수준에서 사용됩니다.
재귀적 뮤텍스 사용
동일 스레드가 동일 뮤텍스를 여러 번 잠글 수 있도록 재귀적 뮤텍스를 활용합니다.

데드락 방지 예제 코드

다음 코드는 자원 획득 순서 지정을 통해 데드락을 방지하는 예제입니다.

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

pthread_mutex_t mutex1, mutex2;

void* thread_function1(void* arg) {
    pthread_mutex_lock(&mutex1);
    pthread_mutex_lock(&mutex2);

    printf("Thread 1: Critical section\n");

    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);

    return NULL;
}

void* thread_function2(void* arg) {
    pthread_mutex_lock(&mutex1);
    pthread_mutex_lock(&mutex2);

    printf("Thread 2: Critical section\n");

    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);

    return NULL;
}

int main() {
    pthread_t t1, t2;

    pthread_mutex_init(&mutex1, NULL);
    pthread_mutex_init(&mutex2, NULL);

    pthread_create(&t1, NULL, thread_function1, NULL);
    pthread_create(&t2, NULL, thread_function2, NULL);

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

    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);

    return 0;
}

결론

데드락 문제는 멀티스레드 프로그래밍에서 신중하게 설계하지 않으면 발생할 수 있습니다. 위의 방지 전략과 같은 접근 방식을 통해 데드락을 예방하고 프로그램의 안정성을 유지할 수 있습니다.

재귀적 뮤텍스 사용법

뮤텍스는 기본적으로 동일한 스레드가 동일 뮤텍스를 여러 번 잠그려고 하면 데드락을 유발합니다. 그러나 재귀적 뮤텍스를 사용하면 동일 스레드가 뮤텍스를 여러 번 잠글 수 있습니다.

재귀적 뮤텍스란?

재귀적 뮤텍스(Recursive Mutex)는 동일 스레드가 동일 뮤텍스를 여러 번 잠그는 것을 허용하며, 각 잠금에는 대응되는 해제가 필요합니다.

기본 뮤텍스: 동일 스레드가 동일 뮤텍스를 두 번 잠그면 데드락 발생.
재귀적 뮤텍스: 동일 스레드의 중복 잠금을 허용하며, 잠금 횟수를 내부적으로 카운팅합니다.

재귀적 뮤텍스 초기화

POSIX 스레드 라이브러리에서 재귀적 뮤텍스를 사용하려면 뮤텍스 속성을 설정해야 합니다.

뮤텍스 속성 생성

   pthread_mutexattr_t attr;
   pthread_mutexattr_init(&attr);
   pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

뮤텍스 초기화
설정한 속성을 사용해 뮤텍스를 초기화합니다.

   pthread_mutex_t mutex;
   pthread_mutex_init(&mutex, &attr);
   pthread_mutexattr_destroy(&attr);

재귀적 뮤텍스 예제 코드

다음 코드는 재귀적 뮤텍스를 활용한 간단한 예제입니다.

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

pthread_mutex_t mutex;

void recursive_function(int count) {
    if (count <= 0) return;

    pthread_mutex_lock(&mutex);
    printf("Recursive lock: %d\n", count);
    recursive_function(count - 1);
    pthread_mutex_unlock(&mutex);
    printf("Recursive unlock: %d\n", count);
}

int main() {
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

    pthread_mutex_init(&mutex, &attr);
    pthread_mutexattr_destroy(&attr);

    recursive_function(3);

    pthread_mutex_destroy(&mutex);
    return 0;
}

출력 결과

위 코드의 실행 결과는 다음과 같습니다.

Recursive lock: 3  
Recursive lock: 2  
Recursive lock: 1  
Recursive unlock: 1  
Recursive unlock: 2  
Recursive unlock: 3

재귀적 뮤텍스의 활용 사례

재귀 호출
함수 내부에서 재귀적으로 자원을 보호해야 할 때 사용합니다.
다중 모듈 작업
동일한 스레드가 여러 단계에서 동일 자원을 접근해야 하는 경우.

주의사항

재귀적 뮤텍스는 기본 뮤텍스보다 성능이 낮을 수 있습니다.
잠금 횟수와 해제 횟수가 일치하지 않으면 뮤텍스가 해제되지 않는 문제가 발생할 수 있습니다.

결론

재귀적 뮤텍스는 동일 스레드의 중복 잠금 상황에서 유용합니다. 올바른 초기화와 잠금/해제 관리를 통해 이를 안전하게 사용할 수 있습니다.

뮤텍스를 활용한 실제 코드 예제

멀티스레드 환경에서 뮤텍스를 사용해 동기화를 구현하는 실제 사례를 통해 뮤텍스의 활용법을 명확히 이해할 수 있습니다. 다음은 은행 계좌의 잔액을 여러 스레드가 안전하게 입출금하는 시뮬레이션 예제입니다.

프로그램 목표

여러 스레드가 공유 자원(은행 계좌 잔액)에 동시에 접근합니다.
뮤텍스를 활용해 스레드 간 동기화 문제를 방지합니다.

코드 예제

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

#define NUM_THREADS 5
#define NUM_TRANSACTIONS 1000

int account_balance = 0;  // 공유 자원: 은행 계좌 잔액
pthread_mutex_t mutex;

void* deposit(void* arg) {
    for (int i = 0; i < NUM_TRANSACTIONS; i++) {
        pthread_mutex_lock(&mutex);
        account_balance += 10;  // 입금 작업
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void* withdraw(void* arg) {
    for (int i = 0; i < NUM_TRANSACTIONS; i++) {
        pthread_mutex_lock(&mutex);
        account_balance -= 10;  // 출금 작업
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    pthread_mutex_init(&mutex, NULL);

    // 입금과 출금 스레드 생성
    for (int i = 0; i < NUM_THREADS; i++) {
        if (i % 2 == 0) {
            pthread_create(&threads[i], NULL, deposit, NULL);
        } else {
            pthread_create(&threads[i], NULL, withdraw, NULL);
        }
    }

    // 모든 스레드 종료 대기
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&mutex);

    // 최종 잔액 출력
    printf("Final account balance: %d\n", account_balance);
    return 0;
}

출력 결과

이 코드는 입금과 출금 스레드가 번갈아 실행되며 잔액이 계산됩니다.
결과는 항상 0이 되며, 이는 뮤텍스가 공유 자원의 동기화를 성공적으로 보장했음을 나타냅니다.

Final account balance: 0

주요 동작 설명

뮤텍스 잠금
각 스레드는 잔액 수정 전 pthread_mutex_lock()을 호출하여 자원을 독점합니다.
뮤텍스 해제
작업이 끝나면 pthread_mutex_unlock()을 호출하여 다른 스레드가 자원을 사용할 수 있도록 합니다.
스레드 생성 및 종료 대기
pthread_create()로 스레드를 생성하고, pthread_join()으로 종료를 기다립니다.

확장 가능성

이 코드는 다음과 같은 시나리오로 확장할 수 있습니다:

여러 은행 계좌를 관리하는 멀티 뮤텍스 구조.
뮤텍스 대신 조건 변수를 사용해 입출금 대기 상황 처리.
타임아웃을 추가해 대기 시간을 제한.

결론

뮤텍스를 활용하면 멀티스레드 환경에서 데이터 일관성과 안정성을 보장할 수 있습니다. 이와 같은 실제 사례는 복잡한 멀티스레드 애플리케이션 설계의 기초를 제공합니다.

뮤텍스와 다른 동기화 도구 비교

뮤텍스는 멀티스레드 프로그래밍에서 중요한 동기화 도구이지만, 다양한 시나리오에 따라 세마포어, 조건 변수 등 다른 도구가 더 적합할 수 있습니다. 이 섹션에서는 주요 동기화 도구를 비교하고, 뮤텍스의 장단점을 이해합니다.

뮤텍스와 세마포어 비교

특징	뮤텍스(Mutex)	세마포어(Semaphore)
자원 관리	단일 자원 보호	다중 자원 관리
잠금 허용 범위	한 번에 한 스레드만 자원 접근 가능	여러 스레드가 동시에 접근 가능
소유권	잠금을 획득한 스레드만 해제 가능	소유권 개념 없음, 누구나 해제 가능
사용 목적	상호 배제 (Mutual Exclusion)	자원 개수 제한 (Counting Resource)
예시 사용	공유 데이터 보호	제한된 풀 (e.g., DB 연결) 관리

뮤텍스는 상호 배제가 필요한 경우에 적합하며, 세마포어는 제한된 자원을 관리할 때 더 유용합니다.

뮤텍스와 조건 변수 비교

특징	뮤텍스(Mutex)	조건 변수(Condition Variable)
역할	자원 접근을 동기화	상태 변화 대기 및 알림 처리
사용 방식	자원 보호 및 동시 접근 방지	뮤텍스와 함께 사용해 특정 조건 대기
예시 사용	공유 데이터 읽기/쓰기 동기화	생산자-소비자 문제 해결

조건 변수는 뮤텍스와 함께 사용되며, 특정 조건이 충족될 때까지 스레드가 대기하도록 설계되었습니다.

뮤텍스와 스핀락 비교

특징	뮤텍스(Mutex)	스핀락(Spinlock)
대기 방식	스레드는 잠금이 풀릴 때까지 대기(블로킹)	잠금이 풀릴 때까지 반복적으로 확인(스핀)
사용 목적	멀티스레드 동기화	짧은 잠금 대기 시간
성능	대기 중 스레드 상태 전환으로 오버헤드 발생	짧은 작업에는 더 빠르지만 CPU 자원 소모 큼

스핀락은 짧은 잠금 대기 시간이 예상되는 경우 적합하며, 뮤텍스는 일반적인 동기화에 사용됩니다.

뮤텍스와 리더-라이터 락 비교

특징	뮤텍스(Mutex)	리더-라이터 락(Reader-Writer Lock)
접근 권한	단일 스레드만 접근 허용	다중 리더 접근 가능, 단일 라이터만 허용
사용 목적	단순 자원 보호	읽기 작업이 많은 경우 효율적

리더-라이터 락은 읽기 작업이 빈번한 경우 성능을 향상시킬 수 있는 대안입니다.

뮤텍스의 장단점

장점

간단한 구조로 상호 배제를 보장.
POSIX 표준으로 다양한 플랫폼에서 사용 가능.
재귀적 뮤텍스 등 유연한 기능 제공.

단점

멀티 자원 관리에 비효율적.
잠금 대기 상태에서 스레드 전환으로 오버헤드 발생.

결론

뮤텍스는 자원 충돌 방지와 상호 배제가 필요한 대부분의 상황에서 효과적이지만, 특정 시나리오에서는 다른 동기화 도구가 더 적합할 수 있습니다. 각 도구의 특징과 용도를 이해하고 상황에 맞는 도구를 선택하는 것이 중요합니다.

학습을 위한 연습 문제

뮤텍스의 사용법과 멀티스레드 프로그래밍의 동기화 개념을 더욱 명확히 이해하기 위해 다음 연습 문제를 제공합니다. 각 문제는 실습을 통해 직접 해결하며, 뮤텍스와 관련된 주요 개념을 익히는 데 도움을 줄 것입니다.

문제 1: 공유 자원의 안전한 수정

다음은 여러 스레드가 shared_counter를 동시에 증가시키는 프로그램의 코드입니다.

뮤텍스를 추가하여 데이터 경쟁 문제를 해결하세요.

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

#define NUM_THREADS 5
#define NUM_ITERATIONS 1000

int shared_counter = 0;

void* increment_counter(void* arg) {
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        shared_counter++;
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, increment_counter, NULL);
    }

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

    printf("Final counter value: %d\n", shared_counter);
    return 0;
}

목표: 프로그램의 출력이 항상 예측 가능한 결과를 출력하도록 수정하세요.

문제 2: 데드락 방지

다음 프로그램은 두 개의 뮤텍스를 사용하며 데드락이 발생할 수 있는 구조를 가지고 있습니다.

데드락이 발생하지 않도록 코드 구조를 수정하세요.

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

pthread_mutex_t mutex1, mutex2;

void* thread_function1(void* arg) {
    pthread_mutex_lock(&mutex1);
    pthread_mutex_lock(&mutex2);

    printf("Thread 1 in critical section\n");

    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void* thread_function2(void* arg) {
    pthread_mutex_lock(&mutex2);
    pthread_mutex_lock(&mutex1);

    printf("Thread 2 in critical section\n");

    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}

int main() {
    pthread_t t1, t2;

    pthread_mutex_init(&mutex1, NULL);
    pthread_mutex_init(&mutex2, NULL);

    pthread_create(&t1, NULL, thread_function1, NULL);
    pthread_create(&t2, NULL, thread_function2, NULL);

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

    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);

    return 0;
}

목표: 자원 획득 순서를 지정하여 데드락을 방지하세요.

문제 3: 재귀적 뮤텍스 활용

재귀적 뮤텍스를 사용하여 다음 코드를 완성하세요.

함수 recursive_increment()가 동일 스레드 내에서 뮤텍스를 여러 번 잠글 수 있도록 코드를 수정하세요.

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

pthread_mutex_t mutex;

void recursive_increment(int count) {
    if (count <= 0) return;

    // 뮤텍스 잠금 추가
    printf("Recursive increment: %d\n", count);

    recursive_increment(count - 1);

    // 뮤텍스 해제 추가
}

int main() {
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);

    // 재귀적 뮤텍스 설정 및 초기화
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&mutex, &attr);
    pthread_mutexattr_destroy(&attr);

    recursive_increment(5);

    pthread_mutex_destroy(&mutex);
    return 0;
}

목표: 재귀적 뮤텍스를 사용하여 프로그램이 정상적으로 실행되도록 수정하세요.

문제 4: 조건 변수와 뮤텍스의 결합

생산자-소비자 문제를 해결하기 위해 뮤텍스와 조건 변수를 사용해 보세요.

생산자가 데이터를 생성하면 소비자가 이를 소비하는 구조를 구현하세요.
추가 목표: 대기 시간 또는 생산량 제한을 설정하세요.

결론

위의 연습 문제를 통해 뮤텍스의 기본 사용법, 데드락 방지, 재귀적 뮤텍스 활용, 그리고 조건 변수와의 조합 방법을 익힐 수 있습니다. 실습을 통해 멀티스레드 프로그래밍에서의 동기화 개념을 깊이 이해하세요.

요약

뮤텍스는 멀티스레드 환경에서 상호 배제를 보장하며, 자원 충돌 방지와 프로그램 안정성 확보에 중요한 역할을 합니다. 본 기사에서는 뮤텍스의 개념, 초기화와 사용법, 스레드 동기화 방법, 데드락 문제 해결, 재귀적 뮤텍스 활용, 그리고 실질적인 코드 예제와 연습 문제를 다뤘습니다. 이를 통해 C언어에서 멀티스레드 프로그래밍의 필수 요소를 체계적으로 이해할 수 있습니다.