MENU
  1. ホーム
  2. C 언어
  3. C 언어에서 시그널(SIGINT, SIGTERM 등)을 사용한 프로세스 제어 방법

C 언어에서 시그널(SIGINT, SIGTERM 등)을 사용한 프로세스 제어 방법

C 언어

C 언어에서 시그널 처리와 프로세스 제어는 중요한 시스템 프로그래밍 주제입니다. 시그널은 운영 체제에서 프로세스 간 통신 및 제어를 위해 사용되며, 이를 통해 프로세스 실행 흐름을 동적으로 제어할 수 있습니다. 이 기사에서는 SIGINT, SIGTERM과 같은 주요 시그널의 개념과 용도를 살펴보고, 이를 활용해 프로세스를 제어하는 방법을 단계적으로 설명합니다. 또한, 시그널 처리기를 설정하고 여러 시그널을 관리하는 실용적인 코드 예제도 제공하여 실무 적용 가능성을 높입니다.

목차

시그널이란 무엇인가


시그널은 운영 체제에서 프로세스에 특정 이벤트를 알리기 위해 사용하는 비동기적인 통신 메커니즘입니다. 이는 프로세스 간 또는 운영 체제와 프로세스 간에 상태를 전달하거나 특정 작업을 트리거하기 위해 사용됩니다.

시그널의 정의


시그널은 운영 체제 커널에서 생성되며, 프로세스에 전달되는 인터럽트 또는 알림의 한 형태입니다. 프로세스가 시그널을 받으면, 기본 동작을 수행하거나 프로그래머가 설정한 시그널 처리기가 실행됩니다.

시그널의 역할

  • 프로세스 제어: 프로세스를 중단, 종료 또는 특정 상태로 전환하는 데 사용됩니다.
  • 이벤트 알림: 프로세스 간 통신 또는 하드웨어/소프트웨어 이벤트 발생 시 알림을 제공합니다.
  • 디버깅: 특정 상태에서 실행을 중단하여 디버깅이 가능하도록 지원합니다.

시그널의 전달 과정

  1. 시그널 발생: 프로세스나 시스템 이벤트에 의해 시그널이 생성됩니다.
  2. 시그널 전달: 커널이 시그널을 대상 프로세스에 전달합니다.
  3. 처리 동작: 프로세스는 시그널에 대해 기본 동작(종료, 무시 등)을 수행하거나, 시그널 처리기를 통해 커스텀 동작을 실행합니다.

시그널은 운영 체제와 프로세스 간의 강력한 통신 도구로, 이를 이해하면 복잡한 시스템 프로그래밍 문제를 해결할 수 있습니다.

주요 시그널 종류


운영 체제에서 제공하는 시그널은 각기 다른 목적과 용도를 가지며, 프로세스 제어 및 통신에 다양하게 활용됩니다. C 언어에서 대표적으로 사용되는 주요 시그널을 살펴보겠습니다.

SIGINT

  • 설명: 키보드 인터럽트(Ctrl + C)로 생성되는 시그널로, 프로세스를 중단시키는 데 사용됩니다.
  • 기본 동작: 프로세스 종료.
  • 용도: 긴급 종료가 필요한 상황에서 프로세스를 중단하기 위해 사용됩니다.

SIGTERM

  • 설명: 프로세스를 정상적으로 종료하라는 요청을 나타내는 시그널입니다.
  • 기본 동작: 프로세스 종료.
  • 용도: 프로세스가 종료 전에 리소스를 정리할 수 있도록 기회를 제공합니다.

SIGHUP

  • 설명: 터미널 또는 세션 연결이 끊어졌음을 나타냅니다.
  • 기본 동작: 프로세스 종료.
  • 용도: 데몬 프로세스가 설정 파일을 다시 로드하도록 트리거하는 데 자주 사용됩니다.

SIGKILL

  • 설명: 프로세스를 즉시 종료시키는 강제 시그널로, 무조건적입니다.
  • 기본 동작: 강제 종료.
  • 용도: 프로세스가 종료 요청에 응답하지 않을 때 사용됩니다.

