C언어에서 alarm() 시스템 호출로 타이머 설정하기

C언어에서 alarm() 시스템 호출은 간단한 타이머를 설정하는 데 사용됩니다. 이 함수는 특정 시간이 지나면 프로세스에 SIGALRM 시그널을 전달하여 미리 정의된 작업을 수행하도록 돕습니다. 서버 프로세스의 시간 제한 설정, 주기적인 알림, 혹은 실행 시간을 제한하는 간단한 구현에서 자주 활용됩니다. 본 기사에서는 alarm()의 기본 동작부터 다양한 활용법까지 살펴보겠습니다.

`alarm()` 함수란?

alarm() 함수는 C 언어의 유닉스 시스템 호출 중 하나로, 특정 초(seconds)가 지나면 현재 프로세스에 SIGALRM 시그널을 보내는 역할을 합니다. 이 함수는 주로 실행 시간을 제한하거나, 정해진 간격으로 이벤트를 트리거해야 하는 상황에서 사용됩니다.

동작 원리

alarm() 함수는 타이머를 설정하여, 지정된 시간이 경과했을 때 프로세스가 SIGALRM 시그널을 받을 수 있도록 합니다. 이 시그널을 통해 호출자는 시그널 핸들러를 정의하거나 특정 작업을 수행할 수 있습니다.

기본 시나리오

호출자가 alarm(seconds)를 호출하면, seconds 후에 SIGALRM 시그널이 전달됩니다.
타이머가 이미 설정된 경우, 이전 타이머가 취소되고 새 타이머가 설정됩니다.
인수로 0을 전달하면 현재 설정된 타이머가 취소됩니다.

이 함수는 간단하지만 강력한 시간 기반 제어 메커니즘을 제공합니다.

`alarm()` 함수의 사용법

alarm() 함수는 간단한 인터페이스를 제공하며, 타이머를 설정하는 데 사용됩니다. 다음은 이 함수의 시그니처와 사용법에 대한 자세한 설명입니다.

함수 시그니처

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

매개변수:
seconds: 타이머가 만료될 때까지의 초 단위 시간.
반환값:
이전 타이머가 만료되기까지 남아 있던 시간(초 단위).
이전에 설정된 타이머가 없었다면 0을 반환합니다.

기본 사용법

alarm()을 호출하면 설정된 시간이 지난 후 프로세스에 SIGALRM 시그널이 전달됩니다.

예제

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

void alarm_handler(int signum) {
    printf("Alarm triggered! Signal: %d\n", signum);
}

int main() {
    signal(SIGALRM, alarm_handler);  // SIGALRM 핸들러 등록
    printf("Setting an alarm for 5 seconds.\n");
    alarm(5);  // 5초 후 SIGALRM 발생

    pause();  // 시그널 대기
    return 0;
}

주요 동작

alarm(seconds) 호출 후, seconds 동안 기다립니다.
시간이 경과하면, 프로세스에 SIGALRM 시그널이 전달됩니다.
시그널 핸들러(alarm_handler)가 실행되어 관련 작업을 수행합니다.

타이머 취소

alarm(0)을 호출하면 현재 설정된 타이머를 취소할 수 있습니다.

예제

alarm(0);  // 타이머 취소

이 함수는 간단한 타이머 설정에 매우 유용하며, 다른 함수나 기능과 결합하여 다양한 응용이 가능합니다.

간단한 타이머 구현 예제

alarm() 함수를 사용하여 간단한 타이머를 구현할 수 있습니다. 이 예제는 타이머가 만료되면 메시지를 출력하는 프로그램을 보여줍니다.

코드 예제: 간단한 타이머

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

// SIGALRM 시그널 핸들러
void timer_handler(int signum) {
    printf("Timer expired! Signal: %d\n", signum);
}

int main() {
    // SIGALRM에 대한 핸들러 설정
    signal(SIGALRM, timer_handler);

    // 타이머 설정
    printf("Setting a 3-second timer...\n");
    alarm(3);  // 3초 후 SIGALRM 시그널 발생

    // 타이머 만료 전까지 대기
    pause();  // 시그널 발생을 대기하는 블로킹 함수

    printf("Program exiting.\n");
    return 0;
}

출력 예시

프로그램을 실행하면 다음과 같은 출력이 표시됩니다.

Setting a 3-second timer...
Timer expired! Signal: 14
Program exiting.

코드 설명

