MENU
  1. ホーム
  2. C 언어
  3. C언어에서 POSIX 기반 신호 핸들링(sigset과 sigprocmask) 완벽 가이드

C언어에서 POSIX 기반 신호 핸들링(sigset과 sigprocmask) 완벽 가이드

C 언어

C언어에서 POSIX 기반 신호 처리 기능은 운영 체제와의 상호작용을 통해 프로그램 제어를 가능하게 합니다. 신호는 프로세스 간 통신과 예외 상황을 처리하는 데 핵심 역할을 하며, 이를 올바르게 관리하지 않으면 프로그램 안정성과 성능에 큰 영향을 미칠 수 있습니다. 본 기사에서는 POSIX 신호 처리의 기본 개념부터 sigset과 sigprocmask의 사용 방법, 주요 신호 처리 사례와 실제 응용 예제까지 자세히 살펴보겠습니다. 이를 통해 POSIX 환경에서 견고하고 효율적인 C 프로그램을 개발하는 데 필요한 지식을 얻을 수 있습니다.

목차

신호 핸들링의 기본 개념


신호는 운영 체제와 응용 프로그램 간에 발생하는 비동기적 이벤트를 전달하는 메커니즘입니다. C언어에서 신호는 프로세스에 특정 이벤트가 발생했음을 알리기 위해 사용됩니다.

신호란 무엇인가


신호는 운영 체제가 프로세스에 보내는 메시지로, 특정 이벤트나 상태를 알리기 위한 용도로 사용됩니다. 예를 들어, 사용자가 Ctrl+C를 눌렀을 때 프로세스에 전달되는 SIGINT 신호가 대표적입니다.

신호 처리와 동작


프로세스는 신호를 처리하기 위해 다음과 같은 동작을 수행할 수 있습니다.

  • 기본 동작 수행: 운영 체제에서 정의된 기본 동작을 실행합니다(예: 종료, 무시).
  • 무시: 특정 신호를 무시하도록 설정할 수 있습니다.
  • 사용자 정의 핸들러 실행: 개발자가 정의한 핸들러 함수로 신호를 처리합니다.

신호 핸들링의 중요성


신호 처리 기능은 다음과 같은 상황에서 유용합니다.

  • 비동기 이벤트 처리: 예기치 않은 이벤트(예: SIGTERM, SIGSEGV)에 대한 대응.
  • 프로세스 제어: 특정 조건에서 프로세스를 종료하거나 재시작.
  • 리소스 관리: 종료 전에 파일이나 네트워크 연결을 정리.

신호의 기초 개념을 이해하면, 프로그램의 안정성과 예외 처리 능력을 크게 향상시킬 수 있습니다.

POSIX 신호 시스템 개요

POSIX(Portable Operating System Interface)은 유닉스 계열 운영 체제에서 제공하는 표준 인터페이스입니다. POSIX 신호 시스템은 운영 체제와 프로그램 간에 비동기적 이벤트를 전달하고 처리하는 강력한 메커니즘을 제공합니다.

POSIX 신호 시스템의 특징

  1. 표준화된 인터페이스: POSIX 신호 시스템은 다양한 유닉스 계열 운영 체제에서 일관되게 작동하도록 설계되었습니다.
  2. 비동기 이벤트 처리: 신호는 프로세스 실행 중 발생하는 이벤트에 대해 즉각적인 응답을 제공합니다.
  3. 프로세스 간 통신: 신호는 하나의 프로세스에서 다른 프로세스로 메시지를 전달하는 데 사용됩니다.

POSIX에서의 주요 신호


POSIX 신호는 다양한 상황에 대응할 수 있도록 설계되었습니다. 몇 가지 대표적인 신호는 다음과 같습니다.

  • SIGINT: 사용자가 Ctrl+C를 눌러 프로세스를 중단할 때 전달됩니다.
  • SIGTERM: 프로세스를 정상적으로 종료하도록 요청합니다.
  • SIGKILL: 프로세스를 강제로 종료합니다(무시할 수 없음).
  • SIGSEGV: 잘못된 메모리 접근이 발생했을 때 전달됩니다.

POSIX 신호 처리의 단계

  1. 신호 생성: 이벤트 발생(예: kill 명령어 실행, 사용자 입력)으로 신호가 생성됩니다.
  2. 신호 전달: 운영 체제가 신호를 대상 프로세스에 전달합니다.
  3. 신호 처리: 프로세스는 신호를 처리하거나 무시하거나 기본 동작을 수행합니다.

