C언어에서 pthread_join()을 활용한 스레드 종료 대기 방법

C언어에서 멀티스레딩 프로그래밍은 복잡한 작업을 효율적으로 처리할 수 있는 강력한 도구입니다. 그러나 여러 스레드가 동시에 실행되는 환경에서는 올바른 동기화와 종료 처리가 중요합니다. pthread_join() 함수는 이러한 스레드 관리에서 핵심적인 역할을 하며, 스레드가 완전히 종료될 때까지 호출 스레드가 대기할 수 있도록 지원합니다. 본 기사에서는 pthread_join()의 개념과 사용법, 그리고 이를 활용한 스레드 종료 대기와 동기화 방법에 대해 다룹니다.

pthread_join() 함수의 역할

pthread_join() 함수는 C언어의 POSIX 스레드 라이브러리에서 제공되는 스레드 동기화 도구로, 생성된 스레드가 종료될 때까지 호출한 스레드를 대기 상태로 유지하는 역할을 합니다. 이 함수는 다음과 같은 주요 기능을 수행합니다.

스레드 종료 대기

pthread_join()은 지정된 스레드가 작업을 완료하고 종료될 때까지 호출한 스레드를 멈추게 합니다. 이를 통해 실행 순서를 명확히 하고 예상치 못한 동작을 방지할 수 있습니다.

스레드 리턴 값 수집

종료된 스레드가 반환한 값을 받을 수 있도록 지원합니다. 반환 값은 스레드 함수의 결과나 상태 정보를 전달하는 데 유용합니다.

자원 회수

스레드 종료 후 스레드의 관련 리소스는 시스템에 의해 정리되지 않습니다. pthread_join()을 호출하여 해당 자원을 명시적으로 회수함으로써 메모리 누수를 방지할 수 있습니다.

이 함수는 멀티스레딩 환경에서 실행 순서와 리소스 관리를 효율적으로 제어하기 위한 필수적인 도구로, 프로그램의 안정성과 가독성을 높이는 데 크게 기여합니다.

pthread_join() 함수의 기본 사용법

pthread_join() 함수는 스레드의 종료를 대기하고, 종료된 스레드의 리턴 값을 가져오는 데 사용됩니다. 함수의 기본 구조와 사용법은 다음과 같습니다.

함수 시그니처

int pthread_join(pthread_t thread, void **retval);

thread: 대기할 대상 스레드의 식별자입니다.
retval: 종료된 스레드의 리턴 값을 저장할 포인터입니다. NULL을 전달할 수도 있습니다.

기본 사용 예제

아래 코드는 pthread_join()의 기본적인 사용법을 보여줍니다.

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

void* thread_function(void* arg) {
    int* num = (int*)arg;
    printf("스레드가 실행 중입니다: %d\n", *num);
    int* result = malloc(sizeof(int));
    *result = (*num) * 2; // 두 배로 계산
    return (void*)result;
}

int main() {
    pthread_t thread;
    int input = 5;
    int* output;

    // 스레드 생성
    if (pthread_create(&thread, NULL, thread_function, &input) != 0) {
        perror("스레드 생성 실패");
        return 1;
    }

    // 스레드 종료 대기 및 반환값 수집
    if (pthread_join(thread, (void**)&output) != 0) {
        perror("스레드 조인 실패");
        return 1;
    }

    printf("스레드 종료. 결과: %d\n", *output);
    free(output); // 반환된 메모리 해제

    return 0;
}

코드 설명

pthread_create로 새로운 스레드를 생성하고, thread_function을 실행합니다.
pthread_join을 호출하여 생성된 스레드가 종료될 때까지 대기합니다.
스레드가 반환한 결과를 retval을 통해 가져옵니다.
반환된 메모리를 해제하여 메모리 누수를 방지합니다.

이 간단한 예제를 통해 pthread_join()의 기본적인 사용법과 반환 값 활용 방법을 이해할 수 있습니다.

동기화 문제 해결을 위한 활용

