C多线程指针问题：数组半区局部最大值计算出现段错误

核心错误导致段错误 #

1. 返回局部变量的地址 #

线程函数max_locale里的max是栈上的局部变量，线程执行完毕后栈帧会被销毁，返回的地址变为无效野指针。主函数中解引用这个无效地址直接触发段错误。

2. 线程参数未正确初始化 #

主函数仅给thread2_args.index赋值，thread1_args.index完全未设置，默认是随机垃圾值，导致循环起始位置非法，引发数组越界。

3. 数组越界风险 #

循环中当i等于finalIndex-1时，a[i+1]会访问到数组的finalIndex位置，以n=10为例，finalIndex为10，超出数组a[0..9]的合法范围，触发越界。

修复后的代码 #

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

#define n 10

// 优化传参：传递数组指针+起始索引+半区长度，避免复制整个数组
struct args {
    int start_idx;
    int *arr;
    int len;
};

void *max_locale(void *parameters) {
    struct args *pp = (struct args *)parameters;
    // 动态分配内存存储结果，避免局部变量销毁问题
    int *max = malloc(sizeof(int));
    *max = pp->arr[pp->start_idx];
    
    // 计算半区的全局最大值（若需局部峰值可调整逻辑）
    for (int i = pp->start_idx; i < pp->start_idx + pp->len; i++) {
        if (pp->arr[i] > *max) {
            *max = pp->arr[i];
        }
    }
    return (void *)max;
}

int main() {
    srand(time(NULL));
    int array[n];
    pthread_t thread1, thread2;
    struct args thread1_args, thread2_args;
    
    printf("-beginning of program-\n");
    for (int i = 0; i < n; i++) {
        array[i] = rand() % 101;
        printf("%d  ", array[i]);
    }
    printf("\nFind MAX...\n");
    
    // 初始化线程参数：共享原数组，无需复制
    thread1_args.start_idx = 0;
    thread1_args.arr = array;
    thread1_args.len = n/2;
    
    thread2_args.start_idx = n/2;
    thread2_args.arr = array;
    thread2_args.len = n/2;
    
    int *thread1_returnValue; 
    int *thread2_returnValue;
    
    pthread_create(&thread1, NULL, max_locale, &thread1_args);
    pthread_create(&thread2, NULL, max_locale, &thread2_args);
    
    pthread_join(thread1, (void **)&thread1_returnValue);
    pthread_join(thread2, (void **)&thread2_returnValue);
    
    printf("Max 1:%d Max 2:%d\n", *thread1_returnValue, *thread2_returnValue);
    
    // 释放动态分配的内存，避免泄漏
    free(thread1_returnValue);
    free(thread2_returnValue);
    
    return 0;
}

关键优化点 #

• 传参优化：不再复制整个数组，而是传递原数组指针，大幅节省内存开销，尤其适合大数组场景。
• 返回值修复：用malloc动态分配内存存储结果，线程结束后内存不会被销毁，主函数可安全访问，使用后需手动释放避免泄漏。
• 参数初始化修复：正确设置两个线程的起始索引和半区长度，彻底避免数组越界。
• 逻辑可选调整：若需求是寻找半区内的局部峰值（元素比左右邻居都大），可替换循环逻辑：

  // 示例：寻找半区内的第一个局部峰值
  *max = pp->arr[pp->start_idx];
  for (int i = pp->start_idx; i < pp->start_idx + pp->len; i++) {
      if (i == pp->start_idx) {
          if (pp->arr[i] > pp->arr[i+1]) {
              *max = pp->arr[i];
              break;
          }
      } else if (i == pp->start_idx + pp->len - 1) {
          if (pp->arr[i] > pp->arr[i-1]) {
              *max = pp->arr[i];
              break;
          }
      } else if (pp->arr[i] > pp->arr[i-1] && pp->arr[i] > pp->arr[i+1]) {
          *max = pp->arr[i];
          break;
      }
  }
  

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