SIGSTOP

  • 설명: 프로세스를 일시 정지시키는 시그널로, 사용자가 프로세스 실행을 중단하고 재개할 수 있습니다.
  • 기본 동작: 프로세스 일시 중지.
  • 용도: 디버깅이나 프로세스 관리에서 유용하게 사용됩니다.

SIGUSR1 및 SIGUSR2

  • 설명: 사용자 정의 시그널로, 프로세스 간 특정 작업을 알리거나 트리거하는 데 사용됩니다.
  • 기본 동작: 없음(사용자가 정의 가능).
  • 용도: 애플리케이션 내부 통신에 활용됩니다.

시그널의 특성과 용도를 이해하면 프로세스 관리 및 통신에서 더 효율적인 프로그래밍이 가능합니다.

시그널 처리기(signal handler)


시그널 처리기는 특정 시그널이 발생했을 때 프로세스가 수행할 동작을 정의하는 함수입니다. 이를 통해 시그널에 대한 기본 동작을 재정의하거나, 특정 요구 사항에 따라 사용자 지정 동작을 구현할 수 있습니다.

시그널 처리기의 기본 개념


시그널 처리기는 C 언어의 signal() 함수나 sigaction() 함수로 등록할 수 있습니다.

  • 기본 동작 재정의: 기본적으로 프로세스를 종료하거나 무시하는 동작을 개발자가 원하는 로직으로 대체할 수 있습니다.
  • 사용자 정의 처리: 특정 시그널에 대해 알림, 로그 기록, 리소스 정리 등의 작업을 수행하도록 설정할 수 있습니다.

시그널 처리기 설정 방법

  1. signal() 함수 사용
    signal() 함수는 시그널 처리기를 등록하는 간단한 방법입니다.
   #include <signal.h>
   #include <stdio.h>

   void handle_sigint(int sig) {
       printf("SIGINT received. Exiting...\n");
       exit(0);
   }

   int main() {
       signal(SIGINT, handle_sigint);
       while (1) {
           printf("Running...\n");
           sleep(1);
       }
       return 0;
   }
  • signal(SIGINT, handle_sigint): SIGINT 발생 시 handle_sigint 함수를 호출합니다.
  • handle_sigint 함수는 사용자 정의 동작을 구현합니다.
  1. sigaction() 함수 사용
    sigaction() 함수는 더 정교한 시그널 처리기 설정을 지원합니다.
   #include <signal.h>
   #include <stdio.h>
   #include <stdlib.h>

   void handle_sigterm(int sig) {
       printf("SIGTERM received. Cleaning up and exiting...\n");
       exit(0);
   }

   int main() {
       struct sigaction sa;
       sa.sa_handler = handle_sigterm;
       sa.sa_flags = 0;
       sigemptyset(&sa.sa_mask);

       sigaction(SIGTERM, &sa, NULL);

       while (1) {
           printf("Waiting for SIGTERM...\n");
           sleep(1);
       }
       return 0;
   }
  • struct sigaction: 시그널 처리기 설정 구조체.
  • sigaction(SIGTERM, &sa, NULL): SIGTERM 발생 시 동작을 설정합니다.

시그널 처리기 동작의 제한사항

  • 시그널 처리기 내에서 호출할 수 있는 함수는 제한적입니다(재진입 가능 함수만 허용).
  • 다중 시그널이 동시에 발생할 경우, 처리 순서가 보장되지 않을 수 있습니다.
  • SIGKILL 및 SIGSTOP은 처리기를 설정할 수 없습니다(기본 동작만 수행).

시그널 처리기를 적절히 설정하면 프로세스 제어와 관련된 작업을 유연하고 효과적으로 수행할 수 있습니다.

SIGINT와 SIGTERM 활용 예시


SIGINT와 SIGTERM은 프로세스를 제어하는 데 가장 흔히 사용되는 시그널입니다. 각각의 시그널을 활용하여 프로세스를 중단하거나 종료하는 방법을 간단한 코드 예제를 통해 살펴보겠습니다.

SIGINT를 활용한 중단 예시


SIGINT는 주로 사용자가 키보드(Ctrl + C)를 사용하여 프로세스를 중단할 때 발생합니다. 다음은 SIGINT를 처리하여 사용자 정의 동작을 수행하는 예제입니다.

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