POSIX 신호 시스템은 유연성과 강력한 제어를 제공하며, 이를 통해 프로세스가 안정적으로 동작하도록 보장합니다. 이후 섹션에서는 sigset과 sigprocmask를 활용해 신호를 세부적으로 제어하는 방법을 살펴보겠습니다.

`sigset`과 신호 블로킹

sigset은 POSIX 표준에서 정의된 자료구조로, 특정 신호의 집합을 나타냅니다. 이 구조를 사용하면 프로그램이 특정 신호를 일시적으로 블로킹하거나 처리 방식을 제어할 수 있습니다.

`sigset`의 정의와 역할


sigset_t는 신호 집합을 표현하는 데 사용되는 데이터 타입입니다. 이를 통해 신호의 추가, 제거, 블로킹 상태를 관리할 수 있습니다.

`sigset` 관련 주요 함수


POSIX는 sigset을 조작하기 위한 여러 함수를 제공합니다. 주요 함수는 다음과 같습니다.

  1. sigemptyset
  • sigset을 초기화하여 빈 신호 집합을 만듭니다.
   sigset_t set;
   sigemptyset(&set);
  1. sigfillset
  • 모든 신호를 포함하는 신호 집합을 만듭니다.
   sigfillset(&set);
  1. sigaddset
  • 특정 신호를 신호 집합에 추가합니다.
   sigaddset(&set, SIGINT);
  1. sigdelset
  • 특정 신호를 신호 집합에서 제거합니다.
   sigdelset(&set, SIGTERM);
  1. sigismember
  • 특정 신호가 신호 집합에 포함되어 있는지 확인합니다.
   if (sigismember(&set, SIGKILL)) {
       printf("SIGKILL is in the set\n");
   }

신호 블로킹과 사용 사례


sigset은 신호 블로킹을 구현할 때 주로 사용됩니다. 블로킹은 특정 신호가 프로세스에 전달되는 것을 일시적으로 방지하는 기능으로, 프로세스가 중요한 작업을 수행 중일 때 유용합니다.

예제: 신호 블로킹

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

int main() {
    sigset_t set;
    sigemptyset(&set);           // 빈 신호 집합 생성
    sigaddset(&set, SIGINT);     // SIGINT 추가 (Ctrl+C)

    // SIGINT 블로킹
    sigprocmask(SIG_BLOCK, &set, NULL);

    printf("SIGINT is blocked. Press Ctrl+C (ignored for 10 seconds)\n");
    sleep(10);

    // SIGINT 언블로킹
    sigprocmask(SIG_UNBLOCK, &set, NULL);
    printf("SIGINT is unblocked. Press Ctrl+C (terminates process)\n");
    sleep(10);

    return 0;
}

`sigset`의 장점

  • 유연성: 특정 신호만 선택적으로 블로킹 가능.
  • 안정성: 중요한 작업 수행 중 예기치 않은 신호 방지.
  • 표준화: 다양한 유닉스 계열 운영 체제에서 일관된 동작 보장.

sigset을 활용하면 프로세스가 신호의 영향을 효과적으로 제어할 수 있습니다. 다음 섹션에서는 sigprocmask를 활용한 신호 마스킹을 자세히 다룹니다.

`sigprocmask`와 신호 마스킹

sigprocmask는 프로세스의 신호 마스크(signal mask)를 조정하여 특정 신호의 전달을 제어하는 데 사용됩니다. 신호 마스킹은 중요한 작업 도중 특정 신호가 프로세스에 전달되는 것을 방지하기 위해 사용됩니다.

`sigprocmask`의 정의와 역할


sigprocmask는 현재 신호 마스크를 설정하거나 변경하여, 신호가 프로세스에 도달하지 않도록 제어할 수 있습니다. 이를 통해 프로세스는 특정 시점에만 신호를 처리하도록 조정할 수 있습니다.

`sigprocmask` 함수의 시그니처

#include <signal.h>

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
  • how: 신호 마스크를 설정하는 방법을 지정합니다.
  • SIG_BLOCK: 기존 신호 마스크에 set의 신호를 추가합니다.
  • SIG_UNBLOCK: 기존 신호 마스크에서 set의 신호를 제거합니다.
  • SIG_SETMASK: 기존 신호 마스크를 set으로 완전히 교체합니다.
  • set: 새로 설정할 신호 집합입니다.
  • oldset: 이전 신호 마스크를 저장할 공간입니다(옵션).

사용 예시

1. 신호 마스킹 설정


