MENU
  1. ホーム
  2. C 언어
  3. C 언어에서 SIGINT, SIGTERM, SIGKILL 처리 방법 완벽 가이드

C 언어에서 SIGINT, SIGTERM, SIGKILL 처리 방법 완벽 가이드

C 언어

C 언어에서 시스템 프로그래밍을 다룰 때, 프로세스는 다양한 신호(interrupt signal)를 받을 수 있습니다. 이 중 SIGINT, SIGTERM, SIGKILL은 프로세스 종료와 관련된 대표적인 신호로, 정확한 처리 방법을 이해하는 것이 중요합니다. 본 기사에서는 이러한 신호의 기본 개념, 처리 방법, 그리고 실제 활용 예시를 통해 안정적이고 신뢰할 수 있는 프로그램을 구현하는 방법을 설명합니다.

목차
  1. 인터럽트 신호란 무엇인가
    1. `SIGINT`
    2. `SIGTERM`
    3. `SIGKILL`
    4. 인터럽트 신호의 활용
  2. C 언어에서 인터럽트 신호 처리의 기본
    1. `signal()` 함수의 기본 구조
    2. 핸들러 함수의 역할
    3. 기본적인 사용법
    4. 주의사항
  3. `SIGINT` 처리 예제
    1. Ctrl+C로 발생하는 `SIGINT` 처리
    2. 코드 설명
    3. 실행 결과
    4. 실전 활용
  4. `SIGTERM`과 안전한 종료 처리
    1. `SIGTERM` 처리 예제
    2. 코드 설명
    3. 실행 결과
    4. 리소스 정리 및 종료
    5. 주의사항
  5. `SIGKILL`의 특성과 한계
    1. `SIGKILL`의 특징
    2. 처리 불가능한 이유
    3. `SIGKILL`의 한계
    4. 안정적인 대안
    5. 결론
  6. 인터럽트 처리에서 주의할 점
    1. 1. 멀티스레드 환경에서의 신호 처리
    2. 2. 재진입성 문제
    3. 3. 신호 핸들러와 시스템 콜
    4. 4. 중첩된 신호 처리
    5. 5. 정리되지 않은 리소스
    6. 결론
  7. 고급 신호 처리와 `sigaction`
    1. `sigaction`의 개요
    2. `sigaction`을 사용한 신호 처리 예제
    3. `sigaction`의 주요 기능
    4. `sigaction`과 `signal`의 차이점
    5. 고급 활용: 다중 신호 처리
    6. 결론
  8. 실전 응용: Graceful Shutdown 구현
    1. Graceful Shutdown의 개념
    2. Graceful Shutdown 구현 예제
    3. 코드 설명
    4. 실행 결과
    5. 응용 가능성
    6. 결론
  9. 요약

인터럽트 신호란 무엇인가


인터럽트 신호는 운영 체제가 프로세스에 특정 이벤트를 알리기 위해 사용하는 메커니즘입니다.

`SIGINT`


SIGINT는 사용자가 키보드에서 Ctrl+C를 눌러 프로세스를 종료하고자 할 때 발생하는 신호입니다. 일반적으로 프로세스를 중단하려는 사용자 의도를 나타냅니다.

`SIGTERM`


SIGTERM은 운영 체제나 다른 프로세스가 특정 프로세스를 종료하라는 요청을 보낼 때 발생하는 신호입니다. 이 신호는 프로세스가 리소스를 정리하고 정상적으로 종료할 기회를 제공합니다.

`SIGKILL`


SIGKILL은 프로세스를 강제 종료하는 데 사용되며, 취소하거나 처리할 수 없습니다. 운영 체제는 즉시 해당 프로세스를 종료합니다.

인터럽트 신호의 활용


이러한 신호는 프로세스 관리와 시스템 리소스 보호에 필수적입니다. 예를 들어, 서버 프로그램에서는 신호를 활용해 클라이언트 연결을 정리하고 종료하는 등의 작업을 수행할 수 있습니다.

C 언어에서 인터럽트 신호 처리의 기본


C 언어에서는 signal() 함수를 사용해 특정 신호를 처리할 수 있습니다. 이를 통해 프로세스가 신호를 받았을 때 실행할 동작(핸들러)을 정의할 수 있습니다.

`signal()` 함수의 기본 구조


signal() 함수는 다음과 같이 사용됩니다:

#include <signal.h>

