多线程可以让C语言程序并发处理多个任务，提高计算资源利用率和交互响应速度。本文以POSIX线程为基础，说明线程创建、参数传递、同步控制、编译运行和资源回收的实现方法，并给出可直接编译运行的完整示例。

多线程实现基础

在支持POSIX线程的系统中，C语言通常通过pthread线程库实现多线程。进程负责提供独立的资源空间，线程则共享进程中的代码、全局数据和已打开文件，同时各自保留调用栈与寄存器状态。多线程适合处理相互独立的计算、网络连接和后台任务，但共享内存也意味着程序必须主动控制并发访问。pthread方案主要适用于Linux、macOS等POSIX环境；如果在Windows上开发，通常需要使用Win32线程API或其他跨平台线程库，接口形式与pthread并不相同。编译时需要启用pthread选项，使编译器和链接器正确处理线程相关接口。

• Linux或macOS可直接使用gcc demo.c -o demo -pthread进行编译。
• 运行命令通常为./demo，便于快速验证线程创建、同步和回收流程。
• 若目标平台是Windows，应单独评估Win32线程API或跨平台封装库，不能直接假设pthread接口可用。

创建线程与传递参数

程序可调用pthread_create创建线程，并提供线程标识、属性、入口函数和入口参数。入口函数接收一个通用指针，因此可以传入结构体地址，将线程编号、循环次数和共享资源集中封装。传入的数据在线程结束前必须保持有效，不能把即将离开作用域的局部变量地址交给仍在运行的线程。若每个线程需要独立参数，应分别准备存储空间，避免多个线程读取同一个循环变量而得到错误结果。下面给出一个可直接编译运行的POSIX线程完整示例，演示头文件、参数结构体、线程入口函数、创建线程、互斥锁保护共享计数器、pthread_join等待回收，以及创建失败后的清理路径：

#include 
#include 
#include 
#include 

typedef struct {
    int thread_index;
    int loops;
    int *shared_counter;
    pthread_mutex_t *counter_mutex;
} ThreadArg;

static void cleanup_threads(pthread_t *threads, int created_count) {
    for (int i = 0; i < created_count; ++i) {
        pthread_join(threads[i], NULL);
    }
}

static void *worker(void *arg) {
    ThreadArg *data = (ThreadArg *)arg;

    for (int i = 0; i < data->loops; ++i) {
        int rc = pthread_mutex_lock(data->counter_mutex);
        if (rc != 0) {
            fprintf(stderr, "pthread_mutex_lock failed: %sn", strerror(rc));
            return NULL;
        }

        (*data->shared_counter)++;

        rc = pthread_mutex_unlock(data->counter_mutex);
        if (rc != 0) {
            fprintf(stderr, "pthread_mutex_unlock failed: %sn", strerror(rc));
            return NULL;
        }
    }

    printf("thread %d finished, loops=%dn", data->thread_index, data->loops);
    return NULL;
}

int main(void) {
    enum { THREAD_COUNT = 4, LOOPS_PER_THREAD = 100000 };
    pthread_t threads[THREAD_COUNT];
    ThreadArg *args = calloc(THREAD_COUNT, sizeof(ThreadArg));
    pthread_mutex_t counter_mutex;
    int shared_counter = 0;
    int created_count = 0;
    int rc = 0;

    if (args == NULL) {
        fprintf(stderr, "calloc failedn");
        return 1;
    }

    rc = pthread_mutex_init(&counter_mutex, NULL);
    if (rc != 0) {
        fprintf(stderr, "pthread_mutex_init failed: %sn", strerror(rc));
        free(args);
        return 1;
    }

    for (int i = 0; i < THREAD_COUNT; ++i) {
        args[i].thread_index = i;
        args[i].loops = LOOPS_PER_THREAD;
        args[i].shared_counter = &shared_counter;
        args[i].counter_mutex = &counter_mutex;

        rc = pthread_create(&threads[i], NULL, worker, &args[i]);
        if (rc != 0) {
            fprintf(stderr, "pthread_create failed at thread %d: %sn", i, strerror(rc));
            cleanup_threads(threads, created_count);
            pthread_mutex_destroy(&counter_mutex);
            free(args);
            return 1;
        }

        created_count++;
    }

    for (int i = 0; i < THREAD_COUNT; ++i) {
        rc = pthread_join(threads[i], NULL);
        if (rc != 0) {
            fprintf(stderr, "pthread_join failed at thread %d: %sn", i, strerror(rc));
            pthread_mutex_destroy(&counter_mutex);
            free(args);
            return 1;
        }
    }

    printf("final counter = %d, expected = %dn",
           shared_counter, THREAD_COUNT * LOOPS_PER_THREAD);

    rc = pthread_mutex_destroy(&counter_mutex);
    if (rc != 0) {
        fprintf(stderr, "pthread_mutex_destroy failed: %sn", strerror(rc));
        free(args);
        return 1;
    }

    free(args);
    return 0;
}

这段代码在正常运行时会输出每个线程的完成信息，最后打印类似final counter = 400000, expected = 400000的结果，可用于确认互斥锁已经正确保护共享计数器。

