嵌入式多线程开发：pthread 线程与互斥锁实战-平芜编程栈

嵌入式多线程开发：pthread 线程与互斥锁实战

一、引言

上一篇文章我们讨论了fork多进程开发。进程固然好——每个进程独立地址空间，崩溃不互相影响——但创建开销大、进程间通信（IPC）麻烦。在很多嵌入式场景中，我们需要轻量级的并行，这时多线程就登场了。

线程（Thread）是共享同一进程地址空间的执行流。多个线程之间切换开销远小于进程切换，而且可以直接访问同一块内存，通信几乎零成本——但也正因如此，必须用互斥锁等手段保护共享数据。

本文从pthread的创建讲起，深入互斥锁的原理与死锁排查，最后给出一个传感器数据采集+并发的实战模型。

二、线程 vs 进程：一张表看懂

对比维度	进程	线程
创建开销	大（分配独立地址空间）	小（共享地址空间）
切换开销	大（切换页表）	小（只切换寄存器和栈）
内存共享	IPC 手段（管道/共享内存）	天然共享全局变量和堆
崩溃影响	不影响其他进程	一个线程崩溃可能拖垮整个进程
适用场景	隔离性要求高	高并发、实时性要求高

在嵌入式 Linux 中，线程的优势尤为明显：传感器线程、网络通信线程、数据处理线程可以各司其职，互不阻塞。

三、创建线程：pthread_create

#include<pthread.h>intpthread_create(pthread_t*thread,constpthread_attr_t*attr,void*(*start_routine)(void*),void*arg);

看起来参数多，拆解一下：

thread：输出参数，保存新线程的 ID
attr：线程属性（NULL 表示默认）
start_routine：线程入口函数，必须是void* func(void* arg)签名
arg：传给入口函数的参数

编译时需要链接 pthread 库：

gcc-oapp main.c-lpthread

基础示例

#include<stdio.h>#include<pthread.h>#include<unistd.h>void*sensor_task(void*arg){intid=*(int*)arg;for(inti=0;i<5;i++){printf("[传感器%d] 第%d次采样\n",id,i+1);sleep(1);}printf("[传感器%d] 采集结束\n",id);returnNULL;}intmain(void){pthread_ttid1,tid2;intid1=1,id2=2;pthread_create(&tid1,NULL,sensor_task,&id1);pthread_create(&tid2,NULL,sensor_task,&id2);// 主线程等待两个子线程结束pthread_join(tid1,NULL);pthread_join(tid2,NULL);printf("所有传感器采集完成\n");return0;}

pthread_join会阻塞当前线程直到目标线程结束——类似于进程中的waitpid。

四、互斥锁：保护共享数据

多线程同时访问同一变量时，会出现竞态条件（Race Condition）。想象两个线程同时对counter++操作：

线程A: 读 counter(=0) → 加1(=1) → 写 counter(=1) 线程B: 读 counter(=0) → 加1(=1) → 写 counter(=1)

本应是 2，结果却是 1——这就是数据竞争。解决方式是互斥锁（Mutex）。

#include<pthread.h>pthread_mutex_tlock=PTHREAD_MUTEX_INITIALIZER;intshared_counter=0;void*worker(void*arg){for(inti=0;i<100000;i++){pthread_mutex_lock(&lock);// 加锁shared_counter++;// 临界区pthread_mutex_unlock(&lock);// 解锁}returnNULL;}

互斥锁像厕所的锁——一个人进去了就锁门，别人在外面等着。出来解锁后，下一个人才能进去。

互斥锁的四种操作

函数	行为
pthread_mutex_lock	阻塞等待直到拿到锁
pthread_mutex_trylock	立即返回，拿不到锁返回 EBUSY
pthread_mutex_unlock	释放锁
pthread_mutex_destroy	销毁锁（用动态方式创建的）

静态初始化用PTHREAD_MUTEX_INITIALIZER，动态初始化用pthread_mutex_init。

五、死锁：当两把锁互相等待

这是多线程编程中最让人头疼的问题。看这段代码：

pthread_mutex_tlockA=PTHREAD_MUTEX_INITIALIZER;pthread_mutex_tlockB=PTHREAD_MUTEX_INITIALIZER;// 线程1void*thread1(void*arg){pthread_mutex_lock(&lockA);// 拿到 Asleep(1);// 给线程2时间去拿 Bpthread_mutex_lock(&lockB);// 等待 B...// ...}// 线程2void*thread2(void*arg){pthread_mutex_lock(&lockB);// 拿到 Bsleep(1);// 给线程1时间去拿 Apthread_mutex_lock(&lockA);// 等待 A...// ...}

结果：线程1 持有 A 等 B，线程2 持有 B 等 A——谁也等不到谁，死锁。

避免死锁的黄金法则

固定加锁顺序：所有线程必须按相同顺序获取多把锁
限制锁粒度：锁保护的代码越少越好
使用pthread_mutex_trylock：拿不到就放弃，稍后重试
超时机制：部分 pthread 实现支持pthread_mutex_timedlock

固定加锁顺序举例：

// 无论哪个线程，都先锁 lockA 再锁 lockBpthread_mutex_lock(&lockA);pthread_mutex_lock(&lockB);// 临界区...pthread_mutex_unlock(&lockB);pthread_mutex_unlock(&lockA);

六、实战：传感器采集 + 线程池模型

下面是一个简化版的多线程传感器采集架构：

#include<stdio.h>#include<stdlib.h>#include<pthread.h>#include<unistd.h>#defineSENSOR_COUNT3pthread_mutex_tdata_lock=PTHREAD_MUTEX_INITIALIZER;// 共享数据缓冲区typedefstruct{floattemperature;floathumidity;floatpressure;intupdated;}SensorData;SensorData g_data={0};void*temp_sensor(void*arg){(void)arg;while(1){pthread_mutex_lock(&data_lock);g_data.temperature=25.0+(rand()%100)/10.0;g_data.updated=1;pthread_mutex_unlock(&data_lock);sleep(2);}returnNULL;}void*report_thread(void*arg){(void)arg;while(1){pthread_mutex_lock(&data_lock);if(g_data.updated){printf("[上报] 温度=%.1f°C\n",g_data.temperature);g_data.updated=0;}pthread_mutex_unlock(&data_lock);sleep(3);}returnNULL;}intmain(void){pthread_tt1,t2;pthread_create(&t1,NULL,temp_sensor,NULL);pthread_create(&t2,NULL,report_thread,NULL);pthread_join(t1,NULL);pthread_join(t2,NULL);return0;}

这个架构很简单但实用：采集线程定时更新共享数据，上报线程定时读取并上报，靠互斥锁保证数据一致性。

七、总结

多线程编程的核心就三件事：

创建与回收：pthread_create/pthread_join
数据保护：互斥锁pthread_mutex_lock/unlock
死锁避免：固定加锁顺序、减小锁粒度、用 trylock

在嵌入式 Linux 中，线程是并行处理的主力。掌握互斥锁，你的程序才能在高并发下稳如磐石。

嵌入式多线程开发：pthread 线程与互斥锁实战