void handle_sigint(int sig) {
    printf("\nSIGINT received. Gracefully stopping the process...\n");
    exit(0);
}

int main() {
    // SIGINT 처리기 등록
    signal(SIGINT, handle_sigint);

    printf("Press Ctrl + C to stop the process.\n");
    while (1) {
        printf("Working...\n");
        sleep(1);
    }
    return 0;
}
  • 핵심 내용
  • signal(SIGINT, handle_sigint): SIGINT 시 호출될 함수 지정.
  • 프로그램 실행 중 Ctrl + C를 누르면 처리기가 실행되며 프로세스가 종료됩니다.

SIGTERM을 활용한 종료 예시


SIGTERM은 프로세스 종료 요청을 보낼 때 사용되며, 이를 통해 종료 전 필요한 정리 작업을 수행할 수 있습니다.

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

void handle_sigterm(int sig) {
    printf("\nSIGTERM received. Cleaning up resources...\n");
    // 리소스 정리 코드
    printf("Exiting now.\n");
    exit(0);
}

int main() {
    // SIGTERM 처리기 등록
    signal(SIGTERM, handle_sigterm);

    printf("Process running. Send SIGTERM to terminate.\n");
    while (1) {
        printf("Processing...\n");
        sleep(1);
    }
    return 0;
}
  • 핵심 내용
  • signal(SIGTERM, handle_sigterm): SIGTERM을 처리하는 함수 등록.
  • 종료 전 리소스 정리 작업을 추가로 수행 가능.

SIGINT와 SIGTERM 비교

특성SIGINTSIGTERM
발생 원인키보드(Ctrl + C) 입력프로세스 종료 요청
기본 동작프로세스 종료프로세스 종료
커스터마이징처리기를 통해 동작 정의 가능처리기를 통해 동작 정의 가능
일반적인 용도긴급 중단정상적인 종료

SIGINT와 SIGTERM의 활용법을 이해하면, 상황에 맞는 프로세스 제어 및 종료 작업을 구현할 수 있습니다.

여러 시그널 처리하기


운영 체제에서 다양한 시그널을 한 프로세스에서 처리해야 하는 경우가 종종 발생합니다. 이를 위해 여러 시그널 처리기를 등록하거나, 동적으로 시그널 처리 동작을 관리할 수 있습니다.

여러 시그널 처리기의 등록


각 시그널에 대해 개별적인 처리기를 등록하여 특정 작업을 수행할 수 있습니다.

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

void handle_sigint(int sig) {
    printf("\nSIGINT received. Interrupting...\n");
}

void handle_sigterm(int sig) {
    printf("\nSIGTERM received. Cleaning up and exiting...\n");
    exit(0);
}

void handle_sighup(int sig) {
    printf("\nSIGHUP received. Reloading configuration...\n");
}

int main() {
    // 각 시그널에 대해 처리기 등록
    signal(SIGINT, handle_sigint);
    signal(SIGTERM, handle_sigterm);
    signal(SIGHUP, handle_sighup);

    printf("Process running. Send SIGINT, SIGTERM, or SIGHUP.\n");
    while (1) {
        pause();  // 시그널 대기
    }
    return 0;
}
  • 핵심 내용
  • 각 시그널에 대해 별도의 처리기를 정의하여 동작을 분리합니다.
  • signal() 함수로 여러 시그널 처리기를 등록합니다.

동적 시그널 처리


모든 시그널을 한 처리기로 관리하고, 시그널 번호에 따라 동작을 결정할 수도 있습니다.

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

void handle_signals(int sig) {
    switch (sig) {
        case SIGINT:
            printf("\nSIGINT received. Stopping the process...\n");
            exit(0);
        case SIGTERM:
            printf("\nSIGTERM received. Cleaning up...\n");
            exit(0);
        case SIGHUP:
            printf("\nSIGHUP received. Reloading configuration...\n");
            break;
        default:
            printf("\nUnknown signal (%d) received.\n", sig);
    }
}

