Pthread程序在CodeBlocks与Linux环境下输出值不一致问题排查

你的程序在CodeBlocks和Linux环境下输出不同，核心原因大概率是多线程竞争条件和环境差异导致的未定义行为。结合你给出的代码片段，我整理了几个关键问题和对应的解决方案：

1. 全局变量的线程竞争是重灾区 #

你代码里的n1、n2、i还有未写完的计数变量都是全局的，多线程同时读写这些变量时会出现数据竞争。比如两个线程同时执行count++，这个操作不是原子的（会拆成读-改-写三步），不同环境下线程调度顺序不同，就会导致计数结果混乱。

解决办法：用互斥锁（pthread_mutex_t）保护所有共享变量的读写操作。每次访问共享数据前加锁，操作完成后立即解锁，确保同一时间只有一个线程能修改共享数据。

2. 主线程可能提前退出，子线程没执行完 #

如果你的代码里没有用pthread_join等待所有子线程完成，主线程可能会在子线程还没跑完就直接退出，不同环境下主线程的退出时机不同，自然输出结果不一样。

解决办法：创建完所有线程后，必须调用pthread_join逐个等待子线程结束，确保所有统计逻辑都执行完毕后再输出最终结果。

3. 子串任务的分配逻辑不清晰 #

你定义了4个线程，但如果没有把string2的内容合理拆分给每个线程，很可能出现重复统计或者遗漏的情况，不同环境下线程处理的顺序不同，结果也会波动。

解决办法：给每个线程分配独立的处理区间（比如把string2按长度分成4块，最后一个线程处理剩余部分），用结构体传递每个线程的起始和结束位置，避免全局变量的依赖。

修正后的完整代码示例 #

我把你的代码补全并修复了上述问题，你可以参考：

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

#define NUM_THREADS 4
#define MAX 1024

// 共享变量，需互斥保护
char *s1, *s2;
int n1, n2;
int total_count = 0;
pthread_mutex_t count_mutex;

// 线程参数结构体：传递每个线程处理的区间
typedef struct {
    int start;
    int end;
} ThreadData;

char* substring(char *string, int position, int length) {
    char* sub = (char*)malloc(length + 1);
    if (!sub) {
        perror("malloc failed");
        pthread_exit(NULL);
    }
    strncpy(sub, string + position, length);
    sub[length] = '\0';
    return sub;
}

void *occurrence(void *arg) {
    ThreadData *data = (ThreadData*)arg;
    int local_count = 0;

    // 遍历当前线程负责的s2区间，统计匹配的子串
    for (int i = data->start; i <= data->end - n1 + 1; i++) {
        char* sub = substring(s2, i, n1);
        if (strcmp(sub, s1) == 0) {
            local_count++;
        }
        free(sub);
    }

    // 加锁更新全局计数，避免竞争
    pthread_mutex_lock(&count_mutex);
    total_count += local_count;
    pthread_mutex_unlock(&count_mutex);

    pthread_exit(NULL);
}

int readf(FILE *fp) {
    if ((fp = fopen("strings.txt", "r")) == NULL) {
        perror("can't open strings.txt");
        return 0;
    }

    s1 = (char*)malloc(MAX);
    s2 = (char*)malloc(MAX);
    if (!s1 || !s2) {
        perror("malloc failed");
        fclose(fp);
        return 0;
    }

    // 读取文件中的两个字符串（假设第一行s1，第二行s2）
    if (fgets(s1, MAX, fp) == NULL || fgets(s2, MAX, fp) == NULL) {
        perror("failed to read strings");
        free(s1);
        free(s2);
        fclose(fp);
        return 0;
    }

    // 去掉换行符（兼容Windows和Linux的换行格式）
    s1[strcspn(s1, "\n")] = '\0';
    s2[strcspn(s2, "\n")] = '\0';

    n1 = strlen(s1);
    n2 = strlen(s2);

    fclose(fp);
    return 1;
}

int main() {
    FILE *fp;
    if (!readf(fp)) {
        return 1;
    }

    // 初始化互斥锁
    if (pthread_mutex_init(&count_mutex, NULL) != 0) {
        perror("mutex init failed");
        free(s1);
        free(s2);
        return 1;
    }

    pthread_t threads[NUM_THREADS];
    ThreadData thread_data[NUM_THREADS];

    // 拆分任务给每个线程
    int chunk_size = n2 / NUM_THREADS;
    for (int i = 0; i < NUM_THREADS; i++) {
        thread_data[i].start = i * chunk_size;
        // 最后一个线程处理剩余的所有内容
        thread_data[i].end = (i == NUM_THREADS - 1) ? n2 : (i + 1) * chunk_size;
        // 确保区间有效（至少能容纳一个s1长度的子串）
        if (thread_data[i].end < n1) thread_data[i].end = n1;
        
        if (pthread_create(&threads[i], NULL, occurrence, &thread_data[i]) != 0) {
            perror("pthread_create failed");
            free(s1);
            free(s2);
            pthread_mutex_destroy(&count_mutex);
            return 1;
        }
    }

    // 等待所有线程完成统计
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Total occurrences: %d\n", total_count);

    // 清理资源
    pthread_mutex_destroy(&count_mutex);
    free(s1);
    free(s2);

    return 0;
}

其他需要排查的点 #

• 编译器优化差异：CodeBlocks和Linux下的GCC优化级别不同，未初始化的变量、越界访问等未定义行为在不同优化下表现不同。确保所有变量都正确初始化，避免数组越界。
• 文件读取的换行符差异：Windows文件用CRLF换行，Linux用LF，读取后字符串长度会不一样，代码里用strcspn去掉换行符可以解决这个问题。
• 线程栈大小：不同环境下线程栈默认大小不同，如果线程里有大的局部变量，可能导致栈溢出，尽量用malloc在堆上分配内存。

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