POSIX 스레드(pthread) 라이브러리에서 스레드를 생성할 때, 기본 동작을 변경하기 위해 스레드 속성(thread attributes)을 사용할 수 있습니다. 이 속성들은 pthread_attr_t 타입의 구조체에 캡슐화되어 있으며, 스레드의 다양한 동작 방식을 제어합니다. 다음은 pthread_attr_t 구조체의 주요 멤버들입니다.
typedef struct
{
int detachstate; // 스레드 분리 상태 (detached/joinable)
int schedpolicy; // 스레드 스케줄링 정책
struct sched_param schedparam; // 스레드 스케줄링 매개변수
int inheritsched; // 스레드 스케줄링 상속 여부
int scope; // 스레드 경쟁 범위 (system/process)
size_t guardsize; // 스레드 스택 끝의 가드 페이지 크기
void* stackaddr; // 스레드 스택 시작 주소
size_t stacksize; // 스레드 스택 크기
} pthread_attr_t;
이 속성들은 pthread_attr_init() 함수로 초기화한 후, 각 속성별 설정 함수(pthread_attr_set*)로 값을 변경하고, pthread_create() 함수에 전달하여 새로운 스레드에 적용합니다. 사용 후에는 pthread_attr_destroy()로 리소스를 해제해야 합니다.
1. 스레드 분리 상태 (detachstate)
detachstate 속성은 스레드가 종료될 때 시스템 자원을 어떻게 처리할지 결정합니다.
PTHREAD_CREATE_JOINABLE (기본값)
이 상태의 스레드는 다른 스레드에 의해 조인(join)될 수 있습니다. 부모 스레드 또는 다른 스레드가 pthread_join() 함수를 호출하여 해당 스레드의 종료를 기다리고, 스레드가 사용하던 자원을 회수할 수 있습니다. pthread_join()이 호출되기 전까지는 스레드가 종료되어도 일부 시스템 자원이 해제되지 않고 남아있을 수 있습니다. 이는 "좀비 스레드"와 유사한 현상으로, 자원 누수를 유발할 수 있습니다.
PTHREAD_CREATE_DETACHED
분리된 스레드는 다른 스레드에 의해 조인될 수 없습니다. 스레드가 종료되면 시스템이 즉시 모든 자원을 자동으로 회수합니다. 따라서, 스레드의 실행 결과를 기다릴 필요가 없는 "일회성" 작업에 적합합니다. 자원 누수를 방지하기 위해 명시적으로 분리 상태로 설정하는 경우가 많습니다.
사용 예제 및 자원 해제
pthread_exit() 함수는 스레드를 종료시키지만, 스레드가 사용한 시스템 자원(예: 스택 공간)을 즉시 해제하지 않습니다. 이 자원들은 pthread_join()이 호출되거나, 스레드가 분리 상태로 생성되었을 때 비로소 해제됩니다. 다음 예제는 pthread_join() 또는 분리 상태 설정의 중요성을 보여줍니다.
먼저, pthread_join() 없이 수많은 스레드를 생성할 때 발생하는 자원 고갈 문제를 살펴보겠습니다. 스레드가 종료되더라도 자원이 회수되지 않아 시스템 자원이 소진됩니다.
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void* worker_function(void* arg) {
// 스레드는 이 함수가 끝날 때 자동으로 종료되므로
// pthread_exit(NULL) 호출은 필수는 아닙니다.
return NULL;
}
int main() {
pthread_t thread_id;
int creation_result;
long created_count = 0;
printf("pthread_join 없이 스레드 생성 시도 (JOINABLE 기본 상태)\n");
while (1) {
// 두 번째 인자로 NULL을 전달하여 기본 속성(JOINABLE) 사용
creation_result = pthread_create(&thread_id, NULL, worker_function, NULL);
if (creation_result != 0) {
fprintf(stderr, "오류: 스레드 생성 실패 (코드: %d). 생성된 스레드 수: %ld\n", creation_result, created_count);
perror("세부 정보");
break; // 스레드 생성 실패 시 루프 종료
}
// pthread_join(thread_id, NULL); // 이 부분을 주석 처리하면 자원 누수 발생
if (++created_count % 100 == 0) {
printf("%ld개 스레드 생성됨...\n", created_count);
}
}
printf("최종 생성된 스레드 수: %ld\n", created_count);
return 0;
}
위 코드를 실행하면 결국 스레드 생성에 실패하며 "Resource temporarily unavailable"과 같은 오류 메시지를 보게 될 것입니다. 이는 pthread_join()을 호출하지 않아 JOINABLE 상태의 스레드 자원이 회수되지 않기 때문입니다. 주석 처리된 pthread_join(thread_id, NULL); 라인의 주석을 해제하면, 스레드가 생성될 때마다 그 종료를 기다리고 자원을 회수하므로 무한히 스레드를 생성할 수 있습니다.
이번에는 스레드를 분리 상태로 생성하여 동일한 자원 고갈 문제를 해결하는 방법을 보여줍니다.
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void* detached_worker_function(void* arg) {
return NULL;
}
int main() {
pthread_t thread_id;
pthread_attr_t thread_attributes;
int creation_result;
long created_count = 0;
// 스레드 속성 객체 초기화
pthread_attr_init(&thread_attributes);
// 분리 상태로 설정
pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_DETACHED);
printf("분리 상태 스레드 생성 시도\n");
while (1) {
creation_result = pthread_create(&thread_id, &thread_attributes, detached_worker_function, NULL);
if (creation_result != 0) {
fprintf(stderr, "오류: 스레드 생성 실패 (코드: %d). 생성된 스레드 수: %ld\n", creation_result, created_count);
perror("세부 정보");
break;
}
if (++created_count % 100 == 0) {
printf("%ld개 스레드 생성됨...\n", created_count);
}
}
printf("최종 생성된 스레드 수: %ld\n", created_count);
// 속성 객체 리소스 해제
pthread_attr_destroy(&thread_attributes);
return 0;
}
이 코드에서는 pthread_create() 시 스레드 속성 객체에 PTHREAD_CREATE_DETACHED를 설정하여 전달합니다. 이렇게 하면 스레드가 종료될 때 시스템이 자동으로 자원을 회수하므로, 무한 루프 내에서 스레드를 생성해도 자원 고갈 없이 계속 실행될 것입니다.
현재 스레드 속성에서 분리 상태를 조회하거나 설정하는 함수는 다음과 같습니다.
#include <pthread.h>
#include <stdio.h>
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs); // 속성 객체 초기화
int current_detach_state;
pthread_attr_getdetachstate(¤t_attrs, ¤t_detach_state);
if (PTHREAD_CREATE_JOINABLE == current_detach_state) {
printf("현재 스레드 분리 상태: PTHREAD_CREATE_JOINABLE\n");
} else if (PTHREAD_CREATE_DETACHED == current_detach_state) {
printf("현재 스레드 분리 상태: PTHREAD_CREATE_DETACHED\n");
}
// 분리 상태를 PTHREAD_CREATE_DETACHED로 설정
pthread_attr_setdetachstate(¤t_attrs, PTHREAD_CREATE_DETACHED);
printf("스레드 분리 상태를 PTHREAD_CREATE_DETACHED로 설정했습니다.\n");
pthread_attr_destroy(¤t_attrs); // 속성 객체 해제
2. 스레드 스케줄링 정책 (schedpolicy)
schedpolicy는 스레드가 CPU 시간을 할당받는 방식을 결정합니다. Linux 커널은 기본적으로 순환 시간 공유(Round-Robin Time-Sharing) 정책인 SCHED_OTHER를 사용합니다. 실시간 스케줄링 정책에는 SCHED_FIFO와 SCHED_RR이 있으며, 이들은 일반적으로 1(낮음)부터 99(높음)까지의 우선순위를 가집니다.
SCHED_FIFO (First-In, First-Out)
- 동일 우선순위의 실시간 스레드: 먼저 실행을 시작한 스레드가 CPU를 선점하고, 자발적으로 CPU를 포기하거나 블록킹될 때까지 실행을 계속합니다. 다른 동일 우선순위 스레드는 대기합니다.
- 다른 우선순위의 실시간 스레드: 더 높은 우선순위의 스레드는 현재 실행 중인 낮은 우선순위의 스레드를 선점할 수 있습니다.
- 시간 할당량(time slice) 개념이 없습니다.
SCHED_RR (Round-Robin)
- 동일 우선순위의 실시간 스레드: 각 스레드는 정해진 시간 할당량(time slice) 동안 실행됩니다. 시간 할당량이 만료되면, 동일 우선순위의 다음 스레드가 실행됩니다.
- 다른 우선순위의 실시간 스레드: 더 높은 우선순위의 스레드는 현재 실행 중인 낮은 우선순위의 스레드를 선점할 수 있습니다.
SCHED_OTHER (Default Time-Sharing)
- 일반적인 스레드의 기본 스케줄링 정책입니다. 우선순위 개념이 없으며, 모든 스레드가 CPU 시간을 공유합니다. 커널의 휴리스틱(heuristic)에 따라 스레드에 CPU 시간이 할당됩니다.
스케줄링 정책을 조회하고 설정하는 방법은 다음과 같습니다.
#include <pthread.h>
#include <stdio.h>
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs);
int current_policy;
pthread_attr_getschedpolicy(¤t_attrs, ¤t_policy);
printf("현재 스케줄링 정책: ");
if (current_policy == SCHED_FIFO) {
printf("SCHED_FIFO\n");
} else if (current_policy == SCHED_RR) {
printf("SCHED_RR\n");
} else if (current_policy == SCHED_OTHER) {
printf("SCHED_OTHER\n");
} else {
printf("알 수 없는 정책 (%d)\n", current_policy);
}
// 스케줄링 정책을 SCHED_RR로 설정
// 실시간 정책을 사용하려면 inheritsched를 PTHREAD_EXPLICIT_SCHED로 설정해야 합니다.
pthread_attr_setschedpolicy(¤t_attrs, SCHED_RR);
printf("스케줄링 정책을 SCHED_RR로 설정했습니다.\n");
pthread_attr_destroy(¤t_attrs);
3. 스케줄링 매개변수 (schedparam)
schedparam 속성은 스레드의 스케줄링 우선순위를 정의합니다. 이는 struct sched_param 구조체로 표현되며, 주로 sched_priority 멤버를 통해 우선순위 값을 설정합니다. 값이 클수록 높은 우선순위를 의미합니다.
struct sched_param
{
int sched_priority; // 스케줄링 우선순위
};
시스템이 지원하는 최대 및 최소 우선순위 값은 sched_get_priority_max()와 sched_get_priority_min() 함수로 얻을 수 있습니다.
#include <pthread.h>
#include <stdio.h>
#include <sched.h> // sched_param 구조체 및 우선순위 함수를 위해
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs);
struct sched_param current_params;
int result_code = pthread_attr_getschedparam(¤t_attrs, ¤t_params);
if (result_code == 0) {
printf("현재 스케줄링 우선순위: %d\n", current_params.sched_priority);
} else {
perror("pthread_attr_getschedparam 실패");
}
// 우선순위 값을 85로 설정 (실시간 스케줄링 정책 사용 시 유효)
current_params.sched_priority = 85;
pthread_attr_setschedparam(¤t_attrs, ¤t_params);
printf("스케줄링 우선순위를 %d로 설정했습니다.\n", current_params.sched_priority);
pthread_attr_destroy(¤t_attrs);
주의: 실시간 애플리케이션이 아닌 일반적인 환경에서 스레드의 우선순위를 변경하는 것은 복잡한 문제를 야기할 수 있습니다. 예를 들어, 공유 자원에 대한 접근 순서에 따라 우선순위 역전(priority inversion)이 발생하여 데드락과 같은 예측 불가능한 동작을 초래할 수 있습니다. 신중한 설계와 테스트 없이 우선순위 변경은 지양해야 합니다.
4. 스케줄링 상속성 (inheritsched)
inheritsched 속성은 새로 생성되는 스레드가 스케줄링 속성(정책 및 매개변수)을 어떻게 결정할지 지정합니다.
PTHREAD_INHERIT_SCHED (기본값)
새 스레드는 자신을 생성한 스레드의 스케줄링 정책과 매개변수를 상속받습니다.
PTHREAD_EXPLICIT_SCHED
새 스레드의 스케줄링 정책과 매개변수는 pthread_attr_setschedpolicy() 및 pthread_attr_setschedparam() 함수를 통해 명시적으로 설정된 값에 따릅니다. 실시간 스케줄링 정책을 적용하려면 이 값을 설정해야 합니다.
#include <pthread.h>
#include <stdio.h>
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs);
int current_inherit_sched;
pthread_attr_getinheritsched(¤t_attrs, ¤t_inherit_sched);
if (PTHREAD_INHERIT_SCHED == current_inherit_sched) {
printf("현재 스케줄링 상속성: PTHREAD_INHERIT_SCHED\n");
} else if (PTHREAD_EXPLICIT_SCHED == current_inherit_sched) {
printf("현재 스케줄링 상속성: PTHREAD_EXPLICIT_SCHED\n");
}
// 스케줄링 상속성을 PTHREAD_EXPLICIT_SCHED로 설정
pthread_attr_setinheritsched(¤t_attrs, PTHREAD_EXPLICIT_SCHED);
printf("스케줄링 상속성을 PTHREAD_EXPLICIT_SCHED로 설정했습니다.\n");
pthread_attr_destroy(¤t_attrs);
5. 스레드 경쟁 범위 (scope)
scope 속성은 스레드가 스케줄링 경쟁을 벌이는 범위를 정의합니다.
PTHREAD_SCOPE_SYSTEM
스레드는 시스템의 모든 스레드(다른 프로세스의 스레드 포함)와 경쟁합니다. 운영체제 커널이 스케줄링을 관리하며, 스레드는 시스템 전체에서 우선순위에 따라 CPU 시간을 할당받습니다.
PTHREAD_SCOPE_PROCESS (Linux에서 미지원)
스레드는 동일 프로세스 내의 다른 스레드하고만 경쟁합니다. 이 모델은 사용자 수준 스레딩 라이브러리에서 스케줄링을 구현할 때 사용될 수 있으나, Linux 시스템에서는 일반적으로 지원되지 않습니다.
#include <pthread.h>
#include <stdio.h>
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs);
int current_scope;
pthread_attr_getscope(¤t_attrs, ¤t_scope);
if (PTHREAD_SCOPE_PROCESS == current_scope) {
printf("현재 경쟁 범위: PTHREAD_SCOPE_PROCESS (Linux에서 일반적으로 미지원)\n");
} else if (PTHREAD_SCOPE_SYSTEM == current_scope) {
printf("현재 경쟁 범위: PTHREAD_SCOPE_SYSTEM\n");
} else {
printf("알 수 없는 경쟁 범위 (%d)\n", current_scope);
}
// PTHREAD_SCOPE_SYSTEM으로 설정 (대부분의 시스템에서 기본값이자 유일하게 지원되는 값)
pthread_attr_setscope(¤t_attrs, PTHREAD_SCOPE_SYSTEM);
printf("경쟁 범위를 PTHREAD_SCOPE_SYSTEM으로 설정했습니다.\n");
pthread_attr_destroy(¤t_attrs);
6. 스택 가드 페이지 크기 (guardsize)
guardsize 속성은 스레드 스택의 끝에 할당되는 "가드 페이지"의 크기를 지정합니다. 가드 페이지는 스택 오버플로우를 감지하기 위해 사용됩니다. 스레드가 자신의 스택 경계를 넘어 가드 페이지에 접근하려 하면, 시스템은 일반적으로 SIGSEGV 신호를 발생시켜 오류를 알립니다. 기본값은 시스템의 메모리 페이지 크기(일반적으로 4096바이트)입니다.
#include <pthread.h>
#include <stdio.h>
#include <errno.h> // errno를 위해
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs);
size_t current_guard_size;
int ret_val = pthread_attr_getguardsize(¤t_attrs, ¤t_guard_size);
if (ret_val != 0) {
fprintf(stderr, "pthread_attr_getguardsize 오류: %s\n", strerror(ret_val));
} else {
printf("현재 스택 가드 페이지 크기: %zu 바이트\n", current_guard_size);
}
// 가드 페이지 크기를 8192바이트로 설정 (두 페이지)
pthread_attr_setguardsize(¤t_attrs, 8192);
printf("스택 가드 페이지 크기를 8192 바이트로 설정했습니다.\n");
pthread_attr_destroy(¤t_attrs);
7. 스택 시작 주소 (stackaddr)
stackaddr 속성은 스레드가 사용할 스택의 시작 주소를 명시적으로 지정할 때 사용됩니다. 일반적으로 시스템이 스택 메모리를 자동으로 할당하므로 이 속성을 직접 설정하는 경우는 드뭅니다. 스택 메모리는 malloc() 등으로 수동으로 할당해야 하며, stacksize와 함께 사용해야 합니다.
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h> // malloc을 위해
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs);
void* custom_stack_addr = NULL;
// pthread_attr_getstackaddr(¤t_attrs, &custom_stack_addr); // 기본값은 NULL 또는 0
// 사용자 정의 스택 메모리 할당 (예: PTHREAD_STACK_MIN 보다 크게)
size_t custom_stack_size = PTHREAD_STACK_MIN * 2;
void* allocated_stack = malloc(custom_stack_size);
if (allocated_stack == NULL) {
perror("스택 메모리 할당 실패");
pthread_attr_destroy(¤t_attrs);
// return EXIT_FAILURE;
}
// 할당된 스택 메모리 주소와 크기 설정
pthread_attr_setstackaddr(¤t_attrs, allocated_stack);
pthread_attr_setstacksize(¤t_attrs, custom_stack_size);
printf("사용자 정의 스택 주소: %p, 크기: %zu 바이트 설정\n", allocated_stack, custom_stack_size);
// 스레드 생성 시 custom_attrs를 사용
// ...
// 사용 후 할당된 메모리 해제
// free(allocated_stack); // 스레드 종료 후 해제 필요
pthread_attr_destroy(¤t_attrs);
8. 스택 크기 (stacksize)
stacksize 속성은 스레드가 사용할 스택의 최소 크기를 바이트 단위로 지정합니다. 기본 스택 크기는 시스템에 따라 다르지만, 특정 스레드가 많은 지역 변수나 깊은 함수 호출을 사용하는 경우 이 값을 늘려야 할 수 있습니다. PTHREAD_STACK_MIN은 시스템이 보장하는 최소 스택 크기입니다.
#include <pthread.h>
#include <stdio.h>
#include <errno.h>
// ... (속성 초기화 및 사용 전)
pthread_attr_t current_attrs;
pthread_attr_init(¤t_attrs);
size_t current_stack_size;
int ret_val = pthread_attr_getstacksize(¤t_attrs, ¤t_stack_size);
if (ret_val != 0) {
fprintf(stderr, "pthread_attr_getstacksize 오류: %s\n", strerror(ret_val));
} else {
printf("현재 스택 크기: %zu 바이트\n", current_stack_size);
}
// 스택 크기를 PTHREAD_STACK_MIN의 4배로 설정
pthread_attr_setstacksize(¤t_attrs, PTHREAD_STACK_MIN * 4);
printf("스택 크기를 %zu 바이트로 설정했습니다.\n", PTHREAD_STACK_MIN * 4);
pthread_attr_destroy(¤t_attrs);
9. 현재 스레드 ID 조회 (pthread_self())
pthread_self() 함수는 현재 실행 중인 스레드의 고유 ID를 반환합니다. 이 ID는 특정 스레드를 식별하거나, 스레드 간의 비교에 사용될 수 있습니다.
#include <pthread.h>
#include <stdio.h>
void* my_thread_func(void* arg) {
pthread_t current_tid = pthread_self();
printf("현재 스레드의 ID: %lu\n", (unsigned long)current_tid); // tid를 정수로 출력
return NULL;
}
int main() {
pthread_t new_thread;
pthread_create(&new_thread, NULL, my_thread_func, NULL);
pthread_join(new_thread, NULL);
return 0;
}
10. 한 번만 실행되는 초기화 (pthread_once)
멀티스레드 환경에서 특정 초기화 작업을 전체 프로그램 실행 동안 단 한 번만 수행해야 하는 경우가 있습니다. 예를 들어, 공유 자원을 설정하거나 특정 모듈을 로드하는 작업 등입니다. pthread_once는 이러한 "한 번만" 초기화 작업을 안전하게 수행하도록 보장합니다.
정적 변수를 이용한 일반적인 문제점
단일 스레드 환경에서는 정적 플래그 변수를 사용하여 한 번만 초기화하는 것이 가능합니다. 하지만 여러 스레드가 동시에 접근할 때 경쟁 조건(race condition)이 발생할 수 있습니다.
#include <pthread.h>
#include <stdio.h>
#include <unistd.h> // sleep을 위해
void perform_critical_init() {
printf("---- 중요 초기화 작업 실행 ----\n");
// 초기화 작업 (시간이 소요될 수 있음)
sleep(1);
}
// 정적 플래그를 사용하는 함수
void access_resource_with_static_flag() {
static int init_done_flag = 0; // 초기화 플래그 (정적 변수)
// 여러 스레드가 동시에 이 부분을 실행하면 여러 번 초기화될 수 있음
if (init_done_flag == 0) {
perform_critical_init();
init_done_flag = 1; // 플래그 설정
} else {
printf("초기화 작업은 이미 완료되었습니다.\n");
}
}
void* static_flag_worker(void* arg) {
access_resource_with_static_flag();
pthread_exit(NULL);
}
int main() {
pthread_t thread_handles[3];
printf("정적 플래그를 사용한 동시 초기화 시도:\n");
// 세 개의 스레드를 동시에 생성하고 실행
for (int i = 0; i < 3; ++i) {
pthread_create(&thread_handles[i], NULL, static_flag_worker, NULL);
}
// 모든 스레드가 종료될 때까지 대기
for (int i = 0; i < 3; ++i) {
pthread_join(thread_handles[i], NULL);
}
printf("모든 스레드 종료.\n");
return 0;
}
위 코드에서는 init_done_flag가 정적 변수임에도 불구하고, 여러 스레드가 동시에 if (init_done_flag == 0) 조건을 확인하고 init_done_flag = 1로 설정하기 전에 perform_critical_init()을 실행하여 "---- 중요 초기화 작업 실행 ----" 메시지가 여러 번 출력될 수 있습니다. 이는 동기화 문제가 없는 단순한 정적 플래그의 한계를 보여줍니다.
pthread_once를 이용한 안전한 초기화
pthread_once 함수는 지정된 초기화 루틴이 프로그램 실행 중 단 한 번만 호출되도록 보장합니다. 이는 내부적으로 뮤텍스(mutex)와 같은 동기화 메커니즘을 사용하여 구현됩니다.
#include <pthread.h>
#include <stdio.h>
#include <unistd.h> // sleep을 위해
// pthread_once_t 타입의 제어 변수를 PTHREAD_ONCE_INIT으로 초기화
static pthread_once_t once_control_variable = PTHREAD_ONCE_INIT;
// 단 한 번만 실행될 초기화 함수
void one_time_initialization_routine() {
printf("---- pthread_once로 제어되는 초기화 작업 실행 ----\n");
// 복잡한 자원 설정 또는 모듈 로딩 등
sleep(1);
}
// 여러 스레드가 호출할 수 있는 함수
void access_resource_with_once() {
// 이 함수가 여러 스레드에 의해 동시에 호출되더라도
// one_time_initialization_routine은 단 한 번만 실행됨
pthread_once(&once_control_variable, one_time_initialization_routine);
printf("초기화 후 자원 접근 중...\n");
}
void* once_worker(void* arg) {
access_resource_with_once();
pthread_exit(NULL);
}
int main() {
pthread_t thread_handles[3];
printf("pthread_once를 사용한 동시 초기화 시도:\n");
// 세 개의 스레드를 동시에 생성하고 실행
for (int i = 0; i < 3; ++i) {
pthread_create(&thread_handles[i], NULL, once_worker, NULL);
}
// 모든 스레드가 종료될 때까지 대기
for (int i = 0; i < 3; ++i) {
pthread_join(thread_handles[i], NULL);
}
printf("모든 스레드 종료.\n");
return 0;
}
이 예제에서는 pthread_once(&once_control_variable, one_time_initialization_routine) 호출 덕분에 one_time_initialization_routine() 함수가 단 한 번만 실행됩니다. 첫 번째 스레드가 pthread_once를 호출하면 초기화 루틴이 실행되고, 다른 스레드들은 첫 번째 스레드가 초기화를 완료할 때까지 기다린 후, 초기화 루틴을 다시 실행하지 않고 다음 코드를 진행합니다.