멀티스레딩 환경에서는 여러 스레드가 동시에 실행되면서 데이터 경쟁이나 예측 불가능한 동작이 발생할 수 있습니다. pthread_join() 함수는 이러한 문제를 해결하기 위해 스레드 실행 순서를 제어하는 효과적인 방법을 제공합니다.

스레드 실행 순서 제어

pthread_join()을 활용하면 특정 스레드가 반드시 종료된 후 다음 작업을 수행하도록 보장할 수 있습니다. 이는 스레드 간에 종속성이 있는 작업에서 특히 중요합니다.

예제 코드:

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

void* thread_task(void* arg) {
    printf("스레드 작업 실행 중...\n");
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 스레드 생성
    pthread_create(&thread1, NULL, thread_task, NULL);
    pthread_create(&thread2, NULL, thread_task, NULL);

    // 스레드 종료 대기
    pthread_join(thread1, NULL);
    printf("첫 번째 스레드 종료 후 실행\n");

    pthread_join(thread2, NULL);
    printf("두 번째 스레드 종료 후 실행\n");

    return 0;
}

결과:

스레드 작업 실행 중...
스레드 작업 실행 중...
첫 번째 스레드 종료 후 실행
두 번째 스레드 종료 후 실행

데이터 경쟁 방지

동일한 자원에 여러 스레드가 동시에 접근할 경우, 데이터 경쟁 문제가 발생할 수 있습니다. pthread_join()을 사용하여 스레드가 종료된 후 데이터를 처리하도록 하면 이러한 문제를 완화할 수 있습니다.

예제:

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

int shared_data = 0;

void* increment_task(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        shared_data++;
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 스레드 생성
    pthread_create(&thread1, NULL, increment_task, NULL);
    pthread_create(&thread2, NULL, increment_task, NULL);

    // 스레드 종료 대기
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("최종 shared_data 값: %d\n", shared_data);
    return 0;
}

결과 분석:
위 코드는 pthread_join()을 통해 두 스레드가 모두 작업을 완료한 후 shared_data 값을 출력합니다. 이를 통해 데이터 경쟁 없이 결과를 안전하게 확인할 수 있습니다.

동기화와 시스템 안정성 확보

pthread_join()은 스레드의 작업 완료를 보장하여 시스템 전체의 동기화를 유지하고 예측 가능한 결과를 제공합니다. 이로 인해 멀티스레딩 프로그램의 안정성과 유지보수성이 향상됩니다.

스레드 리소스 회수와 메모리 관리

멀티스레딩 프로그래밍에서는 생성된 스레드의 종료와 함께 시스템 리소스와 메모리를 적절히 관리해야 합니다. pthread_join() 함수는 스레드 리소스를 회수하고 메모리 누수를 방지하는 데 중요한 역할을 합니다.

스레드 종료 후 리소스 회수

스레드가 종료되더라도 관련된 시스템 리소스는 pthread_join()을 호출할 때까지 해제되지 않습니다. 이로 인해 리소스 누적이 발생할 수 있으므로, 생성된 모든 스레드에 대해 pthread_join()을 호출하여 리소스를 명시적으로 회수해야 합니다.

예제:

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

void* thread_task(void* arg) {
    printf("스레드 작업 실행 중...\n");
    return NULL;
}

int main() {
    pthread_t thread;

    // 스레드 생성
    pthread_create(&thread, NULL, thread_task, NULL);

    // 스레드 종료 대기 및 리소스 회수
    pthread_join(thread, NULL);

    printf("스레드 리소스가 성공적으로 회수되었습니다.\n");
    return 0;
}

메모리 누수 방지

스레드가 동적으로 할당된 메모리를 반환값으로 제공하는 경우, pthread_join()을 통해 해당 메모리를 수집하고 적절히 해제해야 합니다.

예제:

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

void* thread_function(void* arg) {
    int* result = malloc(sizeof(int)); // 메모리 동적 할당
    *result = 42; // 계산 결과 저장
    return (void*)result;
}

int main() {
    pthread_t thread;
    int* thread_result;

    // 스레드 생성
    pthread_create(&thread, NULL, thread_function, NULL);

    // 스레드 종료 대기 및 반환값 수집
    pthread_join(thread, (void**)&thread_result);

    printf("스레드 반환값: %d\n", *thread_result);

    // 반환된 메모리 해제
    free(thread_result);

    return 0;
}