void signal_handler(int signum) {
    // 신호 처리 코드
}

int main() {
    signal(SIGINT, signal_handler); // SIGINT 처리 핸들러 등록
    while (1) {
        // 메인 프로그램 로직
    }
    return 0;
}
  • signal(int signum, void (*handler)(int))
  • signum: 처리할 신호(예: SIGINT, SIGTERM)
  • handler: 신호가 발생했을 때 실행할 함수

핸들러 함수의 역할


핸들러 함수는 신호가 발생했을 때 호출되며, 이를 통해 특정 작업을 수행할 수 있습니다. 예를 들어, SIGINT 신호를 처리하여 프로그램을 안전하게 종료하거나 특정 작업을 중단할 수 있습니다.

기본적인 사용법

  • 특정 신호를 처리하려면 signal()을 호출하여 핸들러를 등록합니다.
  • 핸들러가 호출되면 프로세스는 해당 작업을 수행한 후 원래 작업으로 복귀합니다.

주의사항

  • signal()을 통해 등록된 핸들러는 신호 처리 중 다른 신호를 받을 수 있는 경우 주의가 필요합니다.
  • 멀티스레드 환경에서는 더 정교한 처리 방법이 요구될 수 있습니다.

`SIGINT` 처리 예제


SIGINT는 사용자가 키보드에서 Ctrl+C를 눌렀을 때 프로세스에 전달되는 신호입니다. 이를 처리해 프로그램이 종료되지 않고 특정 동작을 수행하도록 설정할 수 있습니다.

Ctrl+C로 발생하는 `SIGINT` 처리


다음은 SIGINT를 처리하는 간단한 예제 코드입니다:

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

// SIGINT 핸들러 함수 정의
void handle_sigint(int signum) {
    printf("\nSIGINT 신호(%d) 받음. 프로그램 종료 방지!\n", signum);
    printf("종료하려면 Ctrl+C를 한 번 더 누르세요.\n");
}

int main() {
    // SIGINT 신호에 대해 handle_sigint 함수 등록
    signal(SIGINT, handle_sigint);

    printf("프로그램 실행 중... Ctrl+C로 SIGINT를 테스트하세요.\n");
    while (1) {
        // 메인 루프에서 대기
        sleep(1);
    }

    return 0;
}

코드 설명

  1. 핸들러 함수 정의
    handle_sigint 함수는 SIGINT 신호를 받을 때 호출됩니다. 여기서 신호 번호를 매개변수로 받아 특정 동작을 수행할 수 있습니다.
  2. 핸들러 등록
    signal(SIGINT, handle_sigint)를 호출하여 SIGINT 신호에 대해 handle_sigint 함수가 실행되도록 설정합니다.
  3. 프로그램 동작
  • 사용자 입력(Ctrl+C)에 따라 신호가 발생하며, 핸들러가 호출됩니다.
  • 신호를 처리한 후 프로그램은 종료되지 않고 계속 실행됩니다.

실행 결과


프로그램 실행 중 Ctrl+C를 누르면 다음과 같은 메시지가 출력됩니다:

SIGINT 신호(2) 받음. 프로그램 종료 방지!
종료하려면 Ctrl+C를 한 번 더 누르세요.

실전 활용

  • 이 코드를 기반으로 특정 리소스를 정리하거나 사용자로부터 확인을 받은 후 안전하게 종료하도록 확장할 수 있습니다.
  • 예: 파일 저장, 네트워크 연결 해제 등.

`SIGTERM`과 안전한 종료 처리


SIGTERM은 프로세스를 종료하도록 요청하는 신호로, 시스템이나 다른 프로세스에서 보낼 수 있습니다. 이 신호는 SIGKILL과 달리 프로세스가 리소스를 정리하고 종료할 기회를 제공합니다.

`SIGTERM` 처리 예제


다음은 SIGTERM을 처리해 안전하게 종료하는 방법을 보여주는 코드입니다:

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

volatile bool keep_running = true;

// SIGTERM 핸들러 함수 정의
void handle_sigterm(int signum) {
    printf("\nSIGTERM 신호(%d) 받음. 종료 작업 중...\n", signum);
    keep_running = false; // 종료 플래그 설정
}

