Linux 多线程编程详解:线程基础、同步机制、生产者消费者、线程池与面试重点

本文以 Linux 下 POSIX pthread 为主线,系统整理多线程开发的基础知识、线程同步机制、生产者消费者模型、线程池设计以及线程退出和资源回收。

对于嵌入式 Linux C/C++ 应用开发来说,多线程广泛应用于视频采集、图像处理、网络通信、设备控制和任务调度等场景。


一、线程基础知识

1.1 什么是线程?

线程(Thread)是操作系统进行 CPU 调度和执行的基本单位。

一个进程可以包含一个或多个线程,多个线程可以并发执行。

例如,一个视频监控程序可以创建多个线程:

  • 采集线程:从摄像头获取视频帧。

  • 解码线程:负责视频数据解码。

  • 图像处理线程:负责图像分析和处理。

  • 显示线程:负责显示图像。

  • 网络线程:负责向服务器发送视频数据。

这些线程属于同一个进程,可以共享进程中的资源。

1.2 线程与进程的区别

进程是资源分配的基本单位,线程是 CPU 调度和执行的基本单位。

一个进程可以包含多个线程,线程共享所属进程的资源。

对比项进程线程
定义资源分配的基本单位CPU 调度和执行的基本单位
地址空间每个进程有独立的虚拟地址空间同一进程内的线程共享地址空间
全局变量不同进程之间默认不共享同一进程内的线程共享
堆内存不同进程之间默认不共享同一进程内的线程共享
栈每个进程有自己的线程栈每个线程有独立的栈
寄存器进程执行上下文每个线程有独立的执行上下文
通信方式管道、共享内存、消息队列等 IPC共享内存、互斥锁、条件变量等
创建和切换通常开销较大通常开销较小

线程共享哪些资源?

同一个进程中的线程共享:

  • 代码段。

  • 全局变量和静态变量。

  • 堆内存。

  • 文件描述符。

  • 当前工作目录。

  • 进程级别的信号处置等资源。

线程独有的资源有哪些?

每个线程拥有独立的:

  • 线程 ID。

  • 栈空间。

  • 寄存器状态。

  • 程序计数器。

  • 线程局部存储(TLS)。

  • 信号屏蔽字。

  • 线程调度相关属性。

注意:虽然多个线程共享堆内存,但是每个线程的局部变量通常存储在线程自己的栈上。

面试重点:线程和进程的主要区别是什么?

回答思路:

进程是资源分配的基本单位,线程是 CPU 调度和执行的基本单位。同一个进程中的多个线程共享地址空间、全局变量、堆内存和文件描述符等资源,但每个线程有独立的栈、寄存器状态和程序计数器。

线程之间共享数据比较方便,但是也因此容易产生数据竞争,所以需要使用互斥锁、条件变量等同步机制。


1.3 POSIX 线程 API

Linux 下常用的 POSIX 线程接口包括:

  • pthread_create():创建线程。

  • pthread_join():等待线程退出。

  • pthread_detach():将线程设置为分离状态。

  • pthread_exit():退出当前线程。

  • pthread_cancel():向线程发送取消请求。

  • pthread_self():获取当前线程 ID。

  • pthread_equal():比较两个线程 ID。

使用 pthread 接口时,需要包含:

#include <pthread.h>

编译时通常需要添加:

-pthread

-pthread 不只是链接 pthread 库,还会让编译器和链接器采用相应的线程支持选项。

1.4 创建线程 pthread_create()

函数原型:

int pthread_create(
    pthread_t* thread,
    const pthread_attr_t* attr,
    void* (*start_routine)(void*),
    void* arg
);

参数说明:

参数作用
thread保存创建成功后的线程 ID
attr线程属性,传 NULL 表示使用默认属性
start_routine线程执行函数
arg传递给线程函数的参数

返回值:

  • 返回 0:创建成功。

  • 返回非 0:创建失败,返回值本身就是错误码。

注意:pthread 函数通常直接返回错误码,不是通过 errno 获取错误原因。

示例

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

void* thread_func(void* arg)
{
    int value = *(int*)arg;

    printf("子线程执行,参数:%d\n", value);

    return NULL;
}

int main()
{
    pthread_t tid;

    int value = 100;

    int ret = pthread_create(
        &tid,
        NULL,
        thread_func,
        &value
    );

    if (ret != 0)
    {
        printf("pthread_create failed: %d\n", ret);
        return -1;
    }

    pthread_join(tid, NULL);

    return 0;
}

这里需要注意一个问题:

传递给线程函数的参数必须保证在线程使用期间仍然有效。

例如,如果传递的是主线程的局部变量地址,那么主线程不能在线程读取之前就离开该变量的作用域。

对于循环创建线程的场景,也不要简单地把循环变量的地址传给所有线程,否则多个线程可能读取到同一个变量地址所对应的变化后的值。

1.5 等待线程 pthread_join()

函数原型:

int pthread_join(pthread_t thread, void** retval);

作用:

等待指定线程退出,并回收 joinable 线程相关资源。

示例:

pthread_t tid;

pthread_create(&tid, NULL, thread_func, NULL);

pthread_join(tid, NULL);

pthread_join() 是阻塞函数。

调用它的线程会等待目标线程结束。

第二个参数用于接收线程的退出返回值:

void* result = NULL;

pthread_join(tid, &result);

如果线程通过 return 或 pthread_exit() 返回了一个指针,可以通过这个参数接收。

需要注意,返回的指针必须指向仍然有效的对象,不能返回已经失效的局部变量地址。

1.6 分离线程 pthread_detach()

线程默认是 joinable 状态。

如果一个线程已经确定不需要其他线程等待它,也不需要获取它的退出返回值,可以将其设置为 detached 状态。

pthread_detach(tid);

两种线程状态的区别:

对比项JoinableDetached
是否需要 join需要回收时应调用不允许再 join
线程退出后资源等待 join 回收自动释放线程相关资源
是否获取退出返回值可以通过 join 获取不能通过 join 获取

注意:

不能对同一个线程既执行有效的 pthread_join() 回收,又将它当作 detached 线程管理。

如果线程创建时就知道它不需要被 join,也可以通过线程属性设置 detached 状态。

1.7 pthread_exit() 和 return 的区别

在线程执行函数中:

return NULL;

表示当前线程函数正常返回,线程退出。

也可以使用:

pthread_exit(NULL);

主动结束当前线程。

两者都可以结束当前线程。

需要注意:

如果在主线程中调用 pthread_exit(),只会结束主线程,不会直接结束进程;其他线程仍然可以继续执行。

而主线程从 main() 返回或者调用 exit(),会导致整个进程结束。

1.8 线程取消 pthread_cancel()

pthread_cancel(tid);

该接口用于向指定线程发送取消请求。

默认情况下,pthread 使用延迟取消机制。

也就是说,发送取消请求后,目标线程通常会在执行到取消点时响应,而不是立即退出。