잘못된 메모리 관리의 위험

pthread_join()을 호출하지 않으면 다음과 같은 문제가 발생할 수 있습니다:

리소스 누수: 스레드가 사용하는 스택 메모리와 기타 시스템 리소스가 해제되지 않아 메모리 부족 현상이 발생할 수 있습니다.
메모리 해제 지연: 동적 메모리를 반환하지 않으면 프로그램이 종료될 때까지 메모리가 계속 점유됩니다.

리소스 관리의 모범 사례

모든 스레드에 대해 pthread_join() 호출: 생성된 스레드의 종료를 기다리고 리소스를 회수합니다.
동적 메모리 정리: 스레드 반환값이 동적 메모리라면 적절히 해제하여 메모리 누수를 방지합니다.
다중 스레드 리소스 관리: 여러 스레드를 생성한 경우, 반복문 등을 사용하여 pthread_join()을 일괄적으로 호출합니다.

결론

pthread_join()은 스레드 리소스를 효과적으로 관리하고, 메모리 누수를 방지하여 멀티스레딩 프로그램의 안정성을 유지하는 데 필수적인 함수입니다. 이를 올바르게 사용함으로써 시스템 자원을 효율적으로 활용하고 성능 문제를 예방할 수 있습니다.

pthread_join()의 동작 시나리오

멀티스레딩 환경에서 pthread_join()의 동작은 다양한 시나리오에 따라 다르게 나타날 수 있습니다. 이 함수는 스레드 종료를 대기하는 데 필수적이며, 여러 상황에서 유용하게 활용됩니다. 아래는 주요 동작 시나리오와 함께 이를 효과적으로 활용하는 방법을 설명합니다.

단일 스레드 종료 대기

가장 기본적인 사용 사례로, 단일 스레드가 작업을 완료할 때까지 대기합니다. 이는 스레드 간 작업 순서를 보장하고 예상치 못한 실행 오류를 방지합니다.

예제:

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

void* thread_task(void* arg) {
    printf("작업 수행 중...\n");
    return NULL;
}

int main() {
    pthread_t thread;

    // 스레드 생성
    pthread_create(&thread, NULL, thread_task, NULL);

    // 스레드 종료 대기
    pthread_join(thread, NULL);

    printf("스레드 종료 완료\n");
    return 0;
}

다중 스레드 처리

여러 개의 스레드를 생성한 경우, 각 스레드에 대해 pthread_join()을 호출하여 개별적으로 대기합니다. 이는 모든 스레드가 종료된 후에 다음 작업을 수행하도록 보장합니다.

예제:

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

void* thread_task(void* arg) {
    int id = *(int*)arg;
    printf("스레드 %d 작업 중...\n", id);
    return NULL;
}

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

    // 여러 스레드 생성
    for (int i = 0; i < 3; i++) {
        pthread_create(&threads[i], NULL, thread_task, &thread_ids[i]);
    }

    // 각 스레드의 종료 대기
    for (int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
        printf("스레드 %d 종료 완료\n", i + 1);
    }

    return 0;
}

스레드의 순차적 실행 보장

스레드 간 작업 순서가 중요한 경우, pthread_join()을 활용하여 순차적으로 실행되도록 설정할 수 있습니다.

예제:

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

void* thread_task(void* arg) {
    int id = *(int*)arg;
    printf("스레드 %d 시작\n", id);
    printf("스레드 %d 종료\n", id);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    int id1 = 1, id2 = 2;

    pthread_create(&thread1, NULL, thread_task, &id1);
    pthread_join(thread1, NULL); // 첫 번째 스레드 종료 대기

    pthread_create(&thread2, NULL, thread_task, &id2);
    pthread_join(thread2, NULL); // 두 번째 스레드 종료 대기

    printf("모든 스레드 종료 완료\n");
    return 0;
}

스레드가 이미 종료된 경우

스레드가 pthread_join() 호출 이전에 이미 종료된 경우, 함수는 즉시 반환됩니다. 따라서 종료 여부와 관계없이 안전하게 호출할 수 있습니다.