int main() {
    // SIGTERM 신호에 대해 handle_sigterm 함수 등록
    signal(SIGTERM, handle_sigterm);

    printf("프로그램 실행 중... PID: %d\n", getpid());
    printf("SIGTERM을 보내 종료를 테스트하세요.\n");

    // 메인 루프
    while (keep_running) {
        printf("작업 수행 중...\n");
        sleep(1); // 1초 대기
    }

    printf("리소스 정리 후 안전하게 종료합니다.\n");
    return 0;
}

코드 설명

  1. 핸들러 함수 정의
    handle_sigterm 함수는 SIGTERM 신호를 받을 때 호출되며, 종료 플래그인 keep_running을 false로 설정합니다.
  2. 핸들러 등록
    signal(SIGTERM, handle_sigterm)를 호출하여 SIGTERM 신호에 대해 핸들러를 등록합니다.
  3. 메인 루프 종료
    핸들러에서 설정한 플래그를 통해 메인 루프가 종료되고, 리소스 정리 및 프로그램 종료 작업이 이루어집니다.

실행 결과


프로그램 실행 중 kill 명령어를 사용하여 SIGTERM 신호를 보낼 수 있습니다:

kill -SIGTERM <프로세스 PID>

실행 중인 프로그램이 다음과 같이 반응합니다:

작업 수행 중...
SIGTERM 신호(15) 받음. 종료 작업 중...
리소스 정리 후 안전하게 종료합니다.

리소스 정리 및 종료

  • 이 구조를 사용하면 프로그램이 종료 전에 파일, 데이터베이스 연결, 네트워크 세션 등을 정리할 수 있습니다.
  • SIGTERM은 일반적으로 서버나 데몬 프로세스에서 안전한 종료를 구현할 때 유용합니다.

주의사항

  • SIGTERM은 운영 체제에서 보낼 수 있으므로 항상 프로세스 종료 시 중요한 작업을 처리하는 핸들러를 준비해야 합니다.
  • 강제 종료(SIGKILL)를 방지하려면 가능한 리소스 정리를 SIGTERM 처리 시에 완료해야 합니다.

`SIGKILL`의 특성과 한계


SIGKILL은 프로세스를 강제로 종료하는 신호로, 운영 체제가 즉시 실행하며 이를 막거나 처리할 수 없습니다. 다른 신호(SIGINT, SIGTERM 등)와 달리 프로세스에게 종료 준비나 리소스 정리의 기회를 제공하지 않습니다.

`SIGKILL`의 특징

  1. 강제 종료
  • 운영 체제는 SIGKILL을 받은 프로세스를 즉시 종료합니다.
  • 프로세스는 핸들러를 등록하거나 신호를 무시할 수 없습니다.
  1. 사용 사례
  • 일반적으로 프로세스가 응답하지 않을 때 사용됩니다.
  • 관리자는 서버나 작업 관리 도구를 통해 비정상적으로 동작하는 프로세스를 종료하기 위해 이 신호를 사용할 수 있습니다.
  1. 신호 번호
  • SIGKILL의 신호 번호는 일반적으로 9로 정의되어 있습니다.
   kill -9 <프로세스 PID>

처리 불가능한 이유

  • SIGKILL은 커널에 의해 즉시 실행되며, 프로세스 수준에서 차단하거나 처리할 수 없는 신호입니다.
  • signal()이나 sigaction() 함수로 핸들러를 등록해도 무시됩니다.
  • 이는 시스템 안정성을 유지하기 위해 설계된 메커니즘입니다.

`SIGKILL`의 한계

  1. 리소스 정리 불가능
  • 프로세스가 종료되기 전에 열려 있는 파일, 네트워크 연결, 메모리 리소스를 정리할 수 없습니다.
  • 이로 인해 데이터 손실이나 리소스 누수가 발생할 수 있습니다.
  1. 비정상 종료
  • 종료를 예측할 수 없으므로 프로그램 상태가 비정상적으로 남을 가능성이 높습니다.

안정적인 대안

  • SIGTERM을 먼저 보내고, 응답이 없을 경우 최후의 수단으로 SIGKILL을 사용합니다.
  kill -15 <프로세스 PID> # SIGTERM
  kill -9 <프로세스 PID>  # SIGKILL

결론


SIGKILL은 프로세스를 강제 종료하기 위한 마지막 수단으로 사용되며, 안정적인 시스템 운영을 위해 신중하게 사용해야 합니다. 이 신호를 처리할 수 없으므로, 가능한 리소스 정리는 다른 신호(SIGTERM 등)를 통해 미리 수행해야 합니다.