例如:

pthread_testcancel();

可以显式设置取消点。

线程取消涉及清理函数、锁释放和资源管理等问题。

如果线程在持有互斥锁时被取消,却没有正确释放锁,就可能导致其他线程永久阻塞。

因此,实际项目中更推荐使用停止标志、条件变量通知和 pthread_join() 实现协作式退出,而不是依赖 pthread_cancel() 强制停止业务线程。


二、线程同步机制

2.1 为什么需要线程同步?

同一个进程中的多个线程共享地址空间,因此可以访问同一份全局变量和堆内存。

但是,多个线程同时访问共享数据时,可能出现数据竞争。

例如:

int count = 0;

void* thread_func(void* arg)
{
    for (int i = 0; i < 100000; ++i)
    {
        count++;
    }

    return NULL;
}

创建两个线程执行后,理论上希望得到:

count = 200000

但是结果可能小于 200000。

因为:

count++;

不是原子操作,通常可以理解为:

  1. 读取 count。

  2. 执行加 1。

  3. 写回 count。

两个线程可能读取到相同的旧值,最终覆盖彼此的修改。

因此,需要通过线程同步机制保护共享资源。

常见同步机制:

  1. 互斥锁 Mutex。

  2. 条件变量 Condition Variable。

  3. 读写锁 Read-Write Lock。

  4. 信号量 Semaphore。

2.2 互斥锁 Mutex

2.2.1 互斥锁的作用

互斥锁主要用于保护共享资源,保证同一时刻只有一个线程进入受保护的临界区。

临界区是访问共享资源、需要保证互斥的一段代码。

2.2.2 常用 API

初始化:

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, NULL);

静态初始化:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

加锁:

pthread_mutex_lock(&mutex);

解锁:

pthread_mutex_unlock(&mutex);

销毁:

pthread_mutex_destroy(&mutex);

尝试加锁:

pthread_mutex_trylock(&mutex);

如果锁已经被其他线程持有,trylock() 不会一直阻塞,通常返回 EBUSY。

限时加锁:

pthread_mutex_timedlock(&mutex, &timeout);

该函数使用绝对时间期限。超时后返回 ETIMEDOUT。

2.2.3 使用示例

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

int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_func(void* arg)
{
    for (int i = 0; i < 100000; ++i)
    {
        pthread_mutex_lock(&mutex);

        count++;

        pthread_mutex_unlock(&mutex);
    }

    return NULL;
}