아래 코드는 SIGINT(Ctrl+C)가 프로세스에 전달되지 않도록 마스킹하는 방법을 보여줍니다.

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

int main() {
    sigset_t set, oldset;

    sigemptyset(&set);
    sigaddset(&set, SIGINT);  // SIGINT 추가

    // SIGINT 블로킹
    sigprocmask(SIG_BLOCK, &set, &oldset);
    printf("SIGINT is blocked for 5 seconds. Press Ctrl+C (ignored)\n");
    sleep(5);

    // 이전 신호 마스크 복원
    sigprocmask(SIG_SETMASK, &oldset, NULL);
    printf("SIGINT is unblocked. Press Ctrl+C (terminates process)\n");
    sleep(5);

    return 0;
}

2. 현재 신호 마스크 확인


sigprocmask를 사용해 현재 블로킹된 신호 집합을 확인할 수도 있습니다.

sigset_t current_set;
sigprocmask(0, NULL, &current_set);

if (sigismember(&current_set, SIGINT)) {
    printf("SIGINT is currently blocked.\n");
} else {
    printf("SIGINT is not blocked.\n");
}

`sigprocmask` 사용의 이점

  • 중요 작업 보호: 중요한 코드 블록 실행 중 신호 방해 방지.
  • 유연한 신호 관리: 특정 신호를 선택적으로 블로킹 가능.
  • 프로세스 안정성 향상: 신호가 발생해도 프로그램 흐름을 방해하지 않음.

주의 사항

  • 멀티스레드 환경에서는 sigprocmask 대신 pthread_sigmask를 사용해야 합니다.
  • SIGKILL과 SIGSTOP은 블로킹할 수 없습니다.

sigprocmask는 POSIX 신호 처리 시스템에서 핵심적인 역할을 하며, 프로세스 제어를 더욱 세밀하게 할 수 있도록 돕습니다. 다음 섹션에서는 주요 신호 처리 예시를 다룹니다.

SIGINT, SIGTERM 등 주요 신호 처리

POSIX에서 정의된 주요 신호들은 프로세스 제어와 예외 처리를 위해 자주 사용됩니다. 신호를 적절히 처리하면 프로그램의 안정성과 유연성을 크게 향상시킬 수 있습니다.

주요 신호 개요

  1. SIGINT
  • 정의: 사용자 입력(Ctrl+C)에 의해 프로세스를 중단하도록 요청하는 신호.
  • 기본 동작: 프로세스 종료.
  1. SIGTERM
  • 정의: 프로세스를 정상적으로 종료하도록 요청하는 신호.
  • 기본 동작: 종료, 하지만 핸들러를 정의하면 무시하거나 다른 작업 수행 가능.
  1. SIGKILL
  • 정의: 프로세스를 강제로 종료하는 신호.
  • 기본 동작: 강제 종료, 무조건적이며 무시하거나 핸들링 불가능.
  1. SIGSEGV
  • 정의: 잘못된 메모리 접근이 발생했을 때 전달되는 신호.
  • 기본 동작: 코어 덤프 생성 후 종료.
  1. SIGHUP
  • 정의: 터미널 연결이 끊어졌음을 알리는 신호.
  • 기본 동작: 종료, 하지만 서버 프로세스에서 재시작 트리거로도 활용 가능.

신호 핸들러 정의


프로세스는 특정 신호에 대해 사용자 정의 동작을 수행하는 신호 핸들러를 정의할 수 있습니다.

예제: SIGINT 핸들러


아래 코드는 Ctrl+C 입력 시 종료 대신 메시지를 출력하도록 핸들러를 설정합니다.

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

void handle_sigint(int sig) {
    printf("SIGINT received. Use Ctrl+Z to terminate.\n");
}

int main() {
    // SIGINT 핸들러 설정
    signal(SIGINT, handle_sigint);

    printf("Press Ctrl+C to trigger SIGINT (Handled).\n");
    while (1) {
        sleep(1);
    }

    return 0;
}

예제: SIGTERM 핸들러


SIGTERM 신호를 받아 리소스를 정리한 후 종료하는 예제입니다.

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

void handle_sigterm(int sig) {
    printf("SIGTERM received. Cleaning up resources...\n");
    exit(0);  // 정상 종료
}

int main() {
    // SIGTERM 핸들러 설정
    signal(SIGTERM, handle_sigterm);

    printf("Waiting for SIGTERM (Send with 'kill -TERM <pid>').\n");
    while (1) {
        sleep(1);
    }

    return 0;
}