시그널 핸들러 등록: signal(SIGALRM, timer_handler)는 SIGALRM 시그널이 발생했을 때 실행될 함수(timer_handler)를 지정합니다.
타이머 설정: alarm(3)은 3초 후에 SIGALRM 시그널을 발생시킵니다.
시그널 대기: pause() 함수는 시그널이 발생할 때까지 프로그램 실행을 중단합니다.
핸들러 실행: 3초 후, timer_handler가 호출되어 “Timer expired!” 메시지를 출력합니다.

응용 예시

이 간단한 타이머는 다음과 같은 응용 프로그램에 사용될 수 있습니다.

네트워크 요청 제한: 특정 시간 동안만 대기 후 작업 중단.
프로세스 관리: 실행 시간이 초과되었을 때 강제 종료.
반복적인 알림: 주기적으로 작업을 수행하는 경우.

이 예제는 alarm() 함수의 기본 사용법을 익히고, 더 복잡한 프로그램에 적용하기 위한 출발점이 됩니다.

시그널 처리와 `SIGALRM`

alarm() 함수의 핵심은 타이머 만료 시 발생하는 SIGALRM 시그널입니다. 이 시그널은 프로세스가 지정된 시간이 지나면 특정 작업을 수행할 수 있도록 도와줍니다. 이번 항목에서는 SIGALRM 시그널의 개념과 이를 처리하는 방법에 대해 살펴봅니다.

`SIGALRM` 시그널이란?

SIGALRM은 POSIX 표준에서 정의된 시그널 중 하나로, alarm() 함수에 의해 발생합니다.

타이머가 만료되면 프로세스에 SIGALRM 시그널이 전달됩니다.
기본 동작은 프로세스를 종료하는 것이지만, 이를 커스터마이징하기 위해 시그널 핸들러를 사용할 수 있습니다.

시그널 핸들러 설정

SIGALRM 시그널을 처리하려면 사용자 정의 시그널 핸들러를 설정해야 합니다. 이를 위해 signal() 또는 sigaction() 함수를 사용합니다.

`signal()` 함수로 핸들러 설정

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

void alarm_handler(int signum) {
    printf("Received SIGALRM! Signal: %d\n", signum);
}

int main() {
    signal(SIGALRM, alarm_handler);  // SIGALRM 핸들러 등록
    alarm(5);  // 5초 타이머 설정

    printf("Waiting for the alarm...\n");
    pause();  // 시그널 발생 대기

    return 0;
}

`sigaction()` 함수로 핸들러 설정

sigaction()은 더 정교한 시그널 처리 옵션을 제공합니다.

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

void alarm_handler(int signum) {
    printf("SIGALRM received! Signal: %d\n", signum);
}

int main() {
    struct sigaction sa;
    sa.sa_handler = alarm_handler;  // 핸들러 지정
    sa.sa_flags = 0;  // 기본 동작 설정
    sigemptyset(&sa.sa_mask);

    sigaction(SIGALRM, &sa, NULL);  // SIGALRM에 대해 설정
    alarm(5);  // 5초 타이머 설정

    printf("Waiting for the alarm...\n");
    pause();  // 시그널 발생 대기

    return 0;
}

핸들러 실행 흐름

타이머 설정 후, 지정된 시간이 경과하면 SIGALRM 시그널이 발생합니다.
등록된 핸들러 함수가 호출되어 정의된 작업을 수행합니다.
시그널 핸들러가 종료된 후, 프로그램은 원래 위치로 돌아옵니다.

활용 예시

간단한 타이머: 특정 작업을 일정 시간 후에 수행.
타임아웃 구현: 네트워크 연결이나 파일 처리 시 시간 제한 설정.
정기적 작업 수행: 주기적으로 알림이나 로그 저장.

주의사항

시그널 핸들러는 실행 중인 코드를 중단하고 호출되므로, 비동기적으로 실행되는 코드를 주의 깊게 작성해야 합니다.
중첩된 타이머 설정이나 다른 시그널과의 충돌을 피하려면 설계를 신중히 해야 합니다.

SIGALRM은 alarm()의 핵심 요소로, 시간 기반의 작업을 효과적으로 관리할 수 있는 강력한 도구입니다.

다양한 사용 사례

alarm() 함수는 단순한 타이머 이상의 다양한 상황에서 활용할 수 있습니다. 이번 항목에서는 alarm()의 대표적인 사용 사례를 살펴보고, 각 사례에 대한 간단한 구현 방법을 소개합니다.

1. 제한 시간 설정