• 检查pthread_create的返回值，创建失败时及时释放已经申请的资源，并等待已成功创建的线程结束。
• 在线程入口函数中把通用指针转换为约定的数据类型，避免错误解释参数内存。
• 确保参数对象的生命周期覆盖线程的实际运行时间，本示例通过calloc分配参数数组并在全部join后统一释放。

同步共享数据

多个线程同时读写共享变量时，读取、计算和写回可能交错执行，从而产生数据竞争。互斥锁可保证同一时刻只有一个线程进入临界区，适合保护计数器、链表和共享状态。上面的shared_counter示例已经展示了最常见的互斥锁流程：先调用pthread_mutex_lock进入临界区，完成共享数据更新后再调用pthread_mutex_unlock释放锁。条件变量用于等待某个状态成立，常见于生产者与消费者模型；等待时必须把条件判断写在循环里，而不是只判断一次，否则可能受到虚假唤醒或竞争时序影响。下面是一个最小完整的条件变量示例：

#include 
#include 
#include 

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int ready = 0;

static void *consumer(void *arg) {
    (void)arg;
    int rc = pthread_mutex_lock(&mutex);
    if (rc != 0) {
        fprintf(stderr, "lock failed: %sn", strerror(rc));
        return NULL;
    }

    while (!ready) {
        rc = pthread_cond_wait(&cond, &mutex);
        if (rc != 0) {
            fprintf(stderr, "pthread_cond_wait failed: %sn", strerror(rc));
            pthread_mutex_unlock(&mutex);
            return NULL;
        }
    }

    printf("consumer observed ready = %dn", ready);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

static void *producer(void *arg) {
    (void)arg;
    int rc = pthread_mutex_lock(&mutex);
    if (rc != 0) {
        fprintf(stderr, "lock failed: %sn", strerror(rc));
        return NULL;
    }

    ready = 1;
    rc = pthread_cond_signal(&cond);
    if (rc != 0) {
        fprintf(stderr, "pthread_cond_signal failed: %sn", strerror(rc));
    }

    pthread_mutex_unlock(&mutex);
    return NULL;
}

这个流程的关键点是：消费者先持锁检查ready，不满足条件就通过pthread_cond_wait在释放锁的同时进入等待；被唤醒后会重新持有锁，再次检查ready是否已经满足。锁定范围应尽量覆盖完整的一致性操作，同时避免在持锁期间执行耗时输入输出。若多个函数使用多把锁，还应统一加锁顺序，防止线程相互等待形成死锁。

• 使用pthread_mutex_init初始化互斥锁，并在不再使用时销毁。
• 访问受保护的数据前加锁，完成访问后及时解锁，保证共享状态的读改写是一个完整临界区。
• 等待条件时配合while循环检查状态，再调用pthread_cond_wait，避免错误处理虚假唤醒。

等待线程与释放资源

主线程如果需要获取工作线程的执行结果，可调用pthread_join等待指定线程结束。线程入口函数既可以返回结果指针，也可以通过共享结构写入结果，但相关内存必须在读取完成前保持有效。若线程无需被等待，可将其设置为分离状态，由系统在线程结束后自动回收资源。一个线程不能同时采用等待回收和分离回收两种方式，否则容易出现无效调用或资源管理混乱。实际编写代码时，应为每一步定义清晰的清理顺序：先回收已经成功创建的线程，再销毁互斥锁、条件变量等同步对象，最后释放参数结构和其他动态内存。上面的完整示例中，pthread_create一旦在中途失败，就会先join此前已成功创建的线程，再销毁mutex并释放args，这样可以避免遗留运行中的线程继续访问即将释放的资源。

• pthread_join适合可等待线程，分离线程适合无需回收结果的后台任务。
• 发生部分创建成功、后续创建失败时，要按先join已创建线程、再销毁同步对象、最后释放内存的顺序清理。
• 销毁pthread_mutex_t或pthread_cond_t之前，必须确认没有线程仍在使用它们。

常见问题与调试方法

多线程程序的错误往往受运行时序影响，可能只在高负载或特定机器上出现。调试时应先缩小共享状态范围，再检查每条访问路径是否使用同一同步规则。日志中可记录线程编号、任务阶段和关键状态，但输出本身也可能改变执行时序。压力测试应重复运行并覆盖创建失败、提前退出和任务取消等异常路径，同时检查锁、动态内存和线程资源是否都能正确释放。对于pthread接口，还要注意它们大多通过非零返回值报告错误，而不是简单依赖errno；因此应直接检查返回码，并结合strerror输出可读错误信息。若示例能够稳定打印出预期计数值，再逐步扩展到真实业务逻辑，通常更容易定位问题来源。

• 避免在未同步的情况下读写同一个可变对象。
• 不要在线程仍使用参数时提前释放对应内存。
• 检查所有pthread_create、pthread_join、pthread_mutex_lock、pthread_mutex_unlock、pthread_cond_wait等调用的返回值。
• 优先使用明确的所有权规则管理共享资源，并为异常路径预留清理代码。

实现C语言多线程的关键不只是创建多个执行单元，还要明确数据归属、同步边界和回收方式。先用可编译运行的最小示例验证线程创建、互斥锁、条件变量和资源释放流程，再根据实际测量缩短临界区和调整线程数量，才能获得稳定且有效的并发性能。

《夸克》非常好用的免费AI浏览器

下载APP查看