带互斥锁的链表插入线程出现段错误，求问题排查与解决方法

1. 全局指针head未初始化直接访问 #

head是全局node*类型，默认初始化为NULL，但main函数里直接执行head -> next = NULL，属于访问空指针的成员，直接触发段错误。

2. 线程函数中提前操作未分配的指针 #

线程函数list1里先执行pthread_mutex_lock(&new_node->lock)，但此时new_node是未初始化的野指针，访问它的lock成员属于非法内存访问，必然导致段错误。

3. malloc内存分配大小错误 #

malloc(sizeof(node*))只分配了一个指针的大小（通常4/8字节），但需要分配整个node结构体的内存，应改为malloc(sizeof(node))，否则后续访问结构体成员会出现内存越界。

4. 互斥锁未初始化就使用 #

pthread_mutex_t类型的锁必须通过pthread_mutex_init初始化后才能使用，代码中不管是head还是新节点的锁都没有初始化，直接调用lock/unlock属于未定义行为。

5. 链表插入逻辑错误 #

• 判断head -> next == NULL时，head可能是NULL，此时访问head->next又会触发空指针错误；
• 插入第一个节点时，没有处理互斥锁的释放逻辑，且后续执行pthread_mutex_destroy(&prev -> lock)时，prev未被赋值，属于野指针访问；
• 互斥锁的加锁/解锁逻辑混乱，插入过程中没有正确保护共享资源head，且锁的释放时机错误。

6. 链表遍历与内存释放逻辑错误 #

• main函数中curr = head -> next，如果head是第一个节点，head->next为NULL，循环根本不会执行，无法打印数据；
• 循环条件curr -> next != NULL会漏掉最后一个节点的打印；
• free(curr)的时机错误：先将curr指向curr->next再free，导致跳过了当前节点，还可能在curr为NULL时执行curr->next触发错误。

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

typedef struct NODE{
    int data;
    struct NODE* next;
    pthread_mutex_t lock;
}node;

node* head = NULL;

// 初始化节点的互斥锁
void init_node(node* n) {
    pthread_mutex_init(&n->lock, NULL);
    n->next = NULL;
}

void* list1(void* args){
    node *new_node = malloc(sizeof(node));
    if (!new_node) {
        perror("malloc failed");
        pthread_exit(NULL);
    }
    init_node(new_node);
    new_node->data = 10;

    // 用全局锁保护head的访问，也可以用头节点锁实现更细粒度控制
    static pthread_mutex_t head_lock = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_lock(&head_lock);

    if (head == NULL) {
        head = new_node;
    } else {
        node* prev = head;
        pthread_mutex_lock(&prev->lock);
        // 遍历到链表尾部，同时加锁避免其他线程修改
        while (prev->next != NULL) {
            node* temp = prev->next;
            pthread_mutex_lock(&temp->lock);
            pthread_mutex_unlock(&prev->lock);
            prev = temp;
        }
        prev->next = new_node;
        pthread_mutex_unlock(&prev->lock);
    }
    pthread_mutex_unlock(&head_lock);

    return NULL;
}

int main(void){
    void *thread_result;
    int status;
    pthread_t thread_id[1];

    status = pthread_create(&thread_id[0], NULL, list1, NULL);
    if (status != 0) {
        perror("pthread_create failed");
        return 1;
    }
    pthread_join(thread_id[0], &thread_result);

    // 遍历并释放链表
    node* curr = head;
    while (curr != NULL) {
        printf("%d\n", curr->data);
        node* next_node = curr->next;
        pthread_mutex_destroy(&curr->lock);
        free(curr);
        curr = next_node;
    }

    return 0;
}

• 使用GDB调试：编译代码时添加-g参数生成调试信息，然后用gdb ./your_program启动调试，运行程序触发错误后，输入bt查看调用栈，能直接定位到触发段错误的代码行。
• 使用Valgrind工具：用valgrind --leak-check=full ./your_program运行程序，它会检测出空指针访问、内存越界、内存泄漏等问题，给出详细的错误位置和原因。
• 逐步注释代码：如果没有调试工具，可以逐步注释掉部分代码，缩小错误范围，比如先注释线程相关逻辑，先测试单线程下的链表操作是否正常，再逐步加入线程和锁的逻辑。

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