# Are you volatile?

The `volatile` keyword in C is used to inform the compiler that the value of a variable may change at any time, without any action being taken by the code the compiler finds nearby. This is often necessary in embedded systems where certain memory locations are mapped to device registers or in multi-threaded applications where a variable may be modified by another thread.

When you declare a variable as `volatile`, the compiler avoids optimizations that are based on the assumption that the value of the variable cannot change unexpectedly. As a result, each time the variable is accessed, the compiler will always fetch its value from the memory location instead of relying on a cached value that might be out-of-date.

Let's consider an example where `volatile` is useful. Suppose we have a signal handler that changes a flag, and a main loop that waits for this flag to change:

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

volatile sig_atomic_t flag = 0;

void signal_handler(int signum) {
    flag = 1;
}

int main() {
    signal(SIGINT, signal_handler);
    while (!flag) {
        // Main loop does something
    }
    printf("Signal received, flag set to %d\n", flag);
    return 0;
}
```

In this code, `flag` is declared with `volatile` because it is modified by `signal_handler`, which could be called asynchronously. Without `volatile`, the compiler might optimize the loop in `main` in such a way that it never fetches the updated value of `flag`.

### Compiling and Running the Code

To compile and run this C program on a Linux system, you can use `gcc` from the bash shell. Here's how you might do it:

1. **Write the Code**: Save the above code in a file, say `volatile_example.c`.
    
2. **Compile the Code**: Open a terminal and compile the code using `gcc`:
    
    ```bash
    gcc -o volatile_example volatile_example.c
    ```
    
3. **Run the Program**: Run the compiled program:
    
    ```bash
    ./volatile_example
    ```
    
    Now, if you send a SIGINT signal (typically by pressing Ctrl+C) to the program while it's running, the signal handler will set `flag` to 1, and the loop in `main` will exit, printing the message.