신호 처리의 응용

  • 서버 프로세스 관리: SIGHUP를 통해 설정 재로딩 구현.
  • 비정상 종료 방지: SIGINT 처리로 사용자 입력에 따른 안전한 종료.
  • 디버깅: SIGSEGV 핸들러를 통해 잘못된 메모리 접근을 추적.

주의 사항

  • SIGKILL과 SIGSTOP은 처리하거나 무시할 수 없습니다.
  • 신호 핸들러는 비동기적이므로 재진입 문제를 피하려면 간단한 작업만 수행해야 합니다.

적절한 신호 처리는 프로그램 안정성을 높이고 다양한 운영 환경에서 유연한 동작을 가능하게 합니다. 다음 섹션에서는 멀티스레드 환경에서의 신호 핸들링을 살펴봅니다.

신호 핸들링과 다중 스레드

멀티스레드 환경에서는 신호 처리에 특별한 주의가 필요합니다. 신호는 프로세스 단위로 전달되며, 특정 스레드에서 처리되거나 모든 스레드에 영향을 줄 수 있습니다. POSIX는 멀티스레드 환경에서 신호를 관리하기 위한 표준화된 방법을 제공합니다.

멀티스레드 환경에서의 신호 동작

  1. 프로세스 단위 신호 전달
  • 신호는 전체 프로세스에 전달되며, 이를 처리할 스레드는 운영 체제에 의해 선택됩니다.
  • 예외적으로 pthread_sigmask를 사용하여 특정 스레드에서 신호를 처리하도록 설정할 수 있습니다.
  1. 신호 핸들러와 스레드 안전성
  • 신호 핸들러는 비동기적으로 호출되기 때문에 스레드 안전하지 않은 함수 호출 시 문제가 발생할 수 있습니다.
  • async-signal-safe 함수만 신호 핸들러에서 호출해야 합니다.

스레드별 신호 마스크 설정


POSIX에서는 pthread_sigmask 함수를 사용하여 각 스레드에서 신호 마스크를 설정할 수 있습니다.

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

void *thread_func(void *arg) {
    sigset_t set;
    int sig;

    sigemptyset(&set);
    sigaddset(&set, SIGINT);  // SIGINT를 블로킹

    pthread_sigmask(SIG_BLOCK, &set, NULL);
    printf("Thread %ld blocking SIGINT.\n", pthread_self());

    while (1) {
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t thread;
    sigset_t set;

    // 메인 스레드에서 SIGINT 처리
    sigemptyset(&set);
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);

    pthread_create(&thread, NULL, thread_func, NULL);
    printf("Main thread is handling SIGINT.\n");

    while (1) {
        pause();  // 신호 대기
    }
    return 0;
}

신호 핸들링과 스레드 안전 프로그래밍

1. 비동기-신호 안전 함수 사용


신호 핸들러에서 호출 가능한 함수는 POSIX에서 지정된 async-signal-safe 함수로 제한됩니다. 아래는 예제 함수들입니다.

  • write
  • _exit
  • sigprocmask

2. 공유 데이터 보호


신호 핸들러에서 공유 데이터를 수정할 때는 반드시 원자적 작업을 수행하거나 플래그를 사용하여 데이터 경합을 방지해야 합니다.

응용 사례

  • 스레드별 작업 분리: 특정 스레드에서만 신호를 처리하여 작업 분리 가능.
  • 백그라운드 처리: 비동기적 이벤트를 특정 스레드에서 처리하도록 설계.
  • 리소스 관리: SIGTERM 수신 시, 특정 스레드에서 정리 작업 수행.

주의 사항

  • 모든 스레드에서 신호 블로킹 상태를 명확히 관리해야 예기치 않은 동작을 방지할 수 있습니다.
  • 신호 핸들러는 간단하고 빠르게 동작해야 하며, 복잡한 로직은 피해야 합니다.

멀티스레드 환경에서 신호를 올바르게 처리하면 비동기적 이벤트 관리와 시스템 제어의 유연성을 극대화할 수 있습니다. 다음 섹션에서는 신호 디버깅 방법을 다룹니다.

신호 핸들링 디버깅

신호 핸들링은 비동기적으로 작동하므로, 예상치 못한 동작이나 충돌이 발생할 가능성이 있습니다. 효과적인 디버깅을 통해 문제를 식별하고 해결하는 것이 중요합니다.