인터럽트 처리에서 주의할 점


C 언어에서 인터럽트 신호를 처리할 때는 코드 안정성과 프로그램의 동작 일관성을 유지하기 위해 몇 가지 주의사항을 고려해야 합니다.

1. 멀티스레드 환경에서의 신호 처리

  • 멀티스레드 환경에서는 신호가 어떤 스레드에서 처리될지 예측하기 어려울 수 있습니다.
  • 신호는 특정 스레드가 아닌 프로세스에 전달되며, 커널이 처리 스레드를 결정합니다.
  • 따라서, 신호 처리와 멀티스레드 프로그램을 함께 사용할 때는 신호 처리와 스레드 간 동기화에 주의해야 합니다.

대책:

  • 특정 스레드가 신호를 처리하도록 설정하려면 pthread_sigmask()로 신호 마스크를 설정한 뒤, sigwait()를 사용해 신호를 처리합니다.
pthread_sigmask(SIG_BLOCK, &sigset, NULL);
sigwait(&sigset, &signum);

2. 재진입성 문제

  • 신호 핸들러는 재진입(reentrant) 가능한 함수만 호출해야 합니다.
  • 핸들러가 호출되는 도중 다른 신호가 발생하면 예기치 않은 동작이나 데이터 손상이 발생할 수 있습니다.

허용되는 재진입 함수:

  • write(), _exit() 등.
  • 표준 라이브러리 함수(예: printf())는 내부적으로 비재진입성이므로 사용을 피해야 합니다.

대책:

  • 신호 핸들러 내에서 중요한 작업은 최소화하고, 플래그를 설정하여 메인 루프에서 필요한 작업을 처리하도록 설계합니다.
volatile sig_atomic_t signal_flag = 0;

void signal_handler(int signum) {
    signal_flag = 1; // 단순히 플래그를 설정
}

3. 신호 핸들러와 시스템 콜

  • 신호 핸들러 실행 중에는 시스템 콜이 중단될 수 있습니다.
  • 예를 들어, read()나 write()가 중단되면 EINTR 오류가 반환됩니다.

대책:

  • 오류를 감지하고 시스템 콜을 재시도하도록 설계합니다.
ssize_t result;
do {
    result = read(fd, buffer, size);
} while (result == -1 && errno == EINTR);

4. 중첩된 신호 처리

  • 신호 핸들러가 실행 중일 때 동일한 신호가 발생하면 중첩 호출로 인해 문제가 발생할 수 있습니다.

대책:

  • 신호 처리 중 다른 신호를 차단하도록 설정합니다.
struct sigaction sa;
sa.sa_handler = signal_handler;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, SIGINT); // 처리 중 SIGINT 차단
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);

5. 정리되지 않은 리소스

  • 신호가 처리되지 않으면 파일, 메모리, 네트워크 연결 등이 정리되지 않아 리소스 누수가 발생할 수 있습니다.

대책:

  • SIGTERM이나 SIGINT 핸들러에서 리소스를 안전하게 해제하는 로직을 추가합니다.

결론


인터럽트 처리에서는 재진입성, 멀티스레드 동작, 신호와 시스템 콜의 상호작용 등을 신중히 설계해야 합니다. 간단한 작업은 핸들러 내에서 처리하고, 복잡한 작업은 메인 루프에서 처리하도록 설계하는 것이 안정적인 프로그램 구현의 핵심입니다.

고급 신호 처리와 `sigaction`


C 언어에서 sigaction은 signal()보다 더 강력하고 유연한 신호 처리 방법을 제공합니다. 이를 통해 보다 안정적이고 안전한 신호 처리를 구현할 수 있습니다.

`sigaction`의 개요


sigaction은 신호 처리기 설정, 신호 마스크 구성, 추가 플래그 설정 등을 지원하는 함수입니다.

#include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

매개변수 설명:

  • signum: 처리할 신호(예: SIGINT, SIGTERM)
  • act: 새 신호 동작 설정
  • oldact: 이전 신호 동작을 저장

`sigaction`을 사용한 신호 처리 예제


다음은 sigaction을 사용해 SIGINT를 처리하는 예제입니다:

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

// SIGINT 핸들러 함수
void handle_sigint(int signum) {
    printf("\nSIGINT 신호(%d) 받음. 안전하게 종료 작업을 진행합니다.\n", signum);
}

