C 언어에서 타이머를 활용한 프로세스 및 스레드 제어 방법

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

void timer_handler(int sig) {
    printf("타이머 신호를 수신했습니다. 프로세스를 종료합니다.\n");
    _exit(0);
}

int main() {
    struct sigaction sa;
    struct itimerspec ts;
    timer_t timerid;

    // 신호 처리기 설정
    sa.sa_flags = 0;
    sa.sa_handler = timer_handler;
    sigaction(SIGALRM, &sa, NULL);

    // 타이머 생성
    timer_create(CLOCK_REALTIME, NULL, &timerid);

    // 타이머 설정 (5초 후 종료)
    ts.it_value.tv_sec = 5;
    ts.it_value.tv_nsec = 0;
    ts.it_interval.tv_sec = 0;
    ts.it_interval.tv_nsec = 0;
    timer_settime(timerid, 0, &ts, NULL);

    printf("타이머가 설정되었습니다. 5초 후에 종료됩니다.\n");

    // 프로세스 작업 수행
    while (1) {
        printf("작업 실행 중...\n");
        sleep(1);
    }

    return 0;
}

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

void* thread_function(void* arg) {
    printf("스레드가 시작되었습니다. 2초 후 작업을 수행합니다.\n");
    struct timespec ts;
    ts.tv_sec = 2; // 2초 대기
    ts.tv_nsec = 0;

    nanosleep(&ts, NULL); // 스레드 대기
    printf("스레드 작업이 완료되었습니다.\n");

    return NULL;
}

int main() {
    pthread_t thread_id;

    // 스레드 생성
    pthread_create(&thread_id, NULL, thread_function, NULL);
    printf("메인 스레드에서 작업을 수행 중입니다.\n");

    // 스레드 대기
    pthread_join(thread_id, NULL);
    printf("모든 작업이 완료되었습니다.\n");

    return 0;
}

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

void signal_handler(int sig) {
    printf("타이머가 만료되었습니다! 작업을 수행합니다.\n");
}

int main() {
    struct sigaction sa;
    struct itimerspec ts;
    timer_t timerid;

    // 신호 처리기 설정
    sa.sa_flags = 0;
    sa.sa_handler = signal_handler;
    sigaction(SIGRTMIN, &sa, NULL);

    // 타이머 생성
    timer_create(CLOCK_REALTIME, NULL, &timerid);

    // 타이머 설정 (2초 간격 반복)
    ts.it_value.tv_sec = 2;
    ts.it_value.tv_nsec = 0;
    ts.it_interval.tv_sec = 2;
    ts.it_interval.tv_nsec = 0;
    timer_settime(timerid, 0, &ts, NULL);

    printf("타이머가 설정되었습니다. 신호 대기 중...\n");

    // 메인 루프
    while (1) {
        pause(); // 신호 대기
    }

    return 0;
}

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

void callback_function(union sigval sv) {
    printf("콜백 함수 실행: 타이머 ID %d\n", *(int *)sv.sival_ptr);
}

int main() {
    struct sigevent sev;
    struct itimerspec ts;
    timer_t timerid;
    int timer_data = 42; // 사용자 데이터

    // sigevent 설정
    sev.sigev_notify = SIGEV_THREAD; // 타이머 만료 시 별도 스레드에서 실행
    sev.sigev_notify_function = callback_function;
    sev.sigev_value.sival_ptr = &timer_data;

    // 타이머 생성
    timer_create(CLOCK_REALTIME, &sev, &timerid);

    // 타이머 설정 (3초 후 1초 간격 반복)
    ts.it_value.tv_sec = 3;
    ts.it_value.tv_nsec = 0;
    ts.it_interval.tv_sec = 1;
    ts.it_interval.tv_nsec = 0;
    timer_settime(timerid, 0, &ts, NULL);

    printf("타이머가 설정되었습니다. 콜백 대기 중...\n");

    // 메인 루프
    while (1) {
        pause();
    }

    return 0;
}

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

void collect_data() {
    printf("센서 데이터를 수집 중...\n");
}

int main() {
    struct timespec ts;
    ts.tv_sec = 2; // 2초 주기
    ts.tv_nsec = 0;

    while (1) {
        collect_data();
        nanosleep(&ts, NULL); // 주기적으로 대기
    }

    return 0;
}

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

void spawn_enemy() {
    printf("적이 생성되었습니다!\n");
}

int main() {
    struct sigevent sev;
    struct itimerspec ts;
    timer_t timerid;

    // 타이머 설정
    sev.sigev_notify = SIGEV_THREAD;
    sev.sigev_notify_function = (void (*)(union sigval))spawn_enemy;
    timer_create(CLOCK_REALTIME, &sev, &timerid);

    ts.it_value.tv_sec = 5; // 5초 후 실행
    ts.it_value.tv_nsec = 0;
    ts.it_interval.tv_sec = 10; // 이후 10초 간격으로 반복
    ts.it_interval.tv_nsec = 0;
    timer_settime(timerid, 0, &ts, NULL);

    printf("게임 이벤트 타이머가 설정되었습니다.\n");
    while (1) {
        pause();
    }

    return 0;
}

#include <stdio.h>
#include <time.h>

void log_server_status() {
    printf("서버 상태를 확인하고 로그를 기록합니다.\n");
}

int main() {
    struct sigevent sev;
    struct itimerspec ts;
    timer_t timerid;

    // 타이머 설정
    sev.sigev_notify = SIGEV_THREAD;
    sev.sigev_notify_function = (void (*)(union sigval))log_server_status;
    timer_create(CLOCK_REALTIME, &sev, &timerid);

    ts.it_value.tv_sec = 2; // 2초 후 실행
    ts.it_value.tv_nsec = 0;
    ts.it_interval.tv_sec = 5; // 이후 5초 간격으로 반복
    ts.it_interval.tv_nsec = 0;
    timer_settime(timerid, 0, &ts, NULL);

    printf("서버 모니터링 타이머가 시작되었습니다.\n");
    while (1) {
        pause();
    }

    return 0;
}

#include <stdio.h>
#include <time.h>

void sample_task() {
    for (int i = 0; i < 100000000; i++) {} // 작업 시뮬레이션
}

int main() {
    struct timespec start, end;
    double elapsed_time;

    clock_gettime(CLOCK_MONOTONIC, &start); // 시작 시간 기록
    sample_task();
    clock_gettime(CLOCK_MONOTONIC, &end);   // 종료 시간 기록

    // 실행 시간 계산
    elapsed_time = (end.tv_sec - start.tv_sec) + 
                   (end.tv_nsec - start.tv_nsec) / 1e9;
    printf("작업 실행 시간: %.3f초\n", elapsed_time);

    return 0;
}

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

void status_logger(int sig) {
    printf("프로세스 상태: 정상 작동 중\n");
}

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

    // 주기적 신호 발생 (3초 간격)
    alarm(3);

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

    return 0;
}

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

void* thread_function(void* arg) {
    printf("스레드 작업 시작\n");
    sleep(1); // 타이밍 이슈 시뮬레이션
    printf("스레드 작업 완료\n");
    return NULL;
}

int main() {
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, thread_function, NULL);

    printf("메인 스레드에서 동기화 확인\n");
    pthread_join(thread_id, NULL);

    printf("모든 작업 완료\n");
    return 0;
}

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

void timeout_handler(int sig) {
    printf("시간 초과: 작업 강제 종료\n");
    _exit(1);
}

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

    alarm(5); // 5초 제한 설정
    printf("작업 시작...\n");
    sleep(10); // 시간이 초과되는 작업
    printf("작업 완료\n");

    return 0;
}