신호 핸들링 디버깅의 주요 과제

  1. 비동기적 실행 흐름
  • 신호 핸들러는 프로세스의 실행 흐름과 독립적으로 작동하므로 디버깅이 어려울 수 있습니다.
  1. 핸들러 동작 불확실성
  • 잘못 구현된 핸들러가 예기치 않은 동작을 유발할 수 있습니다.
  1. 스레드와 신호 간 상호작용
  • 멀티스레드 환경에서는 신호 전달이 스레드 간 경합 상태를 일으킬 수 있습니다.

디버깅 도구와 기법

1. `gdb`를 사용한 디버깅


GNU Debugger(gdb)는 신호 핸들링 문제를 분석하는 데 유용합니다.

  • 신호 핸들러 진입 확인
    gdb에서 특정 신호 발생 시 중단점을 설정하여 핸들러 동작을 추적할 수 있습니다.
  gdb ./program
  (gdb) break <signal_handler_function>
  (gdb) run
  • 신호 전달 트리거
    gdb 내에서 특정 신호를 프로세스에 보낼 수 있습니다.
  (gdb) signal SIGINT

2. 로깅 활용


핸들러 내부에서 로깅을 추가하면 신호 발생 시점과 실행 흐름을 확인할 수 있습니다.

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

void handle_sigterm(int sig) {
    printf("SIGTERM received. Logging signal handling...\n");
}

int main() {
    signal(SIGTERM, handle_sigterm);
    while (1) {
        pause();
    }
    return 0;
}

3. 신호 마스크 상태 확인


sigprocmask를 사용하여 현재 신호 마스크를 확인하면 블로킹된 신호를 진단할 수 있습니다.

sigset_t set;
sigprocmask(SIG_BLOCK, NULL, &set);
if (sigismember(&set, SIGINT)) {
    printf("SIGINT is currently blocked.\n");
}

4. 코어 덤프 분석


잘못된 신호 처리로 인해 프로그램이 충돌하는 경우, 코어 덤프를 생성하고 이를 분석하여 문제의 원인을 파악할 수 있습니다.

  • 코어 덤프 활성화:
  ulimit -c unlimited
  • 코어 덤프 분석:
  gdb ./program core

문제 해결 사례

1. 신호 핸들러 재진입 문제


신호 핸들러에서 비동기-안전하지 않은 함수 호출로 발생하는 충돌 문제를 확인하고 수정합니다.

// 문제 코드
void handle_sigint(int sig) {
    printf("Signal received: %d\n", sig);  // 비동기-안전하지 않음
}

// 수정 코드
void handle_sigint(int sig) {
    write(STDOUT_FILENO, "Signal received\n", 16);  // 비동기-안전한 함수 사용
}

2. 블로킹 신호의 비의도적 해제


sigprocmask 호출을 확인하여 블로킹이 잘못 해제된 부분을 찾아 수정합니다.

디버깅 시 주의사항

  1. 핸들러 최소화
  • 신호 핸들러는 간단하고 빠르게 동작하도록 설계해야 합니다.
  1. 로깅 오버헤드
  • 과도한 로깅은 성능 저하를 일으킬 수 있으므로 주의가 필요합니다.
  1. 멀티스레드 환경에서의 테스트
  • 모든 스레드가 신호 마스크를 올바르게 설정했는지 확인해야 합니다.

효과적인 디버깅 기법을 활용하면 POSIX 신호 핸들링의 복잡성을 줄이고, 프로그램의 안정성을 크게 향상시킬 수 있습니다. 다음 섹션에서는 실제 프로젝트에서의 신호 핸들링 응용 예제를 다룹니다.

신호 핸들링 응용 예제

POSIX 신호 핸들링은 운영 체제와의 상호작용이 필요한 다양한 상황에서 유용하게 활용됩니다. 아래는 실제 프로젝트에서 신호 처리를 활용한 몇 가지 응용 예제를 소개합니다.

응용 사례 1: 서버의 Graceful Shutdown 구현


서버 애플리케이션에서 SIGTERM 신호를 받아 안전하게 종료 작업을 수행하도록 설계할 수 있습니다.

코드 예제

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

void handle_sigterm(int sig) {
    printf("SIGTERM received. Cleaning up resources...\n");
    // 리소스 정리
    // 예: 파일 닫기, 네트워크 연결 해제
    exit(0);
}

int main() {
    signal(SIGTERM, handle_sigterm);

    printf("Server running. Send SIGTERM to stop the server.\n");
    while (1) {
        sleep(1);
    }
    return 0;
}
  • 핵심 기능: 서버 종료 시 리소스를 안전하게 정리하여 데이터 손실 방지.