int main() {
    struct sigaction sa;

    // 핸들러 설정
    sa.sa_handler = handle_sigint;
    sigemptyset(&sa.sa_mask);  // 다른 신호 차단 없음
    sa.sa_flags = 0;          // 기본 동작

    // SIGINT에 대해 sigaction 설정
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    printf("프로그램 실행 중... Ctrl+C로 SIGINT를 테스트하세요.\n");
    while (1) {
        sleep(1); // 메인 루프
    }

    return 0;
}

`sigaction`의 주요 기능

  1. 신호 마스크 설정
  • sa_mask를 사용하여 신호 처리 중 차단할 신호를 설정할 수 있습니다.
  • 예: SIGINT 처리 중 SIGTERM을 차단
   sigaddset(&sa.sa_mask, SIGTERM);
  1. 플래그 설정
  • sa_flags를 사용해 신호 처리 동작을 제어할 수 있습니다.
    • SA_RESTART: 중단된 시스템 호출 자동 재시도
    • SA_NOCLDWAIT: 좀비 프로세스 방지 (자식 프로세스 종료 시 사용)
   sa.sa_flags = SA_RESTART;
  1. 재진입 방지
  • sigaction은 신호 핸들러 실행 중 다른 신호를 자동 차단할 수 있어 재진입 문제를 방지합니다.

`sigaction`과 `signal`의 차이점

특징signal()sigaction()
신호 마스크 설정불가능가능
재진입 문제 처리제한적 지원자동 지원
플래그 활용불가능가능
복잡한 설정불가능가능

고급 활용: 다중 신호 처리


sigaction은 복수의 신호를 처리하는 데 유용합니다. 예를 들어, SIGINT와 SIGTERM 모두를 처리하려면 다음과 같이 작성할 수 있습니다:

struct sigaction sa;
sa.sa_handler = common_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;

sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);

결론


sigaction은 C 언어에서 신호 처리의 표준으로, 안정성과 유연성을 제공합니다. 신호 처리 중 발생할 수 있는 다양한 문제(재진입, 시스템 호출 중단 등)를 해결할 수 있으며, 복잡한 신호 처리 요구 사항을 충족시킬 수 있습니다.

실전 응용: Graceful Shutdown 구현


서버나 백그라운드 프로세스에서는 신호를 활용해 안전하고 체계적인 종료(Graceful Shutdown)를 구현하는 것이 중요합니다. SIGTERM과 같은 신호를 활용하면 리소스를 정리하고 데이터를 안전하게 저장한 후 종료할 수 있습니다.

Graceful Shutdown의 개념


Graceful Shutdown은 다음 단계를 포함합니다:

  1. 종료 신호(SIGTERM, SIGINT)를 받으면 종료 준비를 시작합니다.
  2. 열려 있는 리소스(파일, 네트워크 소켓 등)를 정리합니다.
  3. 중요 데이터를 저장하고, 안전하게 종료합니다.

Graceful Shutdown 구현 예제


다음은 SIGTERM 신호를 처리하여 안전한 종료를 구현한 서버 프로그램의 예제입니다:

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

volatile bool keep_running = true;

// Graceful Shutdown을 위한 리소스 정리 함수
void cleanup_resources() {
    printf("리소스를 정리 중...\n");
    // 파일 닫기, 메모리 해제, 네트워크 연결 종료 등의 작업 수행
}

// SIGTERM 핸들러 함수
void handle_sigterm(int signum) {
    printf("\nSIGTERM 신호(%d) 받음. 종료 준비 중...\n", signum);
    keep_running = false; // 메인 루프 종료 플래그 설정
}