int main() {
    struct sigaction sa;
    sa.sa_handler = handle_signals;
    sa.sa_flags = 0;
    sigemptyset(&sa.sa_mask);

    // 모든 시그널 처리기를 동일한 함수로 설정
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGHUP, &sa, NULL);

    printf("Process running. Send SIGINT, SIGTERM, or SIGHUP.\n");
    while (1) {
        pause();  // 시그널 대기
    }
    return 0;
}
  • 핵심 내용
  • sigaction()을 사용해 모든 시그널을 단일 처리기로 관리.
  • 처리기 내부에서 시그널 번호에 따라 분기 처리.

예외 처리와 시그널 관리의 효율성

  • 동적 처리의 장점: 하나의 함수에서 다양한 시그널을 처리할 수 있어 코드 관리가 간결합니다.
  • 개별 처리의 장점: 시그널마다 독립적인 동작을 수행하도록 세밀한 제어가 가능합니다.

여러 시그널 처리 기술을 활용하면 프로세스 제어와 관련된 복잡한 요구사항을 충족시킬 수 있습니다. 프로젝트 상황에 맞는 방식을 선택하는 것이 중요합니다.

시그널 블로킹과 비동기 처리


프로세스가 특정 시그널을 처리하지 않거나, 여러 시그널이 동시에 발생했을 때 우선순위를 관리해야 하는 경우가 있습니다. 이를 위해 시그널 블로킹과 비동기 처리를 활용합니다.

시그널 블로킹의 개념


시그널 블로킹은 특정 시그널을 일시적으로 차단하여 프로세스가 해당 시그널을 처리하지 않도록 설정하는 메커니즘입니다. 이는 작업의 원자성을 보장하거나, 특정 시점에서 시그널 처리 지연이 필요할 때 사용됩니다.

시그널 블로킹 구현


sigprocmask() 함수를 사용해 특정 시그널을 블로킹하거나 차단 해제할 수 있습니다.

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

void handle_signal(int sig) {
    printf("\nSignal %d received.\n", sig);
}

int main() {
    sigset_t block_set, old_set;

    // SIGINT 블로킹 설정
    sigemptyset(&block_set);
    sigaddset(&block_set, SIGINT);
    sigprocmask(SIG_BLOCK, &block_set, &old_set);

    printf("SIGINT is now blocked. Try pressing Ctrl + C.\n");
    sleep(5);

    // SIGINT 블로킹 해제
    sigprocmask(SIG_SETMASK, &old_set, NULL);
    printf("SIGINT is now unblocked. Press Ctrl + C again.\n");

    signal(SIGINT, handle_signal);
    while (1) {
        pause();  // 시그널 대기
    }
    return 0;
}
  • 핵심 내용
  • sigaddset(): 블로킹할 시그널을 집합에 추가.
  • sigprocmask(): 현재 시그널 블로킹 상태를 설정하거나 복원.
  • 특정 작업 동안 SIGINT가 처리되지 않도록 차단.

비동기 시그널 처리


비동기 처리는 특정 작업 중에도 시그널을 처리할 수 있도록 지원합니다.

  1. 시그널 대기: sigwait()를 사용하여 지정된 시그널을 동기적으로 처리.
  2. 비동기 알림: SA_SIGINFO 플래그를 사용해 추가 정보를 전달.

비동기 처리 예제

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

void handle_signal(int sig, siginfo_t *info, void *context) {
    printf("\nAsynchronous signal %d received from PID: %d.\n", sig, info->si_pid);
}

int main() {
    struct sigaction sa;
    sa.sa_flags = SA_SIGINFO;  // 추가 정보 제공
    sa.sa_sigaction = handle_signal;

    sigaction(SIGINT, &sa, NULL);

    printf("Waiting for SIGINT (Ctrl + C)...\n");
    while (1) {
        pause();  // 시그널 대기
    }
    return 0;
}
  • 핵심 내용
  • SA_SIGINFO: 시그널 발생 관련 추가 정보 제공.
  • siginfo_t: 시그널 발생의 상세 정보를 담는 구조체.

시그널 블로킹과 비동기 처리의 활용

  • 시그널 블로킹
  • 데이터 정합성을 유지해야 하는 크리티컬 섹션 보호.
  • 특정 작업 완료 전 시그널 처리를 지연.
  • 비동기 처리
  • 이벤트 기반 프로그래밍에 유용.
  • 시그널 발생 시 상세 정보 로그 및 사용자 지정 동작 수행.