특정 작업에 대해 제한 시간을 설정하고, 초과 시 작업을 중단하거나 경고를 출력할 수 있습니다.

예제: 제한 시간 초과 시 경고

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

void timeout_handler(int signum) {
    printf("Operation timed out!\n");
}

int main() {
    signal(SIGALRM, timeout_handler);  // 핸들러 등록
    alarm(10);  // 10초 제한 시간 설정

    printf("Performing an operation...\n");
    sleep(15);  // 작업이 제한 시간을 초과
    printf("Operation completed.\n");

    return 0;
}

출력:

Performing an operation...
Operation timed out!

2. 주기적인 알림

alarm()과 반복 호출을 결합하여 정기적으로 알림이나 작업을 수행할 수 있습니다.

예제: 매 5초마다 메시지 출력

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

void periodic_handler(int signum) {
    printf("5 seconds passed.\n");
    alarm(5);  // 다시 타이머 설정
}

int main() {
    signal(SIGALRM, periodic_handler);  // 핸들러 등록
    alarm(5);  // 첫 타이머 설정

    while (1) {
        pause();  // 시그널 대기
    }

    return 0;
}

출력(5초 간격):

5 seconds passed.
5 seconds passed.
...

3. 대화형 프로그램에서 유휴 시간 관리

대화형 프로그램에서 사용자의 입력 대기 중 유휴 시간이 지나면 경고를 표시하거나 대기를 종료할 수 있습니다.

예제: 입력 시간 초과

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

void idle_handler(int signum) {
    printf("\nNo input received. Exiting...\n");
    _exit(0);  // 프로그램 종료
}

int main() {
    signal(SIGALRM, idle_handler);  // 핸들러 등록
    alarm(10);  // 10초 입력 대기 시간 설정

    printf("Enter your input within 10 seconds: ");
    char input[100];
    if (fgets(input, sizeof(input), stdin) != NULL) {
        alarm(0);  // 타이머 취소
        printf("You entered: %s\n", input);
    }

    return 0;
}

출력(10초 초과 시):

Enter your input within 10 seconds: 
No input received. Exiting...

4. 시간 기반 테스트 및 모니터링

특정 시간 내에 함수가 얼마나 실행되는지 테스트하거나, 실행 시간을 초과했는지 확인하는 데 활용할 수 있습니다.

예제: 작업 실행 시간 측정

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

void timeout_handler(int signum) {
    printf("Function execution timed out!\n");
    _exit(1);  // 강제 종료
}

void long_running_task() {
    for (int i = 0; i < 10; ++i) {
        printf("Processing %d...\n", i);
        sleep(1);
    }
}

int main() {
    signal(SIGALRM, timeout_handler);  // 핸들러 등록
    alarm(5);  // 5초 실행 제한

    long_running_task();

    printf("Task completed within time.\n");
    return 0;
}

출력(5초 초과 시):

Processing 0...
Processing 1...
Processing 2...
Processing 3...
Processing 4...
Function execution timed out!

정리

alarm() 함수는 타이머 설정 외에도 다양한 방식으로 활용할 수 있습니다. 제한 시간 설정, 반복 알림, 대화형 프로그램에서의 유휴 시간 관리 등 여러 상황에서 프로그램의 효율성을 높이는 도구로 사용할 수 있습니다. 다양한 시나리오에 맞는 적절한 시그널 처리와 결합하여 효과적으로 활용할 수 있습니다.

제한 사항 및 주의점

alarm() 함수는 간단하고 유용하지만, 특정 상황에서는 예상치 못한 동작이나 문제가 발생할 수 있습니다. 이 항목에서는 alarm() 함수의 주요 제한 사항과 사용 시 주의해야 할 점을 다룹니다.

1. 단일 타이머만 지원

alarm() 함수는 한 번에 하나의 타이머만 설정할 수 있습니다.

새로운 alarm() 호출은 이전에 설정된 타이머를 덮어씁니다.
다중 타이머가 필요한 경우에는 setitimer() 또는 타이머 라이브러리 같은 대안을 고려해야 합니다.

예제: 타이머 덮어쓰기

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

void timer_handler(int signum) {
    printf("Timer expired!\n");
}

int main() {
    signal(SIGALRM, timer_handler);

    alarm(5);  // 첫 타이머 설정 (5초)
    sleep(2);
    alarm(3);  // 두 번째 타이머 설정 (5초 타이머 덮어쓰기)

    pause();
    return 0;
}

출력:

Timer expired!  (3초 후 발생)

2. 비정확한 타이머 간격

alarm()은 초 단위로만 동작하며, 밀리초나 마이크로초 단위의 정밀한 타이머가 필요할 경우에는 적합하지 않습니다.

정밀 타이머가 필요하면 setitimer()나 clock_nanosleep() 같은 대안을 사용하는 것이 좋습니다.

대안: `setitimer()`를 사용한 정밀 타이머

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/time.h>

void timer_handler(int signum) {
    printf("High-precision timer expired!\n");
}

int main() {
    struct itimerval timer;
    signal(SIGALRM, timer_handler);

    // 500ms 후 타이머 만료
    timer.it_value.tv_sec = 0;
    timer.it_value.tv_usec = 500000;
    timer.it_interval.tv_sec = 0;
    timer.it_interval.tv_usec = 0;

    setitimer(ITIMER_REAL, &timer, NULL);

    pause();
    return 0;
}

3. 시그널 처리의 비동기 특성

SIGALRM과 같은 시그널은 비동기로 호출되므로, 시그널 핸들러 내부에서 안전하지 않은 작업(예: 동적 메모리 할당, 표준 I/O 사용)을 수행하면 예상치 못한 동작이 발생할 수 있습니다.

시그널 핸들러에서는 비동기 신호 안전(asynchronous-signal-safe) 함수만 호출해야 합니다.

문제 예시: 안전하지 않은 작업

void alarm_handler(int signum) {
    printf("This is unsafe: %d\n", signum);  // 안전하지 않은 작업
}

올바른 방식

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

volatile sig_atomic_t flag = 0;

void alarm_handler(int signum) {
    flag = 1;  // 플래그 설정 (안전한 작업)
}

int main() {
    signal(SIGALRM, alarm_handler);
    alarm(5);

    while (!flag) {  // 안전한 루프
        // 작업 수행
    }
    printf("Timer expired safely.\n");
    return 0;
}

4. 다른 시그널과의 충돌

다른 시그널(SIGINT, SIGTERM 등)과 함께 사용하는 경우, 처리 순서나 충돌 문제가 발생할 수 있습니다.

시그널 마스크를 사용하여 동시 처리를 방지하는 것이 좋습니다.

예제: 시그널 마스크 사용

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

void alarm_handler(int signum) {
    printf("SIGALRM handled.\n");
}

int main() {
    struct sigaction sa;
    sigset_t block_set;

    sigemptyset(&block_set);
    sigaddset(&block_set, SIGINT);  // SIGINT 차단
    sa.sa_handler = alarm_handler;
    sa.sa_mask = block_set;

    sigaction(SIGALRM, &sa, NULL);
    alarm(5);

    pause();
    return 0;
}

5. 포터블 문제

alarm()은 대부분의 유닉스 계열 시스템에서 동작하지만, 일부 플랫폼에서는 지원되지 않을 수 있습니다.

코드의 이식성을 위해 POSIX 표준에 따라 동작을 구현하거나 대체 함수를 사용해야 합니다.

정리

alarm()은 간단한 타이머 설정에는 유용하지만, 다중 타이머 지원 부족, 정밀도 한계, 비동기 처리의 제약 등으로 인해 모든 상황에서 적합하지는 않습니다. 이러한 제한을 이해하고, 필요한 경우 더 적합한 대안을 선택하여 사용하는 것이 중요합니다.

요약

이번 기사에서는 C언어의 alarm() 시스템 호출을 사용하여 타이머를 설정하고 관리하는 방법에 대해 알아보았습니다.

alarm()은 간단한 타이머 설정을 위한 유용한 도구이며, 특정 시간이 지나면 SIGALRM 시그널을 발생시켜 작업을 트리거합니다.
기본 사용법, 시그널 핸들링, 응용 예시(제한 시간 설정, 주기적 알림, 유휴 시간 관리 등)를 살펴보았으며, 코드 예제와 함께 설명했습니다.
제한 사항으로는 단일 타이머 지원, 정밀도 한계, 비동기 처리의 제약 등이 있으며, 이를 해결하기 위한 대안을 제시했습니다.

alarm()은 단순하고 직관적인 방법으로 시간 기반 프로세스 제어를 구현하는 데 유용하지만, 고급 기능이 필요한 경우에는 대체 솔루션을 고려하는 것이 중요합니다. 다양한 상황에 맞게 적절히 활용하여 효과적인 시간 관리를 구현할 수 있습니다.