多线程程序段错误（核心已转储）：质数计算程序线程问题排查

Hey there, let's tackle that frustrating segfault in your prime-checking program. Segfaults with pthread operations almost always trace back to mismanaging thread handles, invalid memory access, or improper synchronization—especially in loops where you're checking and joining threads. Let's break down the most likely culprits and fix them.

Common Pitfalls Causing Your Segfault #

1. Out-of-Bounds Access to Thread Handles #

If your loop variable i is going beyond the size of your pthread_t array (e.g., if THRE is the number of threads but your array is smaller, or you're using an off-by-one error), you'll be accessing invalid memory. This is a classic cause of segfaults. Double-check that your thread array is sized exactly to THRE (or whatever constant you're using) and that your loop runs from 0 to THRE - 1, not THRE.

2. Double-Joining Threads #

Once you call pthread_join on a thread handle, that handle becomes invalid. If your loop doesn't track which threads have already been joined and tries to call pthread_join again on the same handle, you'll trigger undefined behavior—often a segfault. You need a way to mark threads as completed (like a boolean array) so you only attempt to join active threads once.

3. Invalid Shared Memory Access #

If test_val or other variables shared between threads aren't protected by a mutex, you could have race conditions leading to corrupted memory. Even worse, if you're passing pointers to stack-allocated variables to your threads, those variables might go out of scope before the thread uses them, leading to invalid memory access.

4. Ignoring pthread_create Errors #

If pthread_create fails (returns a non-zero value), the corresponding thread handle will be invalid. Trying to join an invalid handle will immediately cause a segfault. Always check the return value of pthread_create and handle errors properly.

Fixing Your Thread Join Loop #

Based on your code snippet, here's a corrected approach for checking and joining threads safely:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define THREAD_COUNT 4
#define FINAL 1000

// Shared variables (protected by mutex)
int test_val = 2;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// Track active threads (1 = active, 0 = joined/finished)
int thread_active[THREAD_COUNT];

// Thread function example (simplified prime check)
void* check_primes(void* arg) {
    int thread_id = *(int*)arg;
    free(arg); // Clean up the allocated thread ID

    while (1) {
        pthread_mutex_lock(&mutex);
        int val = test_val;
        if (val > FINAL) {
            pthread_mutex_unlock(&mutex);
            break;
        }
        test_val++;
        pthread_mutex_unlock(&mutex);

        // Simple prime check
        int is_prime = 1;
        for (int i = 2; i*i <= val; i++) {
            if (val % i == 0) {
                is_prime = 0;
                break;
            }
        }
        if (is_prime) {
            printf("Thread %d found prime: %d\n", thread_id, val);
        }
    }
    return NULL;
}

int main() {
    pthread_t threads[THREAD_COUNT];

    // Initialize thread active flags
    for (int i = 0; i < THREAD_COUNT; i++) {
        thread_active[i] = 1;
        // Allocate thread ID to avoid stack scope issues
        int* thread_id = malloc(sizeof(int));
        *thread_id = i;
        int create_result = pthread_create(&threads[i], NULL, check_primes, thread_id);
        if (create_result != 0) {
            fprintf(stderr, "Failed to create thread %d: %s\n", i, strerror(create_result));
            exit(EXIT_FAILURE);
        }
    }

    // Your original loop to check and join threads
    while (1) {
        pthread_mutex_lock(&mutex);
        int done = (test_val > FINAL);
        pthread_mutex_unlock(&mutex);
        if (done) break;

        for (int i = 0; i < THREAD_COUNT; i++) {
            if (thread_active[i]) {
                // Try to join without blocking (use pthread_tryjoin_np if available)
                int join_result = pthread_tryjoin_np(threads[i], NULL);
                if (join_result == 0) {
                    // Thread successfully joined
                    thread_active[i] = 0;
                    printf("Thread %d completed\n", i);
                } else if (join_result != EBUSY) {
                    // Unexpected error during join
                    fprintf(stderr, "Failed to join thread %d: %s\n", i, strerror(join_result));
                    exit(EXIT_FAILURE);
                }
                // EBUSY means thread is still running—move to next
            }
        }
    }

    // Join any remaining threads that might still be running
    for (int i = 0; i < THREAD_COUNT; i++) {
        if (thread_active[i]) {
            if (pthread_join(threads[i], NULL) != 0) {
                perror("Final pthread_join failed");
            }
            thread_active[i] = 0;
        }
    }

    pthread_mutex_destroy(&mutex);
    return 0;
}

Key fixes in this example:

• A thread_active array to track which threads haven't been joined yet
• Proper error checking for pthread_create and pthread_join
• Mutex protection for the shared test_val to avoid race conditions
• Allocating thread IDs dynamically instead of passing stack variables (prevents invalid pointer access)
• Using pthread_tryjoin_np to check thread status without blocking (note: this is a GNU extension; if you need portability, use condition variables instead)

Additional Checks #

• Make sure all shared variables are properly synchronized with mutexes
• Verify that your FINAL and THRE constants are correctly defined and used
• Compile with -g and use gdb to debug the segfault (run gdb ./primes, then run, and bt to get a backtrace of where the crash happens)

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