시그널 블로킹과 비동기 처리를 적절히 사용하면, 복잡한 프로세스 제어 및 안정성을 보장하는 시스템을 설계할 수 있습니다.

SIGKILL과 SIGSTOP의 특수성


SIGKILL과 SIGSTOP은 다른 시그널과 차별화된 특수한 속성을 가지고 있습니다. 이들은 운영 체제에 의해 강제적으로 처리되며, 개발자가 직접 처리기를 설정하거나 동작을 변경할 수 없습니다. 이러한 특성으로 인해, 두 시그널은 프로세스 제어에서 매우 강력한 도구로 사용됩니다.

SIGKILL (번호: 9)


SIGKILL은 프로세스를 즉시 종료하는 데 사용됩니다.

  • 기본 동작: 프로세스 즉시 종료(커널이 강제로 종료).
  • 특수성:
  • 프로세스가 이 시그널을 무시하거나 처리할 수 없습니다.
  • 프로세스가 종료 시 리소스 정리 작업을 수행하지 못합니다.
  • 주로 잘못된 상태에서 응답하지 않는 프로세스를 강제 종료할 때 사용됩니다.
  • 사용 방법:
  kill -9 <PID>

운영 체제에서 PID(프로세스 ID)를 기준으로 특정 프로세스를 종료합니다.

SIGKILL 코드 예제

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

int main() {
    printf("Process PID: %d\n", getpid());
    printf("Send SIGKILL to this process using 'kill -9 <PID>'.\n");

    while (1) {
        sleep(1);
    }
    return 0;
}
  • 핵심 내용:
    SIGKILL은 프로세스 내부에서 처리할 수 없으므로, 강제 종료 시 사용됩니다.

SIGSTOP (번호: 19)


SIGSTOP은 프로세스를 일시 정지하는 데 사용됩니다.

  • 기본 동작: 프로세스 정지(커널이 강제로 중단).
  • 특수성:
  • 프로세스가 이 시그널을 무시하거나 처리할 수 없습니다.
  • 프로세스는 정지 상태로 들어가며, SIGCONT 시그널로 재개할 수 있습니다.
  • 디버깅이나 프로세스 상태를 점검할 때 유용합니다.
  • 사용 방법:
  kill -STOP <PID>  # 프로세스 일시 정지
  kill -CONT <PID>  # 프로세스 재개

SIGSTOP 코드 예제

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

int main() {
    printf("Process PID: %d\n", getpid());
    printf("Send SIGSTOP using 'kill -STOP <PID>' and SIGCONT using 'kill -CONT <PID>'.\n");

    while (1) {
        printf("Running...\n");
        sleep(1);
    }
    return 0;
}
  • 핵심 내용:
    SIGSTOP을 사용하여 프로세스를 정지한 후, SIGCONT를 통해 프로세스를 재개할 수 있습니다.

SIGKILL과 SIGSTOP의 차이점

특성SIGKILLSIGSTOP
기본 동작프로세스 강제 종료프로세스 일시 정지
사용자 처리 가능 여부처리 불가처리 불가
주요 용도응답하지 않는 프로세스 종료디버깅 및 프로세스 관리
리소스 정리불가능상태 유지 가능

운영 체제에서의 활용

  • SIGKILL:
    시스템 관리자가 잘못된 상태의 프로세스를 종료해야 할 때 사용.
  • SIGSTOP:
    디버깅 시 프로세스 실행을 일시 중단하거나, 리소스를 점검하는 용도로 활용.

SIGKILL과 SIGSTOP은 프로세스의 동작을 제어하는 데 중요한 역할을 하며, 개발자와 시스템 관리자에게 강력한 제어 도구를 제공합니다.

디버깅과 트러블슈팅


시그널 처리 코드를 작성하거나 운영 체제에서 시그널을 활용하는 중에는 예기치 않은 문제를 마주칠 수 있습니다. 이러한 문제를 효과적으로 디버깅하고 해결하는 방법을 살펴보겠습니다.

디버깅 시그널 처리 코드

1. 로그 추가


시그널 처리기 내부에 로그를 추가하면, 시그널 발생 시점과 상태를 확인할 수 있습니다.

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

void handle_signal(int sig) {
    printf("Signal %d received.\n", sig);
}

