Stdout thread-safe in C on Linux?

When programming in C on Linux, thread safety is a critical consideration, especially in multithreaded environments. Many functions in the C standard library are not inherently thread-safe, but the GNU C library (glibc) provides thread-safe versions.

What is Thread Safety?

Thread safety refers to the ability of code to correctly handle multiple threads executing the same code segment concurrently or in an interleaved manner within a multithreaded environment. Thread-safe code can avoid issues such as data races and deadlocks.

Thread Safety Issues in the C Standard Library

In the C standard library, some functions are not thread-safe. For example, the strtok() function is used for string splitting and relies on static storage to store data, which can cause conflicts when multiple threads call it simultaneously. To address this issue, the C library provides a thread-safe version, strtok_r(), which requires additional parameters to store intermediate state, thereby avoiding shared static data.

Approaches to Achieving Thread Safety

To write thread-safe code, several common strategies can be employed:

1. Mutexes: Using mutexes ensures that only one thread executes a specific code segment at a time. This is the most direct method for ensuring thread safety.

2. Lock-free programming: By leveraging atomic operations for lock-free programming, thread safety can be achieved without locks. This typically requires hardware support.

3. Thread-local storage (TLS): Using thread-local storage provides each thread with its own instance of variables, thus avoiding data sharing issues between threads.

4. Reentrancy: Code is designed to be reentrant, meaning it can be interrupted during execution and safely called (or recursively called) without issues.

Example

Suppose we need to update a global variable across multiple threads; we can use mutexes to ensure thread-safe updates:

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

int global_variable = 0;
pthread_mutex_t lock;

void* update_variable(void* arg) {
    for (int i = 0; i < 10000; ++i) {
        pthread_mutex_lock(&lock);
        global_variable++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;

    pthread_mutex_init(&lock, NULL);

    pthread_create(&t1, NULL, update_variable, NULL);
    pthread_create(&t2, NULL, update_variable, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("Final value of global_variable is %d\n", global_variable);

    pthread_mutex_destroy(&lock);

    return 0;
}

In this example, both threads attempt to update the global variable global_variable. Using the mutex lock ensures that only one thread modifies the variable at a time, thereby avoiding race conditions.

Overall, writing thread-safe C code requires careful consideration of concurrent access issues and the use of appropriate synchronization mechanisms to ensure data consistency and integrity.