int main()
{
    pthread_t t1, t2;

    pthread_create(&t1, NULL, thread_func, NULL);
    pthread_create(&t2, NULL, thread_func, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("count = %d\n", count);

    pthread_mutex_destroy(&mutex);

    return 0;
}

2.2.4 使用注意事项

第一,临界区尽量短。

不要在持锁期间执行耗时的图像处理、网络通信、文件读写等操作。

第二,必须保证加锁和解锁配对。

某条执行路径获取锁之后没有释放,就可能导致其他线程永久等待。

第三,不要重复获取普通互斥锁。

同一线程重复锁定一把普通互斥锁,可能导致自身死锁。

第四,不要在锁仍然被使用时销毁互斥锁。

必须确保所有相关线程都已经不再使用该锁。


2.3 条件变量 Condition Variable

2.3.1 为什么有了互斥锁,还需要条件变量?

互斥锁解决的是多个线程不能同时访问临界区的问题。

但它不能很好地解决线程等待某个条件成立的问题。

例如生产者消费者模型:

  • 生产者向队列添加任务。

  • 消费者从队列取出任务。

  • 队列为空时,消费者应该等待。

  • 队列有任务时,消费者才继续执行。

如果消费者一直循环检查队列是否为空,就会产生忙等待:

while (queue.empty())
{
    // 不断检查
}

这种方式会持续占用 CPU。

条件变量可以让线程在条件不满足时进入等待状态,等到其他线程通知后再继续执行。

2.3.2 常用 API

初始化:

pthread_cond_t cond;

pthread_cond_init(&cond, NULL);

静态初始化:

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

等待:

pthread_cond_wait(&cond, &mutex);

唤醒一个线程:

pthread_cond_signal(&cond);

唤醒所有线程:

pthread_cond_broadcast(&cond);

销毁:

pthread_cond_destroy(&cond);

2.3.3 pthread_cond_wait() 的执行过程

这是条件变量最重要的接口。

调用前,当前线程必须持有 mutex。

调用过程:

  1. 原子地释放 mutex,并进入条件变量等待。

  2. 被唤醒后,重新获取 mutex。

  3. 成功获取 mutex 后,函数才返回。

为什么要这样设计?

为了避免检查条件和进入等待之间出现通知丢失。

调用后,当前线程必须释放 mutex。

正确使用方式是:在持有同一把互斥锁的情况下检查共享条件,并通过 pthread_cond_wait() 原子地释放锁和等待。

2.3.4 为什么必须使用 while,而不是 if?

错误写法:

pthread_mutex_lock(&mutex);

if (queue.empty())
{
    pthread_cond_wait(&cond, &mutex);
}

Task task = queue.front();
queue.pop();

pthread_mutex_unlock(&mutex);

正确写法:

pthread_mutex_lock(&mutex);

while (queue.empty())
{
    pthread_cond_wait(&cond, &mutex);
}

Task task = queue.front();
queue.pop();

pthread_mutex_unlock(&mutex);

原因有两个:

原因一:虚假唤醒。

条件变量可能出现虚假唤醒。线程从等待函数返回,并不代表条件一定成立。

原因二:多个消费者竞争同一个任务。

假设队列中只有一个任务,两个消费者都在等待。

生产者添加一个任务并发送通知后,其中一个消费者先获取锁,取走了任务。

另一个消费者之后获取锁时,队列可能已经为空。

如果使用 if,它不会再次检查队列。

如果使用 while,它会重新检查条件,发现队列为空后继续等待。

所以必须记住:

条件变量负责通知,真正决定线程能否继续执行的是共享状态。

2.3.5 signal 和 broadcast 的区别

pthread_cond_signal():

唤醒一个等待该条件变量的线程。

pthread_cond_broadcast():

唤醒所有等待该条件变量的线程。

例如:

  • 生产者添加一个任务,通常使用 signal 通知一个消费者。

  • 线程池关闭时,需要唤醒所有等待线程,使用 broadcast。

需要注意,唤醒不代表线程马上运行,也不代表条件一定成立。被唤醒的线程必须重新获取互斥锁并检查条件。


2.4 读写锁 Read-Write Lock

2.4.1 为什么需要读写锁?

互斥锁有一个特点:

无论线程是读取数据还是修改数据,都必须独占锁。

但是实际开发中,可能出现:

  • 多个线程频繁读取共享数据。

  • 只有少数线程偶尔修改数据。

例如视频监控程序中有一份摄像头配置表:

多个工作线程读取配置,管理线程偶尔修改配置。

如果使用互斥锁,多个读取线程也必须依次访问。

读写锁就是为读多写少的场景设计的。

2.4.2 读写锁的特点

读写锁有两种模式。

读锁:

  • 多个线程可以同时持有读锁。

  • 读锁与读锁之间不互斥。

  • 有线程持有写锁时,其他线程不能获取读锁。

写锁:

  • 同一时刻只能有一个线程持有写锁。

  • 写锁与读锁互斥。

  • 写锁与写锁互斥。

锁的组合是否允许同时持有
读锁 + 读锁允许
读锁 + 写锁不允许
写锁 + 写锁不允许

2.4.3 常用 API

初始化:

pthread_rwlock_t rwlock;

pthread_rwlock_init(&rwlock, NULL);

获取读锁:

pthread_rwlock_rdlock(&rwlock);

获取写锁:

pthread_rwlock_wrlock(&rwlock);

释放锁:

pthread_rwlock_unlock(&rwlock);

销毁:

pthread_rwlock_destroy(&rwlock);

2.4.4 使用示例

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

int camera_config = 100;

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

// 读取配置
void* reader(void* arg)
{
    pthread_rwlock_rdlock(&rwlock);

    printf("读取配置:%d\n", camera_config);

    pthread_rwlock_unlock(&rwlock);

    return NULL;
}

// 修改配置
void* writer(void* arg)
{
    pthread_rwlock_wrlock(&rwlock);

    camera_config = 200;

    printf("修改配置:%d\n", camera_config);

    pthread_rwlock_unlock(&rwlock);

    return NULL;
}

多个 reader 可以同时读取配置。

writer 获取写锁时,其他读者和写者都必须等待。

2.4.5 读写锁适用场景

适合:

  • 配置表读取频繁、修改较少。

  • 共享缓存读取多、更新少。

  • 多线程需要同时读取同一份状态数据。

不适合:

  • 写操作非常频繁。

  • 临界区特别短,读写锁的管理开销可能得不偿失。

  • 对读写公平性有严格要求,但没有确认实现的调度策略。

注意:读写锁的读写调度策略依赖实现和属性设置,不能简单认为写线程一定不会饥饿。


2.5 信号量 Semaphore

2.5.1 信号量的作用

信号量主要用于控制多个线程对有限数量资源的访问。

例如程序中只有 5 个可用的硬件处理资源,同一时刻最多允许 5 个线程使用。

这时可以使用计数信号量。

信号量内部维护一个计数值:

  • sem_wait():获取资源,计数值减 1。

  • sem_post():释放资源,计数值加 1。

  • 资源数量不足时,线程阻塞等待。

2.5.2 常用 API

初始化:

#include <semaphore.h>

sem_t sem;

sem_init(&sem, 0, 5);

参数:

sem_init(&sem, pshared, value);
  • pshared = 0:同一进程内的线程共享。

  • value = 5:初始计数值为 5。

等待:

sem_wait(&sem);

释放:

sem_post(&sem);

销毁:

sem_destroy(&sem);

sem_wait() 可能被信号中断,返回 -1 且 errno == EINTR,实际代码需要根据情况重试。

2.5.3 使用示例

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

sem_t sem;

void* worker(void* arg)
{
    sem_wait(&sem);

    printf("线程获取资源\n");

    sleep(2);

    printf("线程释放资源\n");

    sem_post(&sem);

    return NULL;
}

int main()
{
    pthread_t threads[10];

    // 最多允许 3 个线程同时使用资源
    sem_init(&sem, 0, 3);

    for (int i = 0; i < 10; ++i)
    {
        pthread_create(&threads[i], NULL, worker, NULL);
    }

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

    sem_destroy(&sem);

    return 0;
}

虽然创建了 10 个线程,但同一时刻最多只有 3 个线程能够获取资源。

2.5.4 信号量和互斥锁的区别

对比项互斥锁 Mutex信号量 Semaphore
主要用途保护共享资源控制资源数量和同步
内部状态锁定或未锁定计数值
并发访问数量通常一个可以多个
所有权有所有权语义没有互斥锁那样的所有权约束
典型场景保护共享变量、队列限制并发访问硬件资源

二值信号量的值虽然只有 0 和 1,但它并不完全等同于互斥锁。

互斥锁强调所有权,信号量强调计数和同步。


2.6 四种同步机制如何选择?

同步机制核心作用典型场景
互斥锁保护共享资源多线程修改共享变量
条件变量等待某个条件成立队列为空时等待任务
读写锁多个读者并发访问配置表读多写少
信号量控制资源数量限制同时访问硬件资源的线程数

实际开发中,这些同步机制也可以组合使用。

例如生产者消费者模型:

  • 互斥锁:保护任务队列。

  • 条件变量:队列为空或已满时等待。

  • 信号量:也可以用计数方式管理空闲槽位和已有任务数量。


三、生产者消费者模型

3.1 什么是生产者消费者模型?

生产者消费者模型是多线程开发中非常经典的设计模式。

核心思想:

生产者负责生产任务,消费者负责处理任务,中间通过共享队列进行解耦。

例如视频处理程序:

摄像头
  |
  v
采集线程(生产者)
  |
  v
共享任务队列
  |
  v
处理线程(消费者)
  |
  v
图像处理

采集线程不需要等待图像处理完成,可以持续获取视频帧并放入队列。

处理线程从队列中取出视频帧进行处理。

这样可以将数据采集和数据处理分开,提高系统并发能力。

3.2 单生产者、单消费者模型

假设:

  • 一个生产者向队列添加任务。

  • 一个消费者从队列取出任务。

需要解决两个问题:

  1. 队列为空时,消费者不能取任务。

  2. 如果使用有界队列,队列满时,生产者不能继续添加任务。

因此,需要两个条件变量:

pthread_cond_t not_empty;
pthread_cond_t not_full;

它们分别表示:

  • not_empty:队列不为空,可以取任务。

  • not_full:队列没有满,可以添加任务。

3.2.1 生产者

pthread_mutex_lock(&mutex);

while (queue.size() == capacity)
{
    pthread_cond_wait(&not_full, &mutex);
}

queue.push(task);

pthread_cond_signal(&not_empty);

pthread_mutex_unlock(&mutex);

执行过程:

  1. 获取队列互斥锁。

  2. 检查队列是否已满。

  3. 如果队列已满,等待 not_full。

  4. 队列有空位后,添加任务。

  5. 通知消费者队列中有新任务。

  6. 释放互斥锁。

3.2.2 消费者

pthread_mutex_lock(&mutex);

while (queue.empty())
{
    pthread_cond_wait(&not_empty, &mutex);
}

Task task = queue.front();

queue.pop();

pthread_cond_signal(&not_full);

pthread_mutex_unlock(&mutex);

// 在锁外处理任务
process(task);

执行过程:

  1. 获取队列互斥锁。

  2. 检查队列是否为空。

  3. 如果为空,等待 not_empty。

  4. 队列有任务后,取出任务。

  5. 通知生产者队列有空位。

  6. 释放互斥锁。

  7. 在锁外处理任务。

不要在持有队列锁的情况下执行耗时的任务处理操作。

3.3 多生产者、多消费者模型

实际项目中,可能有多个生产者和消费者。

生产者1 ----\
生产者2 -----\
生产者3 ------> 共享任务队列 ----> 消费者1
生产者4 -----/                 \--> 消费者2
                               \--> 消费者3

多个生产者可能同时添加任务,多个消费者也可能同时取出任务。

因此,必须使用互斥锁保护队列的状态检查和插入、取出操作。

3.3.1 为什么需要两个条件变量?

假设只使用一个条件变量:

pthread_cond_t cond;

生产者和消费者都在这个条件变量上等待。

可能发生:

(多消费者时消费者调用 pthread_cond_signal(&cond)唤醒的是另一个消费者)

  1. 队列已满,多个生产者等待。

  2. 消费者取出一个任务,队列出现空位。

  3. 消费者调用 pthread_cond_signal(&cond)。

  4. 被唤醒的可能是另一个消费者。

  5. 消费者发现队列仍然为空,又继续等待。

  6. 原本应该被唤醒的生产者仍然在等待。

这样可能造成不必要的唤醒,甚至影响系统进展。

因此,应该使用两个条件变量:

pthread_cond_t not_empty;
pthread_cond_t not_full;

生产者添加任务:

pthread_cond_signal(&not_empty);

消费者取出任务:

pthread_cond_signal(&not_full);

3.3.2 多生产者、多消费者的核心逻辑

生产者:

pthread_mutex_lock(&mutex);

while (queue.size() >= capacity && !stopping)
{
    pthread_cond_wait(&not_full, &mutex);
}

if (stopping)
{
    pthread_mutex_unlock(&mutex);
    return;
}

queue.push(task);

pthread_cond_signal(&not_empty);

pthread_mutex_unlock(&mutex);

消费者:

pthread_mutex_lock(&mutex);

while (queue.empty() && !stopping)
{
    pthread_cond_wait(&not_empty, &mutex);
}

if (queue.empty() && stopping)
{
    pthread_mutex_unlock(&mutex);
    return;
}

Task task = queue.front();

queue.pop();

pthread_cond_signal(&not_full);

pthread_mutex_unlock(&mutex);

process(task);

这里增加了一个状态:

bool stopping = false;

表示任务队列是否正在关闭。

消费者退出条件:

if (queue.empty() && stopping)
{
    pthread_mutex_unlock(&mutex);
    return;
}

含义:

  • 没有停止时,队列为空就继续等待。

  • 停止时,如果队列还有任务,就继续处理。

  • 停止时,如果队列已经为空,就退出。

注意:这只是生产者消费者的核心逻辑。真正的完整实现还需要统一管理队列关闭、生产者提交和线程生命周期。


四、线程安全、竞态条件和死锁

4.1 什么是线程安全?

线程安全指的是:

一个函数、对象或者模块在多个线程并发访问的情况下,仍然能够保持正确行为。

例如:

int count = 0;

void add()
{
    count++;
}

多个线程同时调用 add(),可能产生数据竞争,因此这个函数不是线程安全的。

可以使用互斥锁:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int count = 0;

void add()
{
    pthread_mutex_lock(&mutex);

    count++;

    pthread_mutex_unlock(&mutex);
}

除此之外,还可以使用:

  • 原子变量。

  • 线程局部存储。

  • 消息队列。

  • 不可变数据。

  • 明确的资源所有权设计。

需要注意,只保护某一个变量,不代表整个业务逻辑一定线程安全。

4.2 什么是数据竞争 Data Race?

数据竞争通常指:

多个线程并发访问同一个内存位置,至少一个线程执行写操作,而且这些访问之间没有适当的同步关系。

例如:

int value = 0;

// 线程1
value++;

// 线程2
value++;

两个线程没有同步地修改同一个变量,就可能产生数据竞争。

在 C++ 内存模型中,未正确同步的 data race 会导致未定义行为。

解决方式:

  • 使用互斥锁。

  • 使用 std::atomic。

  • 通过线程安全队列传递数据。

  • 避免多个线程同时修改同一份数据。

4.3 什么是竞态条件 Race Condition?

竞态条件的概念比数据竞争更广。

它强调:

程序最终结果依赖于线程执行顺序,而这种执行顺序没有得到正确控制。

例如:

if (account_balance >= 100)
{
    account_balance -= 100;
}

假设两个线程同时执行,账户余额为 100。

两个线程都可能先读取到余额为 100,然后分别判断余额充足,最后都执行扣款。

因此,判断余额和扣款应该作为一个整体进行保护。

Data Race 和 Race Condition 的区别

对比项Data RaceRace Condition
中文数据竞争竞态条件
关注点无同步的共享内存并发访问执行时序影响程序结果
范围相对具体更广
是否一定涉及数据竞争是不一定

4.4 什么是死锁 Deadlock?

死锁是指:

多个线程互相等待对方持有的资源,导致所有线程都无法继续执行。

例如:

pthread_mutex_t mutex1;
pthread_mutex_t mutex2;

线程 A:

pthread_mutex_lock(&mutex1);

pthread_mutex_lock(&mutex2);

线程 B:

pthread_mutex_lock(&mutex2);

pthread_mutex_lock(&mutex1);

可能出现:

  1. 线程 A 获取 mutex1。

  2. 线程 B 获取 mutex2。

  3. 线程 A 尝试获取 mutex2,但 mutex2 被 B 持有。

  4. 线程 B 尝试获取 mutex1,但 mutex1 被 A 持有。

此时 A 等待 B 释放 mutex2,B 等待 A 释放 mutex1,形成死锁。

4.4.1 死锁的四个必要条件

1. 互斥条件

资源同一时刻只能被一个线程使用。

2. 请求与保持条件

线程已经持有一个资源,同时又请求其他资源。

3. 不可剥夺条件

线程已经获取的资源不能被强制剥夺,只能由线程主动释放。

4. 循环等待条件

多个线程之间形成循环等待关系。

四个条件同时成立,才具备发生死锁的必要条件。

4.4.2 如何避免死锁?

方法一:统一加锁顺序。

所有线程按照相同顺序获取锁。

pthread_mutex_lock(&mutex1);

pthread_mutex_lock(&mutex2);

// 执行操作

pthread_mutex_unlock(&mutex2);

pthread_mutex_unlock(&mutex1);

方法二:减少嵌套加锁。

避免一个线程持有一把锁时,又去获取另一把锁。

方法三:缩短临界区。

不要在持锁期间执行耗时操作、网络通信或者等待其他线程。

方法四:明确锁的所有权。

每一把锁由谁获取、谁释放,应该有清晰的设计。

注意:pthread_mutex_trylock() 可以用于某些避免阻塞等待的策略,但单独使用它并不能自动解决所有死锁问题。


五、有界队列和线程池

5.1 为什么需要有界队列?

假设:

  • 生产者每秒产生 1000 个任务。

  • 消费者每秒只能处理 500 个任务。

那么每秒就会有 500 个任务堆积在队列中。

如果程序持续运行,队列就会越来越大,最终可能造成内存耗尽。

因此,实际项目通常会限制队列容量。

这种队列叫作有界队列(Bounded Queue)。

5.2 有界队列的两种处理策略

策略一:阻塞生产者。

队列满时,生产者等待,直到消费者取走任务。

适合:

  • 不能丢失任务的业务。

  • 普通任务调度系统。

  • 文件处理任务。

  • 需要保证任务完整性的场景。

策略二:丢弃任务。

队列满时,直接丢弃新任务,或者丢弃队列中较旧的任务。

适合:

  • 实时视频流。

  • 实时图像处理。

  • 对实时性要求高于完整性的场景。

例如视频采集线程每秒产生 30 帧,但图像处理线程只能处理每秒 20 帧。

如果始终采用阻塞策略,采集线程可能被迫等待,导致延迟不断增加。

此时可以采用丢帧策略,优先处理最新的视频帧。

因此,有界队列不仅是限制内存,还可以控制任务积压和系统延迟。

5.3 环形队列 Circular Queue

有界队列的一种常见实现方式是环形队列。

它通过固定大小的数组实现队列。

需要维护:

buffer      // 存储任务的数组
capacity    // 队列最大容量
head        // 队头位置
tail        // 队尾位置
size        // 当前任务数量

插入任务:

buffer[tail] = task;

tail = (tail + 1) % capacity;

size++;

取出任务:

Task task = buffer[head];

head = (head + 1) % capacity;

size--;

使用取模运算,让数组末尾之后重新回到数组开头。

通过 size 区分队列的空和满:

size == 0          // 队列为空
size == capacity   // 队列已满

注意:环形队列本身不一定线程安全。多个生产者和消费者并发访问时,仍然需要互斥锁或其他同步设计。

5.4 线程池 Thread Pool

5.4.1 为什么需要线程池?

假设服务器每收到一个请求,就创建一个线程:

pthread_create(...);

处理完成后再等待线程退出:

pthread_join(...);

频繁创建和销毁线程会带来额外开销。

而且线程数量可能不断增长,造成系统资源紧张。

线程池就是为了解决这个问题。

线程池的核心思想:提前创建一定数量的工作线程,让这些线程反复执行任务,而不是每次有任务都创建新线程。

线程池的做法:提前创建好固定数量的线程(比如 8 个),让它们在那里待命。任务来了直接扔给它们执行,执行完也不销毁,继续等下一个任务。这就实现了线程复用。

5.4.2 线程池的基本结构

一个线程池通常包含:

  1. 工作线程。

  2. 任务队列。

  3. 任务提交接口。

  4. 线程同步机制。

  5. 停止和资源回收机制。

             submit(task)
                  |
                  v
             任务队列
                  |
          +-------+-------+
          |       |       |
          v       v       v
        worker1 worker2 worker3
          |       |       |
          v       v       v
        执行任务 执行任务 执行任务

5.4.3 工作线程的执行流程

工作线程启动后,不是执行一次任务就退出,而是持续循环:

while (true)
{
    pthread_mutex_lock(&mutex);

    while (queue.empty() && !stopping)
    {
        pthread_cond_wait(&not_empty, &mutex);
    }

    if (queue.empty() && stopping)
    {
        pthread_mutex_unlock(&mutex);
        break;
    }

    Task task = queue.front();

    queue.pop();

    pthread_cond_signal(&not_full);

    pthread_mutex_unlock(&mutex);

    task();
}

执行逻辑:

  1. 工作线程获取互斥锁。

  2. 检查任务队列。

  3. 如果没有任务,就等待条件变量。

  4. 如果有任务,就从队列中取出任务。

  5. 释放互斥锁。

  6. 执行任务。

  7. 执行完成后,回到循环开头。

task() 必须在锁外执行,否则一个工作线程执行耗时任务时,其他工作线程可能无法获取任务。

5.4.4 任务提交接口

线程池通常提供:

submit(task);

调用者不需要关心具体由哪个工作线程执行任务。

线程池内部负责:

  • 检查是否允许提交任务。

  • 将任务放入队列。

  • 通知工作线程。

  • 由空闲工作线程获取任务并执行。

例如:

pool.submit([]()
{
    printf("执行任务\n");
});

可以使用:

std::function<void()>

保存不同形式的任务。

实际实现必须解决 submit() 与 stop() 并发执行的问题,防止线程池关闭后仍然提交任务,或者在线程池资源销毁后继续访问队列。


六、线程退出和资源回收

6.1 线程退出的几种方式

6.1.1 线程函数 return

void* thread_func(void* arg)
{
    // 执行任务

    return NULL;
}

线程函数执行到 return,当前线程正常退出。

6.1.2 pthread_exit()

void* thread_func(void* arg)
{
    pthread_exit(NULL);
}

主动终止当前线程,不会直接结束整个进程。

6.1.3 pthread_cancel()

pthread_cancel(tid);

发送取消请求。

默认采用延迟取消机制,线程在取消点响应。

复杂业务中不建议将它作为线程池主要停止方式。

6.2 协作式退出

更推荐通过停止标志通知工作线程退出。

bool stopping = false;

消费者:

while (true)
{
    pthread_mutex_lock(&mutex);

    while (queue.empty() && !stopping)
    {
        pthread_cond_wait(&not_empty, &mutex);
    }

    if (queue.empty() && stopping)
    {
        pthread_mutex_unlock(&mutex);
        break;
    }

    Task task = queue.front();

    queue.pop();

    pthread_mutex_unlock(&mutex);

    process(task);
}

停止条件:

queue.empty() && stopping

表示线程池正在关闭,而且没有剩余任务。

如果采用优雅停止,工作线程就可以在执行完剩余任务后退出。

6.3 优雅停止和立即停止

6.3.1 优雅停止 Graceful Shutdown

  • 不再接受新的任务。

  • 已经提交的任务继续执行。

  • 所有任务执行完毕后,工作线程退出。

  • 最后回收资源。

6.3.2 立即停止 Immediate Shutdown

  • 不再接受新的任务。

  • 清理尚未执行的任务。

  • 正在执行的任务如何处理,需要由业务决定。

例如实时视频处理程序关闭时,可以丢弃尚未处理的视频帧,不必为了处理完所有历史帧而延迟关闭。

但是立即停止不意味着可以随意强制终止线程。

仍然需要保证锁正常释放、资源没有提前销毁,也不会产生悬空指针。

6.4 线程池停止时为什么需要 broadcast?

假设线程池中有 5 个工作线程,它们全部因为任务队列为空而进入等待状态:

pthread_cond_wait(&not_empty, &mutex);

此时管理线程准备关闭线程池。

如果只修改:

stopping = true;

工作线程可能仍然一直处于等待状态。

因此,需要通知所有等待线程:

pthread_mutex_lock(&mutex);

stopping = true;

pthread_cond_broadcast(&not_empty);
pthread_cond_broadcast(&not_full);

pthread_mutex_unlock(&mutex);

原因:

  • 等待 not_empty 的消费者需要被唤醒。

  • 等待 not_full 的生产者需要被唤醒。

关闭流程还必须先阻止新的生产者继续提交任务,并妥善处理正在提交任务的生产者。

6.5 pthread_join:等待线程退出

pthread_join(tid, NULL);

作用:

  • 等待指定线程退出。

  • 获取线程退出状态(如果提供接收参数)。

  • 回收 joinable 线程相关资源。

默认情况下,pthread_create() 创建的线程是 joinable 状态。

如果不需要等待线程退出,也不需要获取其返回值,可以使用:

pthread_detach(tid);

线程退出后,detached 线程的相关资源会自动释放,但不能再调用 pthread_join()。

6.6 正确的线程池关闭顺序

一个合理的优雅关闭流程:

第一步:停止接受新的任务。

确保新的 submit() 请求不能继续进入任务队列。

第二步:设置停止标志。

stopping = true;

该标志需要在正确的互斥保护下修改。

第三步:唤醒所有等待线程。

pthread_cond_broadcast(&not_empty);
pthread_cond_broadcast(&not_full);

第四步:等待生产者退出。

确保正在提交任务的生产者已经退出,不会继续向队列添加任务。

第五步:工作线程处理剩余任务。

如果采用优雅停止,工作线程继续执行已经提交的任务。

第六步:等待所有工作线程退出。

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

第七步:销毁同步对象。

pthread_cond_destroy(&not_empty);
pthread_cond_destroy(&not_full);

pthread_mutex_destroy(&mutex);

第八步:释放队列和其他资源。

只有在所有使用这些资源的线程都已经退出后,才能安全销毁它们。


七、实际开发中容易忽略的问题

7.1 任务队列中的数据所有权

例如视频采集线程获取了一帧图像:

cv::Mat frame;

然后将它放入任务队列。

如果队列只是保存一个指向临时缓冲区的裸指针,而采集线程随后又复用了这块内存,消费者可能读取到已经被修改的数据,甚至访问已经失效的内存。

因此,任务入队时必须明确数据所有权。

常见方案:

  • 深拷贝数据。

  • 使用引用计数。

  • 使用 std::shared_ptr 管理共享对象,能解决对象生命周期问题。

  • 使用明确的缓冲区池和所有权转移机制。

例如:

std::shared_ptr<Frame> frame;

将共享指针放入队列,可以让生产者和消费者共同管理帧对象的生命周期。不会访问已经失效的内存。

但引用计数只能解决对象生命周期问题,不能自动保证对象内部数据的并发访问安全。

动保证对象内部数据的并发访问安全还是要使用锁。

7.2 不要让队列锁保护整个业务处理过程

错误:

pthread_mutex_lock(&mutex);

Task task = queue.front();

queue.pop();

process(task);

pthread_mutex_unlock(&mutex);

process(task) 可能耗时很长,其他线程无法及时访问队列。

正确:

pthread_mutex_lock(&mutex);

Task task = queue.front();

queue.pop();

pthread_mutex_unlock(&mutex);

process(task);

7.3 pthread API 的错误处理

pthread 函数通常直接返回错误码。

例如:

int ret = pthread_mutex_lock(&mutex);

if (ret != 0)
{
    printf("pthread_mutex_lock failed: %d\n", ret);
}

不要把所有 pthread 函数都按照普通系统调用的错误处理方式理解。

另外,pthread_create()、pthread_join() 等接口也需要检查返回值。

7.4 不要提前销毁同步对象

如果还有线程正在使用:

pthread_mutex_destroy(&mutex);

就可能产生未定义行为。

正确原则:

先确保所有使用同步对象的线程退出,再销毁同步对象。


八、Linux 多线程面试重点与常见问题

8.1 线程基础类

问题1:进程和线程有什么区别?

答:

进程是操作系统资源分配的基本单位,线程是 CPU 调度和执行的基本单位。

进程之间拥有相对独立的虚拟地址空间,而同一进程中的多个线程共享进程的地址空间、堆内存、全局变量、静态变量以及打开的文件描述符等资源。

每个线程拥有独立的栈、寄存器状态和程序计数器。

线程之间共享资源方便,但需要通过互斥锁、条件变量等同步机制保证共享数据的线程安全。

问题2:Linux 下如何创建线程?

答:

Linux 下通常使用 POSIX 线程库提供的 pthread_create() 创建线程。

该函数需要指定线程 ID、线程属性、线程执行函数以及传递给线程的参数。

创建成功后,可以通过 pthread_join() 等待线程退出并回收资源,也可以通过 pthread_detach() 将线程设置为分离状态。

需要注意,pthread_create() 成功返回 0,失败时直接返回错误码。

问题3:pthread_join() 和 pthread_detach() 有什么区别?

答:

pthread_join() 用于等待指定线程退出,并回收其相关资源,还可以获取线程的返回值。

pthread_detach() 用于将线程设置为分离状态,线程退出后由系统自动回收相关资源,不需要其他线程再调用 pthread_join()。

如果需要等待线程执行完成或者获取返回值,就使用 pthread_join();如果线程不需要被等待和获取返回值,可以使用 pthread_detach()。

问题4:线程和进程之间如何通信?

答:

同一进程中的线程共享地址空间,可以通过全局变量、共享内存等方式直接交换数据,但需要使用互斥锁、条件变量等机制保证同步。

不同进程拥有独立的地址空间,通常通过 IPC 机制通信,例如管道、FIFO、共享内存、消息队列和 Socket 等。

8.2 线程同步类

问题5:为什么需要互斥锁?

答:

多个线程共享同一份数据时,如果同时进行读写操作,可能发生数据竞争,导致数据不一致。

互斥锁可以保证同一时刻只有一个线程进入受保护的临界区,从而避免多个线程同时修改共享数据。

问题6:互斥锁和自旋锁有什么区别?

答:

互斥锁获取失败时,线程通常会进入阻塞等待状态,不会一直占用 CPU 进行主动检查。

自旋锁获取失败时,线程会持续循环检查锁的状态,等待锁释放,因此会持续占用 CPU。

自旋锁适合临界区非常短、预计等待时间很短的场景;互斥锁更适合临界区较长或者等待时间不确定的场景。

问题7:互斥锁和信号量有什么区别?

答:

互斥锁主要用于保护共享资源,保证同一时刻只有一个线程访问临界区,强调锁的所有权。

信号量通过计数值控制可用资源的数量,也可以实现线程同步。

互斥锁通常只有一个线程持有,而计数信号量可以允许多个线程同时获取资源。例如,信号量初始值为 5,就可以控制最多 5 个线程同时获取对应的资源名额。

问题8:条件变量有什么作用?

答:

条件变量主要用于线程之间的等待和通知,避免线程在等待某个条件时不断循环检查,造成 CPU 资源浪费。

例如生产者消费者模型中,消费者发现任务队列为空时,可以调用 pthread_cond_wait() 进入阻塞等待;生产者添加任务后,通过 pthread_cond_signal() 唤醒消费者。

条件变量通常需要和互斥锁配合使用。

问题9:条件变量和互斥锁有什么区别?

答:

互斥锁主要解决共享资源的并发访问冲突,保证同一时刻只有一个线程进入临界区。

条件变量主要解决线程之间的等待和通知问题,当某个条件不满足时,线程可以进入阻塞等待状态,等其他线程改变条件后再被唤醒。

两者通常配合使用:互斥锁保护共享数据,条件变量负责等待和通知。

问题10:为什么 pthread_cond_wait() 要放在 while 中?

答:

因为条件变量可能发生虚假唤醒,而且多个线程被唤醒后可能竞争同一个资源。

例如两个消费者同时被唤醒,但只有一个任务,先获得锁的消费者取走任务后,另一个消费者再次获得锁时,队列可能已经为空。

因此,不能认为线程被唤醒就代表条件一定成立,必须使用 while 重新检查共享条件。

问题11:pthread_cond_signal() 和 pthread_cond_broadcast() 有什么区别?

答:

pthread_cond_signal() 通常唤醒一个正在等待该条件变量的线程,而 pthread_cond_broadcast() 会唤醒所有等待该条件变量的线程。

普通任务到达时,通常使用 signal() 唤醒一个消费者;线程池关闭时,通常使用 broadcast() 唤醒所有阻塞的工作线程,让它们检查停止标志并退出。

问题12:读写锁和互斥锁有什么区别?

答:

互斥锁同一时刻通常只允许一个线程进入临界区,不区分读操作和写操作。

读写锁区分读锁和写锁:多个线程可以同时持有读锁,但写锁是独占的,与其他读锁和写锁都互斥。

因此,读写锁适合读多写少的场景。不过,如果写操作比较频繁,读写锁不一定比互斥锁效率高,还需要考虑线程饥饿问题。

问题13:信号量的初始值为 5,代表什么?

答:

表示初始有 5 个可用的资源名额。

每次成功执行 sem_wait(),信号量计数值减 1;执行 sem_post(),计数值加 1。

因此,在正确的资源管理逻辑下,最多允许 5 个线程同时获取对应的资源。

8.3 生产者消费者类

问题14:什么是生产者消费者模型?

答:

生产者消费者模型是一种常见的并发设计模式,主要由生产者、任务队列和消费者组成。

生产者负责生成任务并放入队列,消费者负责从队列中取出任务并处理,任务队列起到缓冲和解耦的作用。

这样生产者和消费者不需要直接等待对方执行完成,可以提高系统的并发处理能力。

问题15:生产者消费者模型为什么需要两个条件变量?

答:

因为有界队列存在两种不同的等待条件。

not_empty 用于消费者等待任务,当生产者向队列添加任务后通知消费者;not_full 用于生产者等待空闲位置,当消费者取走任务后通知生产者。

使用两个条件变量可以分别管理生产者和消费者的等待状态,避免共用一个条件变量时唤醒不合适的线程。

问题16:为什么取出任务后要在锁外执行?

答:

因为互斥锁主要用于保护任务队列,而不是保护任务的执行过程。

如果消费者持有队列锁执行耗时任务,其他生产者和消费者就无法访问队列,会降低系统并发能力。

因此,应该先加锁取出任务,再释放锁,在锁外执行任务。

8.4 并发问题类

问题17:什么是线程安全?

答:

线程安全是指多个线程并发访问某个函数、对象或模块时,仍然能够保证程序行为正确,不会因为并发执行导致数据破坏或错误结果。

通常可以通过互斥锁、原子变量、线程局部存储以及消息传递等方式实现线程安全。

问题18:什么是数据竞争?

答:

数据竞争是指多个线程并发访问同一内存位置,至少有一个线程执行写操作,并且这些访问之间缺少适当的同步关系。

在 C++ 内存模型中,未正确同步的数据竞争属于未定义行为。

通常可以通过互斥锁或原子变量解决。

问题19:什么是竞态条件?

答:

竞态条件是指程序的执行结果依赖于多个线程的执行时序,而这种时序没有得到正确控制,可能导致程序产生错误结果。

数据竞争和竞态条件不同:数据竞争特指未正确同步的并发内存访问,而竞态条件还包括更广泛的业务逻辑问题。例如,两个线程分别使用原子操作读取余额和扣款,仍然可能因为操作时序导致重复扣款。

问题20:什么是死锁?产生死锁的四个条件是什么?

答:

死锁是指多个线程互相等待对方持有的资源,导致所有线程都无法继续执行。

产生死锁需要同时满足四个必要条件:

  1. 互斥条件:资源一次只能由一个线程使用。

  2. 请求与保持条件:线程持有资源的同时,又请求其他资源。

  3. 不可剥夺条件:线程已获得的资源不能被强制夺走,只能主动释放。

  4. 循环等待条件:多个线程之间形成循环等待关系。

问题21:如何避免死锁?

答:

常见方法有:

  1. 统一加锁顺序,避免不同线程按照不同顺序获取多把锁。

  2. 尽量减少嵌套加锁,降低资源之间的依赖关系。

  3. 缩短临界区,减少持锁时间。

  4. 避免持锁执行耗时操作,例如网络通信和文件 I/O。

  5. 同时获取多把锁时,可以使用 std::lock() 或 C++17 的 std::scoped_lock。

8.5 线程池和资源回收类

问题22:为什么需要线程池?

答:

如果每来一个任务就创建一个线程,任务执行完成后再销毁线程,会产生频繁的线程创建和销毁开销。

同时,大量任务到达时可能创建过多线程,增加上下文切换开销和系统资源消耗。

线程池通过提前创建一定数量的工作线程,让它们反复执行任务,从而实现线程复用,控制并发线程数量,提高资源利用率。

问题23:线程池的核心组成是什么?

答:

线程池主要由以下几个部分组成:

  1. 工作线程:负责执行任务。

  2. 任务队列:存放等待执行的任务。

  3. 任务提交接口:负责接收并提交任务。

  4. 互斥锁:保护任务队列和线程池状态。

  5. 条件变量:让工作线程在没有任务时阻塞等待。

  6. 停止标志:控制线程池关闭。

  7. 线程回收机制:通过 pthread_join() 等待工作线程退出并回收资源。

问题24:为什么需要有界队列?

答:

有界队列主要用于限制任务数量,避免生产速度长期超过消费速度时,任务无限堆积,导致内存持续增长甚至耗尽。

当队列已满时,可以阻塞生产者、拒绝新任务或者丢弃旧任务。

具体采用哪种策略,需要根据业务需求决定。例如实时视频处理系统通常更关注实时性,可以根据设计策略丢弃过期视频帧,避免队列堆积导致延迟不断增加。

问题25:线程池如何优雅退出?

答:

线程池优雅退出通常采用协作式退出,基本流程是:

  1. 停止接受新任务。

  2. 设置线程池停止标志。

  3. 使用 broadcast() 唤醒所有阻塞的工作线程。

  4. 工作线程根据退出策略处理已经提交的任务。

  5. 通过 pthread_join() 等待所有工作线程退出。

  6. 确认没有线程继续使用同步对象后,销毁互斥锁和条件变量。

  7. 释放任务队列及其他资源。

优雅退出通常会处理完已提交任务,而立即退出则可能丢弃尚未执行的任务。

问题26:pthread_cancel() 和协作式退出有什么区别?

答:

pthread_cancel() 用于向指定线程发送取消请求,默认采用延迟取消机制,线程通常在执行到取消点时响应取消请求。

协作式退出则是通过停止标志、条件变量等方式通知线程,让线程主动检查退出条件并执行清理操作。

相比之下,协作式退出更容易控制线程退出流程,避免锁和其他资源没有正确释放。

因此,在线程池中通常更推荐使用协作式退出。

问题27:线程退出后为什么需要 pthread_join()?

答:

默认创建的线程属于 joinable 状态,线程退出后仍需要其他线程调用 pthread_join() 等待并回收其相关资源。

如果不进行回收,可能造成线程资源长期未释放。

如果线程被设置为 detached 状态,则在线程退出后由系统自动释放相关资源,不需要再调用 pthread_join()。

问题28:为什么不能在线程还运行时销毁互斥锁?

答:

因为其他线程可能仍然持有这把锁,或者正在等待获取这把锁。

如果此时销毁互斥锁,可能导致未定义行为或资源访问异常。

正确做法是先通知所有工作线程退出,通过 pthread_join() 等待它们全部结束,确认没有线程继续使用互斥锁后,再销毁互斥锁和其他同步对象。


本章复习重点

这一部分建议重点掌握以下内容:

  • 线程基础:进程与线程区别、线程创建与回收。

  • 线程同步:互斥锁、自旋锁、信号量、条件变量、读写锁。

  • 生产者消费者:有界队列、两个条件变量、锁外执行任务。

  • 并发问题:线程安全、数据竞争、竞态条件、死锁。

  • 线程池:任务队列、线程复用、优雅退出、资源回收。


九、实战项目:基于 POSIX 线程的任务调度系统

学完这些知识点后,建议自己实现一个小型任务调度系统。

项目名称:

基于 POSIX 多线程的任务调度系统

9.1 项目功能

实现:

  1. 多生产者:负责提交任务。

  2. 有界任务队列:保存待执行任务。

  3. 多消费者:从队列中取出任务。

  4. 线程池:管理固定数量的工作线程。

  5. 条件变量:队列为空或已满时进行等待。

  6. 互斥锁:保护队列和线程池状态。

  7. 优雅关闭:停止接收任务,执行完剩余任务后退出。

  8. 资源回收:join 工作线程并销毁同步对象。

9.2 项目结构

thread_pool/
├── CMakeLists.txt
├── include/
│   ├── ThreadPool.h
│   └── TaskQueue.h
├── src/
│   ├── ThreadPool.cpp
│   ├── TaskQueue.cpp
│   └── main.cpp
└── README.md

9.3 验收标准

测试一:多生产者、多消费者

创建 3 个生产者、3 个消费者,队列容量设置为 100。

检查能否正常生产和消费任务。

测试二:队列容量为 1

检查生产者和消费者能否正确等待和唤醒。

测试三:大量任务

提交 10 万个任务,检查:

  • 是否有任务丢失。

  • 是否有任务重复执行。

  • 最终执行数量是否正确。

  • 程序是否出现死锁。

测试四:并发关闭

在任务提交和任务执行过程中触发关闭,检查:

  • 是否拒绝新的任务。

  • 已提交任务是否按照停止策略处理。

  • 工作线程是否正常退出。

  • 是否存在资源泄漏。

测试五:线程安全检查

使用 ThreadSanitizer:

g++ -std=c++11 -g -O1 \
-fsanitize=thread \
-fno-omit-frame-pointer \
-pthread \
main.cpp ThreadPool.cpp TaskQueue.cpp \
-o thread_pool

运行:

./thread_pool

也可以使用 AddressSanitizer 检查内存错误:

g++ -std=c++11 -g -O1 \
-fsanitize=address \
-fno-omit-frame-pointer \
-pthread \
main.cpp ThreadPool.cpp TaskQueue.cpp \
-o thread_pool_asan

TSan 和 ASan 通常分别构建和运行。


十、总结:多线程知识体系

Linux 多线程编程需要掌握的知识可以分成六个阶段。

阶段知识点掌握目标
线程基础进程与线程、pthread_create、join、detach、exit能创建和管理线程
同步机制互斥锁、条件变量、读写锁、信号量理解不同同步机制的使用场景
生产者消费者单生产者、多生产者、多消费者能实现线程安全的任务队列
并发问题线程安全、数据竞争、竞态条件、死锁能分析并发错误
线程池有界队列、环形队列、任务提交、工作线程能设计任务调度系统
线程退出停止标志、broadcast、join、资源回收能安全关闭多线程程序

面试复习优先级

优先级知识点
必须掌握进程与线程的区别
必须掌握pthread_create、pthread_join、pthread_detach
必须掌握互斥锁的作用和使用方式
必须掌握条件变量的使用方式以及 while 的原因
必须掌握生产者消费者模型
必须掌握死锁的四个必要条件
必须掌握线程池的基本结构和工作流程
重点掌握读写锁与互斥锁的区别
重点掌握信号量与互斥锁的区别
重点掌握多生产者、多消费者为什么需要两个条件变量
重点掌握有界队列和背压
重点掌握线程池的优雅退出
进阶掌握环形队列实现
进阶掌握TSan、ASan 并发问题排查
进阶掌握线程取消、资源所有权和复杂关闭流程

对于嵌入式 Linux C/C++ 应用开发,建议重点练习互斥锁、条件变量、读写锁、生产者消费者模型和线程池。

尤其是在视频采集、RTSP 数据处理、图像处理等项目中,经常需要多个线程配合完成任务。

真正掌握这些知识的标准,不是能够背出 pthread API,而是能够独立设计一个多生产者、多消费者的线程安全任务队列,并且正确处理任务积压、线程退出、数据所有权和资源回收。

 

Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