결론

pthread_join()은 멀티스레딩 환경에서 동기화를 보장하고 리소스를 효율적으로 관리하기 위한 강력한 도구입니다. 단일 스레드부터 다중 스레드까지 다양한 시나리오에서 이를 올바르게 사용하면 프로그램의 안정성과 성능을 크게 향상시킬 수 있습니다.

예외 상황에서의 pthread_join() 처리

pthread_join() 함수는 일반적으로 스레드 종료 대기를 위한 안정적인 메커니즘으로 사용되지만, 특정 상황에서는 예외적인 동작이 발생할 수 있습니다. 이러한 상황에서 적절한 대처법을 이해하는 것이 중요합니다.

스레드 종료 실패

문제:

대상 스레드가 이미 pthread_detach()를 통해 분리된 상태인 경우 pthread_join() 호출 시 오류가 발생합니다.
오류 코드: EINVAL (잘못된 상태)

해결 방법:

스레드를 분리(pthread_detach())하거나 대기(pthread_join()) 중 하나를 선택하여 사용합니다.
분리된 스레드에 대해 pthread_join()을 호출하지 않도록 설계합니다.

데드락(Deadlock)

문제:

호출한 스레드가 자기 자신을 대상으로 pthread_join()을 호출하면 데드락이 발생합니다.
예를 들어, pthread_self()를 사용해 자신을 pthread_join()의 대상 스레드로 지정한 경우.

해결 방법:

pthread_join()의 대상 스레드와 호출 스레드가 같은지 확인합니다.
스레드 생성 시 관리할 식별자를 명확히 지정하여 실수를 방지합니다.

예제:

if (pthread_equal(pthread_self(), target_thread)) {
    fprintf(stderr, "자기 자신을 대상으로 pthread_join() 호출 금지\n");
    exit(EXIT_FAILURE);
}

중복 호출

문제:

동일한 스레드에 대해 여러 번 pthread_join()을 호출하면 오류가 발생합니다.
오류 코드: EINVAL

해결 방법:

스레드 관리 구조체를 사용하여 이미 pthread_join()이 호출된 스레드인지 추적합니다.

예제:

#include <stdbool.h>

typedef struct {
    pthread_t thread_id;
    bool joined;
} ThreadInfo;

void join_thread(ThreadInfo* info) {
    if (info->joined) {
        fprintf(stderr, "이미 pthread_join()이 호출되었습니다.\n");
        return;
    }
    pthread_join(info->thread_id, NULL);
    info->joined = true;
}

잘못된 스레드 식별자

문제:

유효하지 않은 스레드 식별자(예: NULL 또는 종료된 후 식별자 값을 잘못 사용)로 pthread_join()을 호출하면 오류가 발생합니다.
오류 코드: ESRCH (존재하지 않는 스레드)

해결 방법:

스레드 생성 후 올바른 스레드 식별자를 저장하고 유효성을 검사합니다.

예제:

if (pthread_join(invalid_thread, NULL) != 0) {
    fprintf(stderr, "유효하지 않은 스레드 식별자입니다.\n");
}

스레드가 무기한 대기 상태에 빠질 경우

문제:

스레드가 종료되지 않으면 pthread_join() 호출은 무기한 대기 상태로 남습니다.

해결 방법:

스레드의 상태를 지속적으로 모니터링하거나, 타이머와 같은 보조 메커니즘을 활용하여 대기를 제한합니다.
스레드 작업 시간 초과 시 스레드를 강제로 종료하는 설계 방식을 고려합니다.

예제:

struct timespec timeout;
clock_gettime(CLOCK_REALTIME, &timeout);
timeout.tv_sec += 5; // 5초 대기

if (pthread_timedjoin_np(target_thread, NULL, &timeout) != 0) {
    fprintf(stderr, "스레드가 시간 초과로 인해 종료되지 않았습니다.\n");
}

결론

pthread_join()은 강력한 스레드 관리 도구이지만, 예외 상황에 대비한 방어적 프로그래밍이 필요합니다. 스레드 상태와 동작을 철저히 관리하면 예기치 않은 오류와 프로그램 충돌을 방지할 수 있습니다.

