Signal handlers often need to communicate with the main program — the most common way is a shared global variable. But this has two subtle problems:

The C standard provides the type sig_atomic_t (defined in <signal.h>) specifically for this purpose. Reads and writes to this type are guaranteed to be atomic on every POSIX-compliant platform.

You must combine it with volatile to prevent compiler optimizations from caching the value in a register.

/* Correct declaration of a flag shared between main() and a signal handler */
static volatile sig_atomic_t flag = 0;

On Linux, SIG_ATOMIC_MIN and SIG_ATOMIC_MAX are defined as the limits of a signed 32-bit integer (–2147483648 to 2147483647). POSIX guarantees at minimum –127 to 127.

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

/*
 * CORRECT: volatile prevents compiler from caching in a register.
 * sig_atomic_t guarantees atomic set/read.
 */
static volatile sig_atomic_t shutdown_requested = 0;
static volatile sig_atomic_t alarm_fired = 0;

static void sigint_handler(int sig)
{
    shutdown_requested = 1;   /* Only SET — do not increment */
}

static void sigalrm_handler(int sig)
{
    alarm_fired = 1;           /* Only SET */
}

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

    sa.sa_handler = sigint_handler;
    sigaction(SIGINT, &sa, NULL);

    sa.sa_handler = sigalrm_handler;
    sigaction(SIGALRM, &sa, NULL);

    alarm(5);  /* Fire SIGALRM after 5 seconds */

    printf("PID=%d. Ctrl+C to stop, or wait 5s for alarm.\n", (int)getpid());

    while (!shutdown_requested && !alarm_fired) {
        /*
         * Main loop safely reads both flags.
         * Because they are volatile, the compiler MUST re-read from memory
         * every iteration — it cannot cache the value in a register.
         */
        sleep(1);
        printf("Working...\n");
    }

    if (shutdown_requested)
        printf("Stopped by SIGINT.\n");
    if (alarm_fired)
        printf("Stopped by SIGALRM after 5 seconds.\n");

    return 0;
}

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

/*
 * WRONG: no volatile. With -O2 optimization, the compiler MAY
 * hoist the check outside the loop, turning:
 *
 *   while (!flag) { ... }
 *
 * into:
 *
 *   if (!flag) { while(1) { ... } }  // flag never re-read!
 *
 * The signal handler sets flag = 1, but the loop never sees it.
 */
static sig_atomic_t flag = 0;  /* Missing volatile! */

static void handler(int sig) { flag = 1; }

int main(void)
{
    signal(SIGINT, handler);

    /*
     * With aggressive optimization (-O2), this loop may run forever
     * even after Ctrl+C, because the compiler cached 'flag' in a register.
     * Adding 'volatile' fixes this.
     */
    while (!flag) {
        /* do work */
    }
    printf("Flag was set.\n");
    return 0;
}

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

/* One flag per signal type of interest */
static volatile sig_atomic_t got_sigint  = 0;
static volatile sig_atomic_t got_sigterm = 0;
static volatile sig_atomic_t got_sighup  = 0;
static volatile sig_atomic_t got_sigusr1 = 0;

/*
 * A single handler for multiple signals.
 * We use 'sig' to decide which flag to set.
 */
static void generic_handler(int sig)
{
    switch (sig) {
        case SIGINT:  got_sigint  = 1; break;
        case SIGTERM: got_sigterm = 1; break;
        case SIGHUP:  got_sighup  = 1; break;
        case SIGUSR1: got_sigusr1 = 1; break;
    }
}

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

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

    printf("PID=%d. Ready. Send signals: kill -INT/-TERM/-HUP/-USR1 %d\n",
           (int)getpid(), (int)getpid());

    while (1) {
        /* Check all flags in main loop */
        if (got_sigint)  { printf("[Main] SIGINT received\n");  got_sigint  = 0; break; }
        if (got_sigterm) { printf("[Main] SIGTERM received\n"); got_sigterm = 0; break; }
        if (got_sighup)  { printf("[Main] SIGHUP — reload config\n"); got_sighup = 0; }
        if (got_sigusr1) { printf("[Main] SIGUSR1 — status dump\n");  got_sigusr1 = 0; }

        sleep(1);
    }

    printf("Shutting down cleanly.\n");
    return 0;
}