int main() {
    signal(SIGINT, handle_signal);
    printf("Waiting for SIGINT...\n");

    while (1) {
        pause();
    }
    return 0;
}
  • 핵심 내용: printf를 사용해 시그널 발생 로그를 출력합니다.
  • 문제 해결: 처리기의 호출 여부 및 시그널 번호를 실시간으로 확인 가능.

2. 디버거 활용


gdb와 같은 디버거를 사용하면 프로세스 상태와 시그널 흐름을 분석할 수 있습니다.

gdb ./program
run
# 프로세스 실행 중 SIGINT 시그널 전송
kill -SIGINT <PID>
# SIGINT 발생 후 처리 상태 점검
  • 핵심 내용: 디버거를 사용하여 처리기 호출 흐름 및 메모리 상태를 점검합니다.

3. 시그널 발생 시점 분석


시그널이 예상대로 발생하지 않을 경우, 발생 조건을 검토하고 시그널 전달 여부를 확인합니다.

  • kill 명령을 통해 프로세스에 직접 시그널을 보냄으로써 시그널 전달 경로를 점검.
  • strace를 사용해 시그널 시스템 호출을 추적.
  strace -e signal ./program

트러블슈팅 주요 문제

1. 시그널 누락

  • 원인: 시그널이 블로킹 상태에 있거나, 처리기가 등록되지 않았을 수 있습니다.
  • 해결:
  • sigprocmask()를 사용해 블로킹 상태를 확인하고, 필요한 경우 해제합니다.
  • signal() 또는 sigaction()을 통해 처리기가 올바르게 등록되었는지 점검합니다.

2. SIGKILL/SIGSTOP 관련 문제

  • 원인: 이 시그널은 처리기를 등록할 수 없습니다.
  • 해결:
  • 프로그램 외부에서만 제어 가능하므로, kill 명령이나 시스템 명령어를 사용해 동작을 확인합니다.
  • SIGKILL로 종료 시 리소스 정리 로직을 다른 시그널(SIGTERM)에서 수행하도록 구현합니다.

3. 시그널 처리 중 충돌

  • 원인: 처리기 내에서 비재진입 함수 호출로 인해 충돌이 발생할 수 있습니다.
  • 해결:
  • 시그널 처리기 내에서 안전한 함수만 호출(예: write() 사용).
  • 처리기를 최소한의 로직으로 간결하게 설계하고, 복잡한 작업은 메인 루프에서 처리.

시그널 처리 모니터링 도구

  1. ps 명령
    프로세스 상태와 시그널 전달 여부를 확인합니다.
   ps -e -o pid,stat,cmd
  1. kill 명령
    특정 프로세스에 시그널을 전달합니다.
   kill -SIGINT <PID>
  1. strace 명령
    시그널 관련 시스템 호출을 추적합니다.
   strace -e signal ./program

시그널 처리 시 유용한 팁

  • 리소스 정리 우선: SIGTERM 처리기에서 리소스를 정리하여 예상치 못한 종료에도 안전성을 확보합니다.
  • 비재진입 함수 피하기: 시그널 처리기는 간결하게 설계하여 비재진입 함수 호출로 인한 문제를 방지합니다.
  • 디버깅 반복: 디버거와 로그를 활용하여 처리 로직을 세밀히 점검합니다.

이러한 디버깅 및 트러블슈팅 방법을 통해, 시그널 처리 관련 문제를 효과적으로 해결할 수 있습니다.

요약


이 기사에서는 C 언어에서 시그널(SIGINT, SIGTERM 등)을 활용한 프로세스 제어의 기본 개념과 구현 방법을 다뤘습니다. 시그널의 정의와 주요 유형, 시그널 처리기 설정 및 활용법, 블로킹과 비동기 처리, 그리고 SIGKILL과 SIGSTOP의 특수성까지 구체적으로 설명했습니다. 또한 디버깅 및 트러블슈팅 기법을 통해 실무적인 문제 해결 능력을 높이는 방법을 제시했습니다.

적절한 시그널 처리를 통해 시스템 프로그래밍의 안정성과 효율성을 극대화할 수 있습니다.

C 언어
C언어 시그널 처리 프로세스 제어
목차