효율적인 스레드 관리 전략

멀티스레딩 환경에서는 스레드의 생성, 동기화, 종료, 리소스 관리를 체계적으로 수행하는 것이 중요합니다. pthread_join()과 함께 사용할 수 있는 효율적인 스레드 관리 전략을 살펴보겠습니다.

스레드 풀(Thread Pool) 활용

개념:
스레드 풀은 미리 생성된 스레드 집합으로 작업을 처리하는 구조입니다. 스레드 생성 및 종료의 오버헤드를 줄이고, 스레드 재사용을 통해 성능을 향상시킬 수 있습니다.
장점:

스레드 관리 간소화
시스템 리소스 절약
고정된 스레드 수를 유지하여 과도한 스레드 생성 방지

예제:

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

   #define THREAD_POOL_SIZE 4

   pthread_t thread_pool[THREAD_POOL_SIZE];
   int task_queue[10];
   int task_count = 0;

   void* thread_task(void* arg) {
       int* task = (int*)arg;
       printf("스레드에서 작업 처리: %d\n", *task);
       return NULL;
   }

   void add_task(int task) {
       task_queue[task_count++] = task;
   }

   int main() {
       // 스레드 풀 생성
       for (int i = 0; i < THREAD_POOL_SIZE; i++) {
           pthread_create(&thread_pool[i], NULL, thread_task, &task_queue[i]);
       }

       // 작업 추가
       for (int i = 0; i < 10; i++) {
           add_task(i + 1);
       }

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

       printf("모든 작업 처리 완료\n");
       return 0;
   }

스레드 상태 관리

상태 추적:
스레드의 실행 여부, 종료 여부 등을 상태 변수로 관리합니다.

   typedef struct {
       pthread_t thread_id;
       int is_running;
   } ThreadStatus;

장점:

스레드 종료 및 동작 상태를 명확히 추적 가능
잘못된 스레드 접근 방지

작업 큐(Work Queue) 기반 스레드 관리

작업 큐 개념:
작업 큐는 작업을 저장하고 스레드가 작업을 하나씩 가져가 처리하는 구조입니다.
예제:

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

   #define QUEUE_SIZE 10

   typedef struct {
       int tasks[QUEUE_SIZE];
       int front, rear;
       pthread_mutex_t mutex;
   } TaskQueue;

   void init_queue(TaskQueue* queue) {
       queue->front = queue->rear = 0;
       pthread_mutex_init(&queue->mutex, NULL);
   }

   void enqueue(TaskQueue* queue, int task) {
       pthread_mutex_lock(&queue->mutex);
       queue->tasks[queue->rear] = task;
       queue->rear = (queue->rear + 1) % QUEUE_SIZE;
       pthread_mutex_unlock(&queue->mutex);
   }

   int dequeue(TaskQueue* queue) {
       pthread_mutex_lock(&queue->mutex);
       int task = queue->tasks[queue->front];
       queue->front = (queue->front + 1) % QUEUE_SIZE;
       pthread_mutex_unlock(&queue->mutex);
       return task;
   }

   void* process_task(void* arg) {
       TaskQueue* queue = (TaskQueue*)arg;
       while (1) {
           int task = dequeue(queue);
           printf("작업 처리: %d\n", task);
       }
   }

   int main() {
       pthread_t thread;
       TaskQueue queue;
       init_queue(&queue);

       // 작업 추가
       for (int i = 0; i < 5; i++) {
           enqueue(&queue, i + 1);
       }

       // 스레드 생성
       pthread_create(&thread, NULL, process_task, &queue);
       pthread_join(thread, NULL);

       return 0;
   }

적절한 동기화 도구 사용

뮤텍스(Mutex): 스레드 간 데이터 경쟁 방지
조건 변수(Condition Variable): 특정 조건에서 스레드 대기 및 실행
세마포어(Semaphore): 리소스 접근 제한

결론