응용 사례 2: SIGHUP를 활용한 설정 재로딩


데몬 프로세스는 SIGHUP 신호를 받아 설정 파일을 다시 로드하고, 서비스 중단 없이 환경을 갱신할 수 있습니다.

코드 예제

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

void handle_sighup(int sig) {
    printf("SIGHUP received. Reloading configuration...\n");
    // 설정 파일 다시 읽기
    // 예: 새로 고침 작업
}

int main() {
    signal(SIGHUP, handle_sighup);

    printf("Daemon running. Send SIGHUP to reload configuration.\n");
    while (1) {
        sleep(1);
    }
    return 0;
}
  • 핵심 기능: SIGHUP 신호를 활용하여 런타임 중 설정 업데이트 가능.

응용 사례 3: SIGUSR1과 SIGUSR2를 통한 사용자 정의 동작


SIGUSR1과 SIGUSR2 신호는 사용자 정의 작업을 수행하도록 설계할 수 있습니다.

코드 예제

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

void handle_sigusr1(int sig) {
    printf("SIGUSR1 received. Performing action 1...\n");
}

void handle_sigusr2(int sig) {
    printf("SIGUSR2 received. Performing action 2...\n");
}

int main() {
    signal(SIGUSR1, handle_sigusr1);
    signal(SIGUSR2, handle_sigusr2);

    printf("Send SIGUSR1 or SIGUSR2 to trigger custom actions.\n");
    while (1) {
        sleep(1);
    }
    return 0;
}
  • 핵심 기능: 특정 이벤트(예: 모니터링, 로그 저장) 발생 시 사용자 정의 동작 수행.

응용 사례 4: SIGALRM을 활용한 타이머 이벤트


SIGALRM 신호를 활용하여 특정 간격마다 작업을 수행하는 타이머를 구현할 수 있습니다.

코드 예제

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

void handle_sigalrm(int sig) {
    printf("SIGALRM received. Timer expired.\n");
    alarm(5);  // 다시 5초 타이머 설정
}

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

    alarm(5);  // 5초 타이머 설정
    printf("Timer set for 5 seconds.\n");

    while (1) {
        pause();  // 신호 대기
    }
    return 0;
}
  • 핵심 기능: 주기적인 작업 수행 자동화.

응용 사례 5: SIGCHLD를 활용한 자식 프로세스 관리


SIGCHLD 신호를 활용하면 자식 프로세스의 종료를 감지하고 적절히 처리할 수 있습니다.

코드 예제

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

void handle_sigchld(int sig) {
    int status;
    pid_t pid = wait(&status);
    printf("Child process %d terminated.\n", pid);
}

int main() {
    signal(SIGCHLD, handle_sigchld);

    if (fork() == 0) {
        // 자식 프로세스
        printf("Child process running...\n");
        sleep(2);
        return 0;
    }

    // 부모 프로세스
    printf("Parent process waiting for child termination.\n");
    while (1) {
        pause();  // SIGCHLD 대기
    }

    return 0;
}
  • 핵심 기능: 자식 프로세스 종료 상태를 감지하고 리소스를 적절히 정리.

신호 처리 응용의 이점

  • 효율적 시스템 제어: 다양한 이벤트를 관리하고 시스템 자원을 효과적으로 제어 가능.
  • 서비스 안정성: Graceful Shutdown과 설정 재로딩을 통해 안정적인 서비스 유지.
  • 사용자 정의 동작: SIGUSR1, SIGUSR2 등을 활용해 유연한 시스템 설계 가능.

다음 섹션에서는 본 기사 내용을 간단히 요약합니다.

요약

본 기사에서는 C언어에서 POSIX 기반 신호 처리의 중요성과 기본 개념, 주요 함수(sigset, sigprocmask), 신호 블로킹 및 마스킹 방법, 그리고 SIGINT, SIGTERM 등의 주요 신호 처리 기법을 다루었습니다. 또한, 멀티스레드 환경에서의 신호 관리, 디버깅 기법, 그리고 Graceful Shutdown, 설정 재로딩 등 실제 응용 사례를 통해 실무에서의 활용 가능성을 살펴보았습니다.

POSIX 신호 처리는 비동기적 이벤트 제어를 위한 강력한 도구로, 적절히 활용하면 안정적이고 유연한 시스템 설계가 가능합니다. 이를 통해 C언어 기반 프로그램의 효율성과 안정성을 극대화할 수 있습니다.

C 언어
C언어 POSIX 신호 처리
목차