c语言多线程的三种实现方式

作者：袖梨 2026-09-08

在前端开发内容学习中，c语言多线程的三种实现方式是常见主题。很多人在阅读时会遇到概念分散、步骤不清和注意点难以归纳的问题。本文按照基础概念、操作流程和关键细节，对相关内容进行整理。

c语言实现多线程，关键在于先明确运行环境，再选择对应线程库。本文围绕常见开发场景，分别介绍pthread、C11标准线程和Windows API三种实现方式，并说明它们的适用条件、基本写法与选型要点。

先明确多线程实现的选择前提

c语言本身并没有内建线程语法，实际开发中的多线程能力通常来自操作系统接口或标准库扩展。所以，讨论实现方式时，不能只看语法是否相似，更要看目标平台、编译器支持和部署环境。

如果程序主要运行在Linux、macOS等类Unix系统上，pthread通常是最常见也最成熟的方案。它接口完整、资料多，适合服务端程序、工具程序和教学示例。

如果项目希望尽量采用标准化写法，并且编译器已经支持C11线程库，那么threads.h会更利于跨平台整理代码。若程序只面向Windows桌面或服务环境，直接使用Windows线程API往往更贴近系统能力。

第一种方式：使用pthread库

pthread是POSIX线程库，适合大多数类Unix环境。它的核心思路是定义线程入口函数，创建线程，等待线程结束，再在需要时配合互斥锁、条件变量等机制进行同步。

这种方式的优点是生态成熟、可控性强，缺点是接口偏底层，跨到Windows时不能直接复用。对Linux下的C语言多线程入门和实际工程，它通常是第一选择。

基本流程：定义线程函数，准备参数，调用pthread_create创建线程，最后用pthread_join回收线程。

pthread完整示例

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

void* worker(void* arg) {
    const char* name = (const char*)arg;
    printf("thread: %sn", name);
    return NULL;
}

int main(void) {
    pthread_t tid;
    const char* msg = "pthread";

    if (pthread_create(&tid, NULL, worker, (void*)msg) != 0) {
        perror("pthread_create");
        return 1;
    }

    pthread_join(tid, NULL);
    printf("main donen");
    return 0;
}

编译命令：cc -std=c11 demo.c -o demo -pthread

第二种方式：使用C11标准线程

C11引入了threads.h，目标是提供标准化线程接口。常见类型包括thrd_t、mtx_t，常见函数包括thrd_create、thrd_join和互斥锁相关接口，整体风格比pthread更统一。

它的优势在于代码层面更接近标准C，便于减少平台专有写法。限制在于并不是所有编译器和运行库都完整支持，所以在正式采用前，必须先确认工具链是否可用。最直接的判断方法，是先写一个只包含`#include <threads`.h`>`和`thrd_t`声明的最小测试文件，再用项目实际编译命令试编译；

如果头文件找不到、链接失败，或者运行时相关接口不可用，就说明当前工具链不适合直接采用这一方案。

适用场景：希望代码更标准化，且编译器明确支持C11线程库的项目。
判断步骤：先检查是否能包含threads.h，再编译并运行最小示例；任一步失败，就优先回退到类Unix下的pthread或Windows下的系统线程API。

C11线程完整示例

#include <stdio.h>
#include <threads.h>

int worker(void* arg) {
    const char* name = (const char*)arg;
    printf("thread: %sn", name);
    return 0;
}

int main(void) {
    thrd_t tid;
    const char* msg = "c11";

    if (thrd_create(&tid, worker, (void*)msg) != thrd_success) {
        puts("thrd_create failed");
        return 1;
    }

    thrd_join(tid, NULL);
    puts("main done");
    return 0;
}

编译命令：cc -std=c11 demo.c -o demo

第三种方式：使用Windows线程API

如果程序只运行在Windows环境，直接调用系统提供的线程接口会更直接。常见做法是使用CreateThread创建线程，再通过WaitForSingleObject等待线程结束，最后关闭线程句柄。

这种方式与Windows系统集成更紧密，适合明确锁定Windows平台的程序。缺点也很明显，就是平台耦合更强，后续迁移到Linux或macOS时需要重写线程相关代码。

典型场景：Windows本地工具、运维程序、只部署在Windows服务器上的内部应用。

Windows线程完整示例

#include <stdio.h>
#include <windows.h>

DWORD WINAPI worker(LPVOID arg) {
    const char* name = (const char*)arg;
    printf("thread: %sn", name);
    return 0;
}

int main(void) {
    const char* msg = "winapi";
    HANDLE hThread = CreateThread(NULL, 0, worker, (LPVOID)msg, 0, NULL);

    if (hThread == NULL) {
        puts("CreateThread failed");
        return 1;
    }

    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    puts("main done");
    return 0;
}

编译方式：如果使用MinGW或MinGW-w64，可直接执行 `gcc demo.c -o demo.exe`；如果使用Visual Studio开发者命令提示符，可执行 `cl demo.c`。在IDE中则要确保工程类型为Windows下的C项目，并链接默认系统库，`windows.h`可正常包含。

线程同步基础：只会创建线程还不够

多线程代码真正容易出问题的地方，通常不是线程能不能启动，而是多个线程同时读写同一份数据时会不会发生竞争。只要存在共享计数器、共享队列、日志缓冲区或全局状态，就需要明确同步方案。

下面用pthread给出一个最小互斥锁示例：两个线程共同累加同一个计数器，如果不加锁，结果可能不稳定；加锁后，每次修改共享数据都会被串行保护。这种思路在C11线程里对应mtx_t，在Windows线程API里则可以用CRITICAL_SECTION或互斥体实现。

最小原则：只要多个线程会修改同一份数据，就先考虑互斥锁，而不是假设“示例里运行几次都没出错”。

pthread互斥锁最小示例

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

static int counter = 0;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void* worker(void* arg) {
    int i;
    (void)arg;

    for (i = 0; i < 100000; ++i) {
        pthread_mutex_lock(&lock);
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main(void) {
    pthread_t t1, t2;

    pthread_create(&t1, NULL, worker, NULL);
    pthread_create(&t2, NULL, worker, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("counter = %dn", counter);
    pthread_mutex_destroy(&lock);
    return 0;
}