int main() {
    struct sigaction sa;

    // SIGTERM에 대해 핸들러 등록
    sa.sa_handler = handle_sigterm;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;

    if (sigaction(SIGTERM, &sa, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    printf("서버 실행 중... PID: %d\n", getpid());
    printf("SIGTERM을 보내 안전한 종료를 테스트하세요.\n");

    // 메인 루프
    while (keep_running) {
        printf("클라이언트 요청 처리 중...\n");
        sleep(1); // 작업 시뮬레이션
    }

    // Graceful Shutdown 수행
    cleanup_resources();
    printf("서버가 안전하게 종료되었습니다.\n");

    return 0;
}

코드 설명

  1. 핸들러 설정
  • handle_sigterm 함수는 SIGTERM 신호를 처리하여 종료 준비를 시작합니다.
  • 메인 루프를 종료하기 위해 keep_running 플래그를 false로 설정합니다.
  1. 리소스 정리 함수
  • cleanup_resources 함수는 파일 닫기, 네트워크 연결 종료 등 종료 전에 필요한 작업을 수행합니다.
  1. Graceful Shutdown 흐름
  • 메인 루프에서 keep_running 상태를 지속적으로 확인하며, 종료 신호를 받으면 루프를 빠져나옵니다.
  • 루프 종료 후 cleanup_resources를 호출해 안전하게 프로그램을 종료합니다.

실행 결과

  1. 서버 실행 중:
   서버 실행 중... PID: 12345
   클라이언트 요청 처리 중...
   클라이언트 요청 처리 중...
  1. SIGTERM 신호 전송 후:
   kill -SIGTERM 12345

출력:

   SIGTERM 신호(15) 받음. 종료 준비 중...
   리소스를 정리 중...
   서버가 안전하게 종료되었습니다.

응용 가능성

  • 웹 서버: 연결된 클라이언트를 차례로 종료하고, 작업 중인 데이터를 저장.
  • 파일 처리 프로그램: 열려 있는 파일을 닫고 데이터 무결성을 보장.
  • 데이터베이스 관리 시스템: 실행 중인 트랜잭션을 안전하게 종료.

결론


Graceful Shutdown은 시스템 안정성과 데이터 무결성을 보장하는 중요한 프로그래밍 패턴입니다. 신호 처리 메커니즘을 활용해 종료 준비를 철저히 설계하면, 비정상 종료로 인한 문제를 최소화할 수 있습니다.

요약


본 기사에서는 C 언어에서의 주요 인터럽트 신호(SIGINT, SIGTERM, SIGKILL) 처리 방법과 이를 활용한 안정적인 프로그램 구현 방법을 다뤘습니다. signal()과 sigaction을 사용해 신호 핸들러를 설정하는 기본 방법부터 고급 기술, 그리고 Graceful Shutdown 구현을 통해 실전 응용 사례까지 설명했습니다. 안전한 종료와 리소스 정리를 위한 신호 처리는 시스템 프로그래밍에서 필수적인 기술로, 이를 통해 안정적이고 신뢰할 수 있는 프로그램을 개발할 수 있습니다.

C 언어
C언어 SIGINT SIGKILL SIGTERM 인터럽트
목차
  1. 인터럽트 신호란 무엇인가
    1. `SIGINT`
    2. `SIGTERM`
    3. `SIGKILL`
    4. 인터럽트 신호의 활용
  2. C 언어에서 인터럽트 신호 처리의 기본
    1. `signal()` 함수의 기본 구조
    2. 핸들러 함수의 역할
    3. 기본적인 사용법
    4. 주의사항
  3. `SIGINT` 처리 예제
    1. Ctrl+C로 발생하는 `SIGINT` 처리
    2. 코드 설명
    3. 실행 결과
    4. 실전 활용
  4. `SIGTERM`과 안전한 종료 처리
    1. `SIGTERM` 처리 예제
    2. 코드 설명
    3. 실행 결과
    4. 리소스 정리 및 종료
    5. 주의사항
  5. `SIGKILL`의 특성과 한계
    1. `SIGKILL`의 특징
    2. 처리 불가능한 이유
    3. `SIGKILL`의 한계
    4. 안정적인 대안
    5. 결론
  6. 인터럽트 처리에서 주의할 점
    1. 1. 멀티스레드 환경에서의 신호 처리
    2. 2. 재진입성 문제
    3. 3. 신호 핸들러와 시스템 콜
    4. 4. 중첩된 신호 처리
    5. 5. 정리되지 않은 리소스
    6. 결론
  7. 고급 신호 처리와 `sigaction`
    1. `sigaction`의 개요
    2. `sigaction`을 사용한 신호 처리 예제
    3. `sigaction`의 주요 기능
    4. `sigaction`과 `signal`의 차이점
    5. 고급 활용: 다중 신호 처리
    6. 결론
  8. 실전 응용: Graceful Shutdown 구현
    1. Graceful Shutdown의 개념
    2. Graceful Shutdown 구현 예제
    3. 코드 설명
    4. 실행 결과
    5. 응용 가능성
    6. 결론
  9. 요약