효율적인 스레드 관리는 프로그램 성능을 향상시키고, 리소스 사용을 최적화하며, 멀티스레딩 환경에서의 안정성을 보장합니다. pthread_join()과 함께 스레드 풀, 작업 큐, 동기화 도구를 활용하면 복잡한 작업도 효과적으로 처리할 수 있습니다.

실습: 간단한 멀티스레딩 프로그램 작성

이 섹션에서는 pthread_join()을 활용한 멀티스레딩 프로그램을 작성하고, 이를 통해 스레드 종료 대기와 동기화의 실질적인 예를 확인합니다.

프로그램 목표

다수의 스레드가 독립적으로 작업을 수행하며, 각 스레드의 작업 결과를 수집해 출력하는 간단한 프로그램을 작성합니다.

예제 코드

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

#define THREAD_COUNT 3

typedef struct {
    int thread_id;
    int result;
} ThreadData;

void* thread_task(void* arg) {
    ThreadData* data = (ThreadData*)arg;
    printf("스레드 %d 작업 중...\n", data->thread_id);

    // 간단한 작업 수행 (예: ID의 제곱 계산)
    data->result = data->thread_id * data->thread_id;
    printf("스레드 %d 작업 완료: 결과 = %d\n", data->thread_id, data->result);

    return NULL;
}

int main() {
    pthread_t threads[THREAD_COUNT];
    ThreadData thread_data[THREAD_COUNT];

    // 스레드 생성
    for (int i = 0; i < THREAD_COUNT; i++) {
        thread_data[i].thread_id = i + 1; // 스레드 ID 설정
        if (pthread_create(&threads[i], NULL, thread_task, &thread_data[i]) != 0) {
            perror("스레드 생성 실패");
            exit(EXIT_FAILURE);
        }
    }

    // 스레드 종료 대기
    for (int i = 0; i < THREAD_COUNT; i++) {
        if (pthread_join(threads[i], NULL) != 0) {
            perror("스레드 조인 실패");
            exit(EXIT_FAILURE);
        }
        printf("스레드 %d 종료 확인: 결과 = %d\n", thread_data[i].thread_id, thread_data[i].result);
    }

    printf("모든 스레드 작업 완료\n");
    return 0;
}

코드 설명

스레드 데이터 구조 정의

ThreadData 구조체는 각 스레드의 ID와 작업 결과를 저장합니다.

스레드 생성

pthread_create()를 사용해 3개의 스레드를 생성합니다. 각 스레드에 ID와 작업 정보를 전달합니다.

스레드 작업

각 스레드는 전달받은 ID의 제곱을 계산하고 결과를 구조체에 저장합니다.

스레드 종료 대기

pthread_join()으로 각 스레드가 종료될 때까지 대기하고, 종료 후 작업 결과를 확인합니다.

결과 출력

모든 스레드의 작업 결과를 출력하고 프로그램을 종료합니다.

실행 결과

스레드 1 작업 중...
스레드 2 작업 중...
스레드 3 작업 중...
스레드 1 작업 완료: 결과 = 1
스레드 2 작업 완료: 결과 = 4
스레드 3 작업 완료: 결과 = 9
스레드 1 종료 확인: 결과 = 1
스레드 2 종료 확인: 결과 = 4
스레드 3 종료 확인: 결과 = 9
모든 스레드 작업 완료

결론

이 예제는 pthread_join()을 통해 다중 스레드의 작업 종료를 기다리고, 각 스레드의 결과를 안전하게 수집하는 방법을 보여줍니다. 이를 활용하면 멀티스레딩 환경에서 동기화와 리소스 관리를 효과적으로 수행할 수 있습니다.

요약

본 기사에서는 C언어에서 pthread_join()을 활용하여 스레드 종료 대기와 동기화를 구현하는 방법을 다뤘습니다. pthread_join()의 역할, 기본 사용법, 동기화 문제 해결, 예외 처리, 그리고 효율적인 스레드 관리 전략을 설명하며, 실습 예제를 통해 이를 실질적으로 구현하는 방법을 확인했습니다.

이제 pthread_join()을 활용하여 멀티스레딩 프로그램의 안정성과 효율성을 높일 수 있습니다.