Linux 多线程编程详解:线程基础、同步机制、生产者消费者、线程池与面试重点
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);
两种线程状态的区别:
| 对比项 | Joinable | Detached |
|---|---|---|
| 是否需要 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++;
不是原子操作,通常可以理解为:
-
读取 count。
-
执行加 1。
-
写回 count。
两个线程可能读取到相同的旧值,最终覆盖彼此的修改。
因此,需要通过线程同步机制保护共享资源。
常见同步机制:
-
互斥锁 Mutex。
-
条件变量 Condition Variable。
-
读写锁 Read-Write Lock。
-
信号量 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。
调用过程:
-
原子地释放 mutex,并进入条件变量等待。
-
被唤醒后,重新获取 mutex。
-
成功获取 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 单生产者、单消费者模型
假设:
-
一个生产者向队列添加任务。
-
一个消费者从队列取出任务。
需要解决两个问题:
-
队列为空时,消费者不能取任务。
-
如果使用有界队列,队列满时,生产者不能继续添加任务。
因此,需要两个条件变量:
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(¬_full, &mutex);
}
queue.push(task);
pthread_cond_signal(¬_empty);
pthread_mutex_unlock(&mutex);
执行过程:
-
获取队列互斥锁。
-
检查队列是否已满。
-
如果队列已满,等待
not_full。 -
队列有空位后,添加任务。
-
通知消费者队列中有新任务。
-
释放互斥锁。
3.2.2 消费者
pthread_mutex_lock(&mutex);
while (queue.empty())
{
pthread_cond_wait(¬_empty, &mutex);
}
Task task = queue.front();
queue.pop();
pthread_cond_signal(¬_full);
pthread_mutex_unlock(&mutex);
// 在锁外处理任务
process(task);
执行过程:
-
获取队列互斥锁。
-
检查队列是否为空。
-
如果为空,等待
not_empty。 -
队列有任务后,取出任务。
-
通知生产者队列有空位。
-
释放互斥锁。
-
在锁外处理任务。
不要在持有队列锁的情况下执行耗时的任务处理操作。
3.3 多生产者、多消费者模型
实际项目中,可能有多个生产者和消费者。
生产者1 ----\
生产者2 -----\
生产者3 ------> 共享任务队列 ----> 消费者1
生产者4 -----/ \--> 消费者2
\--> 消费者3
多个生产者可能同时添加任务,多个消费者也可能同时取出任务。
因此,必须使用互斥锁保护队列的状态检查和插入、取出操作。
3.3.1 为什么需要两个条件变量?
假设只使用一个条件变量:
pthread_cond_t cond;
生产者和消费者都在这个条件变量上等待。
可能发生:
(多消费者时消费者调用 pthread_cond_signal(&cond)唤醒的是另一个消费者)
-
队列已满,多个生产者等待。
-
消费者取出一个任务,队列出现空位。
-
消费者调用
pthread_cond_signal(&cond)。 -
被唤醒的可能是另一个消费者。
-
消费者发现队列仍然为空,又继续等待。
-
原本应该被唤醒的生产者仍然在等待。
这样可能造成不必要的唤醒,甚至影响系统进展。
因此,应该使用两个条件变量:
pthread_cond_t not_empty;
pthread_cond_t not_full;
生产者添加任务:
pthread_cond_signal(¬_empty);
消费者取出任务:
pthread_cond_signal(¬_full);
3.3.2 多生产者、多消费者的核心逻辑
生产者:
pthread_mutex_lock(&mutex);
while (queue.size() >= capacity && !stopping)
{
pthread_cond_wait(¬_full, &mutex);
}
if (stopping)
{
pthread_mutex_unlock(&mutex);
return;
}
queue.push(task);
pthread_cond_signal(¬_empty);
pthread_mutex_unlock(&mutex);
消费者:
pthread_mutex_lock(&mutex);
while (queue.empty() && !stopping)
{
pthread_cond_wait(¬_empty, &mutex);
}
if (queue.empty() && stopping)
{
pthread_mutex_unlock(&mutex);
return;
}
Task task = queue.front();
queue.pop();
pthread_cond_signal(¬_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 Race | Race 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);
可能出现:
-
线程 A 获取 mutex1。
-
线程 B 获取 mutex2。
-
线程 A 尝试获取 mutex2,但 mutex2 被 B 持有。
-
线程 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 线程池的基本结构
一个线程池通常包含:
-
工作线程。
-
任务队列。
-
任务提交接口。
-
线程同步机制。
-
停止和资源回收机制。
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(¬_empty, &mutex);
}
if (queue.empty() && stopping)
{
pthread_mutex_unlock(&mutex);
break;
}
Task task = queue.front();
queue.pop();
pthread_cond_signal(¬_full);
pthread_mutex_unlock(&mutex);
task();
}
执行逻辑:
-
工作线程获取互斥锁。
-
检查任务队列。
-
如果没有任务,就等待条件变量。
-
如果有任务,就从队列中取出任务。
-
释放互斥锁。
-
执行任务。
-
执行完成后,回到循环开头。
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(¬_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(¬_empty, &mutex);
此时管理线程准备关闭线程池。
如果只修改:
stopping = true;
工作线程可能仍然一直处于等待状态。
因此,需要通知所有等待线程:
pthread_mutex_lock(&mutex);
stopping = true;
pthread_cond_broadcast(¬_empty);
pthread_cond_broadcast(¬_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(¬_empty);
pthread_cond_broadcast(¬_full);
第四步:等待生产者退出。
确保正在提交任务的生产者已经退出,不会继续向队列添加任务。
第五步:工作线程处理剩余任务。
如果采用优雅停止,工作线程继续执行已经提交的任务。
第六步:等待所有工作线程退出。
for (int i = 0; i < thread_count; ++i)
{
pthread_join(threads[i], NULL);
}
第七步:销毁同步对象。
pthread_cond_destroy(¬_empty);
pthread_cond_destroy(¬_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:什么是死锁?产生死锁的四个条件是什么?
答:
死锁是指多个线程互相等待对方持有的资源,导致所有线程都无法继续执行。
产生死锁需要同时满足四个必要条件:
-
互斥条件:资源一次只能由一个线程使用。
-
请求与保持条件:线程持有资源的同时,又请求其他资源。
-
不可剥夺条件:线程已获得的资源不能被强制夺走,只能主动释放。
-
循环等待条件:多个线程之间形成循环等待关系。
问题21:如何避免死锁?
答:
常见方法有:
-
统一加锁顺序,避免不同线程按照不同顺序获取多把锁。
-
尽量减少嵌套加锁,降低资源之间的依赖关系。
-
缩短临界区,减少持锁时间。
-
避免持锁执行耗时操作,例如网络通信和文件 I/O。
-
同时获取多把锁时,可以使用
std::lock()或 C++17 的std::scoped_lock。
8.5 线程池和资源回收类
问题22:为什么需要线程池?
答:
如果每来一个任务就创建一个线程,任务执行完成后再销毁线程,会产生频繁的线程创建和销毁开销。
同时,大量任务到达时可能创建过多线程,增加上下文切换开销和系统资源消耗。
线程池通过提前创建一定数量的工作线程,让它们反复执行任务,从而实现线程复用,控制并发线程数量,提高资源利用率。
问题23:线程池的核心组成是什么?
答:
线程池主要由以下几个部分组成:
-
工作线程:负责执行任务。
-
任务队列:存放等待执行的任务。
-
任务提交接口:负责接收并提交任务。
-
互斥锁:保护任务队列和线程池状态。
-
条件变量:让工作线程在没有任务时阻塞等待。
-
停止标志:控制线程池关闭。
-
线程回收机制:通过
pthread_join()等待工作线程退出并回收资源。
问题24:为什么需要有界队列?
答:
有界队列主要用于限制任务数量,避免生产速度长期超过消费速度时,任务无限堆积,导致内存持续增长甚至耗尽。
当队列已满时,可以阻塞生产者、拒绝新任务或者丢弃旧任务。
具体采用哪种策略,需要根据业务需求决定。例如实时视频处理系统通常更关注实时性,可以根据设计策略丢弃过期视频帧,避免队列堆积导致延迟不断增加。
问题25:线程池如何优雅退出?
答:
线程池优雅退出通常采用协作式退出,基本流程是:
-
停止接受新任务。
-
设置线程池停止标志。
-
使用
broadcast()唤醒所有阻塞的工作线程。 -
工作线程根据退出策略处理已经提交的任务。
-
通过
pthread_join()等待所有工作线程退出。 -
确认没有线程继续使用同步对象后,销毁互斥锁和条件变量。
-
释放任务队列及其他资源。
优雅退出通常会处理完已提交任务,而立即退出则可能丢弃尚未执行的任务。
问题26:pthread_cancel() 和协作式退出有什么区别?
答:
pthread_cancel() 用于向指定线程发送取消请求,默认采用延迟取消机制,线程通常在执行到取消点时响应取消请求。
协作式退出则是通过停止标志、条件变量等方式通知线程,让线程主动检查退出条件并执行清理操作。
相比之下,协作式退出更容易控制线程退出流程,避免锁和其他资源没有正确释放。
因此,在线程池中通常更推荐使用协作式退出。
问题27:线程退出后为什么需要 pthread_join()?
答:
默认创建的线程属于 joinable 状态,线程退出后仍需要其他线程调用 pthread_join() 等待并回收其相关资源。
如果不进行回收,可能造成线程资源长期未释放。
如果线程被设置为 detached 状态,则在线程退出后由系统自动释放相关资源,不需要再调用 pthread_join()。
问题28:为什么不能在线程还运行时销毁互斥锁?
答:
因为其他线程可能仍然持有这把锁,或者正在等待获取这把锁。
如果此时销毁互斥锁,可能导致未定义行为或资源访问异常。
正确做法是先通知所有工作线程退出,通过 pthread_join() 等待它们全部结束,确认没有线程继续使用互斥锁后,再销毁互斥锁和其他同步对象。
本章复习重点
这一部分建议重点掌握以下内容:
-
线程基础:进程与线程区别、线程创建与回收。
-
线程同步:互斥锁、自旋锁、信号量、条件变量、读写锁。
-
生产者消费者:有界队列、两个条件变量、锁外执行任务。
-
并发问题:线程安全、数据竞争、竞态条件、死锁。
-
线程池:任务队列、线程复用、优雅退出、资源回收。
九、实战项目:基于 POSIX 线程的任务调度系统
学完这些知识点后,建议自己实现一个小型任务调度系统。
项目名称:
基于 POSIX 多线程的任务调度系统
9.1 项目功能
实现:
-
多生产者:负责提交任务。
-
有界任务队列:保存待执行任务。
-
多消费者:从队列中取出任务。
-
线程池:管理固定数量的工作线程。
-
条件变量:队列为空或已满时进行等待。
-
互斥锁:保护队列和线程池状态。
-
优雅关闭:停止接收任务,执行完剩余任务后退出。
-
资源回收: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,而是能够独立设计一个多生产者、多消费者的线程安全任务队列,并且正确处理任务积压、线程退出、数据所有权和资源回收。
openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构
更多推荐


所有评论(0)