含结构体的pthread多线程程序出现Segmentation fault问题求助

核心错误点 #

• 线程参数传递错误
  调用pthread_create时，你传递了&Firststruct（这是struct Params**二级指针），但线程函数double_number中将其强制转换为struct Params*一级指针，导致内存访问越界，触发段错误。正确做法是直接传递Firststruct（本身就是一级指针）。

• 线程函数无返回值
  POSIX线程函数必须返回void*类型值，当前double_number函数没有return语句，会引发未定义行为。

• 多线程场景的潜在问题
  若后续启用多线程，所有线程会共享同一个Params结构体：

  • 同时修改start会引发数据竞争，计算结果混乱；
  • 每个线程都会malloc覆盖result指针，造成内存泄漏。需为每个线程分配独立的结构体实例。

修正后的代码 #

//The program will do: 1 * 2 = 2, 2 * 2 = 4, 4 * 2 = 8 
//The results will be stored in a the struct result which is a pointer.

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

struct Params
{
    int start;
    int iteration;
    int *result;
};

void *double_number(void *vFirststruct)
{
    struct Params *Firststruct = (struct Params *)vFirststruct;
    int iter = 0;
    Firststruct->result = (int *)malloc(sizeof(int) * Firststruct->iteration);
    for (iter = 0; iter < Firststruct->iteration; iter++)
    {
        Firststruct->start = Firststruct->start * 2;
        Firststruct->result[iter] = Firststruct->start;
    }
    return NULL; // 补充线程函数返回值
}

void double_number_Single_Thread(struct Params *Firststruct)
{
    int iter = 0;
    Firststruct->result = (int *)malloc(sizeof(int) * Firststruct->iteration);
    for (iter = 0; iter < Firststruct->iteration; iter++)
    {
        printf("%d\n", Firststruct->start);
        Firststruct->start = Firststruct->start * 2;
        Firststruct->result[iter] = Firststruct->start;
    }
}

int main(int argc, char *argv[])
{

    struct Params *Firststruct = (struct Params *)malloc(sizeof(struct Params));
    Firststruct->start = atoi(argv[1]);
    Firststruct->iteration = atoi(argv[2]);
    int threads = atoi(argv[3]);

    //For Single Thread
    // double_number_Single_Thread(Firststruct); // <-- testing on single thread

    // for (int i = 0; i < Firststruct->iteration; i++)
    // {
    //     printf("%d %d\n", i, Firststruct->result[i]);
    // }

    //End for Single Thread

    //Start of Single thread using pthread-Thread
    pthread_t *t = (pthread_t *)malloc(threads * sizeof(pthread_t));

    // 修正：传递Firststruct而非&Firststruct
    pthread_create(&t[0], NULL, &double_number, (void *)Firststruct);
    pthread_join(t[0], NULL);

    // 可以添加结果打印验证
    for (int i = 0; i < Firststruct->iteration; i++)
    {
        printf("Result[%d]: %d\n", i, Firststruct->result[i]);
    }

    // 释放malloc的内存
    free(Firststruct->result);
    free(t);
    free(Firststruct);
    return 0;
}

多线程场景的优化建议 #

如果要真正实现多线程并行计算（比如拆分迭代任务到不同线程），需要为每个线程创建独立的Params结构体，避免共享数据竞争：

// 示例：拆分迭代任务到多个线程
void *double_number_part(void *vFirststruct)
{
    struct Params *p = (struct Params *)vFirststruct;
    int current_val = p->start;
    for (int i = 0; i < p->iteration; i++)
    {
        current_val *= 2;
        p->result[i] = current_val;
    }
    return NULL;
}

// 在main中创建多线程
int main(int argc, char *argv[])
{
    int start = atoi(argv[1]);
    int total_iter = atoi(argv[2]);
    int threads = atoi(argv[3]);
    
    int iter_per_thread = total_iter / threads;
    pthread_t *t = malloc(threads * sizeof(pthread_t));
    struct Params *params_arr = malloc(threads * sizeof(struct Params));
    int *final_result = malloc(total_iter * sizeof(int));

    for (int i = 0; i < threads; i++)
    {
        params_arr[i].start = start;
        // 前i个线程已经完成的迭代次数，计算当前线程的初始值
        for (int j = 0; j < i * iter_per_thread; j++)
        {
            params_arr[i].start *= 2;
        }
        params_arr[i].iteration = iter_per_thread;
        params_arr[i].result = final_result + i * iter_per_thread;
        pthread_create(&t[i], NULL, double_number_part, &params_arr[i]);
    }

    for (int i = 0; i < threads; i++)
    {
        pthread_join(t[i], NULL);
    }

    // 打印最终结果
    for (int i = 0; i < total_iter; i++)
    {
        printf("Result[%d]: %d\n", i, final_result[i]);
    }

    // 释放资源
    free(final_result);
    free(params_arr);
    free(t);
    return 0;
}

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