C语言多线程应用段错误与输出异常问题求助

Hey there, let's break down the issues you're facing with your multi-threaded C program—segfaults and wonky output are classic pitfalls when working with pthreads, but we can work through them step by step. Here are the most likely culprits and how to fix them:

1. Data Races on the Global Array (Biggest Suspect) #

Your m "writer" threads are all cramming random numbers into the same global array without any synchronization. When multiple threads write to the same memory location at the same time, you get data races—this can corrupt the array's memory structure (leading to segfaults) or leave garbage values that throw off your sum/average calculations.

Fix Options: #

• Partition the array: Assign each writer thread its own dedicated chunk of the array. For example, if your array is sized m * 30, thread i writes to indices i*30 to (i+1)*30 - 1. No locks needed here since each thread only touches its own slice—super efficient.
• Use a mutex: If partitioning isn't feasible, add a pthread_mutex_t lock around all accesses (read AND write) to the global array. Initialize it once before starting threads, lock it before modifying/reading the array, and unlock it afterward.

Example of a mutex setup:

#include <pthread.h>

pthread_mutex_t array_lock;
int global_array[1000]; // Adjust size to m*30

// Writer thread function
void *write_numbers(void *arg) {
    int thread_id = *(int*)arg;
    pthread_mutex_lock(&array_lock);
    for (int i = 0; i < 30; i++) {
        global_array[thread_id*30 + i] = rand() % 100;
    }
    pthread_mutex_unlock(&array_lock);
    pthread_exit(NULL);
}

2. Broken Thread Waiting Logic #

You mentioned the m "reader" threads use pthread_join to wait for the first thread—but this is ambiguous. If readers start before all writers finish, they'll read uninitialized or half-written data, which can cause segfaults or wrong sums.

Fixes: #

• Wait for specific writers: If each reader is paired with a writer, pass the writer's pthread_t handle to the reader thread, so it can pthread_join that exact writer before reading.
• Wait for all writers first: Start all writer threads, join every single one in the main thread, then start the reader threads. This ensures the entire array is fully populated before any reading happens.

Example of waiting for all writers first:

pthread_t writer_threads[m];
pthread_t reader_threads[m];

// Start all writers
for (int i = 0; i < m; i++) {
    int *id = malloc(sizeof(int));
    *id = i;
    pthread_create(&writer_threads[i], NULL, write_numbers, id);
}

// Wait for all writers to finish
for (int i = 0; i < m; i++) {
    pthread_join(writer_threads[i], NULL);
}

// Now start all readers
for (int i = 0; i < m; i++) {
    int *id = malloc(sizeof(int));
    *id = i;
    pthread_create(&reader_threads[i], NULL, calculate_sum, id);
}

3. Out-of-Bounds Array Access #

If your global array isn't sized correctly (e.g., it's smaller than m*30), writers will overwrite memory beyond the array's bounds. This is a guaranteed way to get segfaults or corrupt other variables.

Fix: #

Double-check that your array is declared with a size of m * 30 (or dynamically allocated with malloc(m * 30 * sizeof(int)) if m is a runtime variable). Also, make sure each writer thread is writing to its correct index range (no off-by-one errors!).

4. Non-Thread-Safe Random Number Generation #

The standard rand() function isn't thread-safe—it uses a shared internal state. If multiple writer threads call rand() at the same time, it can corrupt that state, leading to duplicate numbers, garbage values, or even segfaults.

Fix: #

Use rand_r() instead, which takes a thread-specific seed pointer. Initialize a unique seed for each thread (e.g., using the thread ID or a timestamp plus thread ID):

void *write_numbers(void *arg) {
    int thread_id = *(int*)arg;
    unsigned int seed = thread_id + time(NULL); // Unique seed per thread
    for (int i = 0; i < 30; i++) {
        global_array[thread_id*30 + i] = rand_r(&seed) % 100;
    }
    pthread_exit(NULL);
}

Debugging Tips to Narrow It Down #

• Use gdb to catch the segfault: Run gdb ./your_program, then run—when it crashes, use backtrace to see exactly which line caused the fault.
• Check for data races with valgrind --tool=helgrind ./your_program—it will flag any unsynchronized access to shared memory.
• Add debug prints: Print the indices each writer is writing to, and the values being stored, to verify they're not overlapping or out of bounds.

内容的提问来源于stack exchange，提问作者Zorg