alarm系统调用及示例

#include <unistd.h> // 必需

unsigned int alarm(unsigned int seconds);

#include <unistd.h>   // alarm
#include <signal.h>   // signal, SIGALRM
#include <stdio.h>    // printf, perror
#include <stdlib.h>   // exit
#include <errno.h>    // errno (虽然 alarm 不会失败，但信号处理可能涉及)
#include <string.h>   // strerror

volatile sig_atomic_t alarm_flag = 0;

// SIGALRM 信号处理函数
void alarm_handler(int sig) {
    // 在信号处理函数中，应只调用异步信号安全的函数
    // printf 通常被认为是安全的，但更安全的做法是只修改标志
    write(STDERR_FILENO, "Alarm! SIGALRM signal received.\n", 32);
    alarm_flag = 1; // 设置全局标志
}

int main() {
    unsigned int remaining;

    printf("Process PID: %d\n", getpid());

    // 1. 设置 SIGALRM 信号处理函数
    if (signal(SIGALRM, alarm_handler) == SIG_ERR) {
        perror("signal SIGALRM");
        exit(EXIT_FAILURE);
    }

    // 2. 设置一个 3 秒的 alarm 定时器
    printf("Setting alarm for 3 seconds.\n");
    remaining = alarm(3);

    // 3. 检查是否有旧的定时器 (应该没有)
    if (remaining > 0) {
        printf("There was an old alarm set to expire in %u seconds. It's now canceled.\n", remaining);
    } else {
        printf("No previous alarm was set.\n");
    }

    // 4. 等待信号
    printf("Waiting for the alarm to go off...\n");
    // 这里使用 pause() 等待信号
    // 在实际应用中，这里可能是 read(), write(), connect() 等阻塞调用
    while (!alarm_flag) {
        pause(); // 挂起进程，直到收到信号
    }

    printf("Main function continuing after alarm.\n");

    // 5. 再设置一个 2 秒的 alarm
    printf("Setting another alarm for 2 seconds.\n");
    remaining = alarm(2);
    if (remaining > 0) {
        printf("Canceled a previous alarm that had %u seconds left.\n", remaining);
    }

    // 6. 等待第二个 alarm
    alarm_flag = 0; // 重置标志
    printf("Waiting for the second alarm...\n");
    while (!alarm_flag) {
        pause();
    }

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

#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h> // 用于非局部跳转 setjmp/longjmp

// jmp_buf 是一个特殊的数据结构，用于保存程序执行状态
static jmp_buf jmp_env;
volatile sig_atomic_t timed_out = 0;

void timeout_handler(int sig) {
    // 当 read 超时，SIGALRM 会触发此处理函数
    write(STDERR_FILENO, "Read operation timed out!\n", 26);
    timed_out = 1;
    // 使用 longjmp 跳转回调用 setjmp 的地方
    longjmp(jmp_env, 1);
}

int main() {
    char buffer[100];
    ssize_t bytes_read;

    printf("Setting timeout handler for SIGALRM.\n");
    if (signal(SIGALRM, timeout_handler) == SIG_ERR) {
        perror("signal SIGALRM");
        exit(EXIT_FAILURE);
    }

    printf("Setting alarm for 5 seconds. Please type something and press Enter:\n");

    // setjmp 保存当前程序执行状态到 jmp_env
    // 首次调用 setjmp 返回 0
    // 当 longjmp 被调用并跳转回来时，setjmp 返回 longjmp 传入的值 (这里是 1)
    if (setjmp(jmp_env) == 0) {
        // 1. 设置 5 秒超时
        alarm(5);

        // 2. 执行可能阻塞的操作
        bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);

        // 3. 如果 read 返回，说明没有超时 (或者在超时前完成了)
        // 取消 alarm (传入 0)
        alarm(0);

        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("You typed: %s", buffer); // buffer 可能已包含 \n
        } else if (bytes_read == 0) {
            printf("EOF reached on input.\n");
        } else {
            perror("read");
        }
    } else {
        // 4. 从 longjmp 跳转到这里 (超时发生)
        printf("Jumped back from timeout handler.\n");
        // 注意：read 可能已被中断，errno 为 EINTR
        // 在这个简单的例子中，我们不重试 read
    }

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

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

int main() {
    unsigned int ret1, ret2, ret3;

    printf("Process PID: %d\n", getpid());
    printf("No alarm set initially.\n");

    // 1. 设置一个 10 秒的 alarm
    printf("Setting alarm for 10 seconds...\n");
    ret1 = alarm(10);
    printf("alarm(10) returned: %u (should be 0, no previous alarm)\n", ret1);

    // 等待一小会儿，让时间流逝
    printf("Sleeping for 3 seconds...\n");
    sleep(3);

    // 2. 设置一个 5 秒的新 alarm，覆盖旧的
    printf("Setting alarm for 5 seconds (should override the previous one)...\n");
    ret2 = alarm(5);
    // 旧 alarm 已运行了 3 秒，还剩 7 秒，所以返回 7
    printf("alarm(5) returned: %u (should be ~7, remaining time of previous alarm)\n", ret2);

    // 再等一小会儿
    printf("Sleeping for 2 more seconds...\n");
    sleep(2);

    // 3. 取消 alarm (设置为 0)
    printf("Canceling alarm (setting it to 0)...\n");
    ret3 = alarm(0);
    // 旧 alarm 已运行了 5 秒，还剩 3 秒，所以返回 3
    printf("alarm(0) returned: %u (should be ~3, remaining time of previous alarm)\n", ret3);

    printf("Alarm canceled. Waiting for 10 seconds to prove no signal is sent.\n");
    sleep(10);
    printf("No signal received. Program finished normally.\n");

    return 0;
}

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

int main() {
    pid_t pid;

    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // --- 子进程 ---
        printf("Child process (PID %d): Ignoring SIGALRM and setting alarm(3).\n", getpid());

        // 忽略 SIGALRM 信号
        if (signal(SIGALRM, SIG_IGN) == SIG_ERR) {
            perror("signal SIG_IGN");
            _exit(EXIT_FAILURE);
        }

        // 设置 3 秒 alarm
        alarm(3);
        printf("Child: Alarm set. Now sleeping for 5 seconds. Alarm should have no effect.\n");

        // 睡眠 5 秒，比 alarm 时间长
        unsigned int slept = sleep(5);
        printf("Child: sleep(5) returned. It claims %u seconds were left unslept.\n", slept);
        if (slept == 0) {
            printf("Child: sleep completed fully. No signal interrupted it.\n");
        } else {
            printf("Child: sleep was interrupted (unexpected in this setup).\n");
        }

        printf("Child process exiting.\n");
        _exit(EXIT_SUCCESS);

    } else {
        // --- 父进程 ---
        printf("Parent process (PID %d): Waiting for child (PID %d) to finish.\n", getpid(), pid);

        int status;
        if (waitpid(pid, &status, 0) == -1) {
            perror("waitpid");
            exit(EXIT_FAILURE);
        }

        if (WIFEXITED(status)) {
            printf("Parent: Child exited normally with status %d.\n", WEXITSTATUS(status));
        } else {
            printf("Parent: Child did not exit normally.\n");
        }
    }

    return 0;
}