重温并发任务:Linux 多线程同步利器互斥锁

typedef union{  struct __pthread_mutex_s __data;  char __size[__SIZEOF_PTHREAD_MUTEX_T];  long int __align;} pthread_mutex_t;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

#include <stdio.h>#include <stdlib.h>#include <pthread.h>int balance = 1000;pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;void* withdraw(void *arg) {    int amount = *(int*)arg;    pthread_mutex_lock(&lock); // 1. 加锁    int temp = balance;    temp -= amount;    usleep(1000); // 模拟处理耗时，如果不加锁，这里肯定会乱    balance = temp;    printf("取款 %d, 剩余余额: %d\n", amount, balance);    pthread_mutex_unlock(&lock); // 2. 解锁    return NULL;}int main() {    pthread_t t1, t2;    int a1 = 200, a2 = 300;    pthread_create(&t1, NULL, withdraw, &a1);    pthread_create(&t2, NULL, withdraw, &a2);    pthread_join(t1, NULL);    pthread_join(t2, NULL);    printf("最终余额: %d (应该是 500)\n", balance);    return 0;}

示例 2：多把锁的顺序（防止死锁）

死锁是线程编程的大坑。这个例子展示了“固定加锁顺序”这一黄金法则。

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>pthread_mutex_t lock_a = PTHREAD_MUTEX_INITIALIZER;pthread_mutex_t lock_b = PTHREAD_MUTEX_INITIALIZER;// 线程1：先锁 A，再锁 Bvoid* worker1(void *arg) {    printf("[线程1] 准备拿锁 A...\n");    pthread_mutex_lock(&lock_a);    printf("[线程1] 拿到锁 A，干活中...\n");    sleep(1);    printf("[线程1] 准备拿锁 B...\n");    pthread_mutex_lock(&lock_b); // 如果这里乱序去抢别的锁，可能死锁    printf("[线程1] 拿到锁 B，干活中...\n");    sleep(1);    pthread_mutex_unlock(&lock_b);    pthread_mutex_unlock(&lock_a);    printf("[线程1] 完工\n");    return NULL;}// 线程2：也先锁 A，再锁 B (顺序一致，安全！)void* worker2(void *arg) {    printf("[线程2] 准备拿锁 A...\n");    pthread_mutex_lock(&lock_a);     printf("[线程2] 拿到锁 A，干活中...\n");    sleep(1);    printf("[线程2] 准备拿锁 B...\n");    pthread_mutex_lock(&lock_b);     printf("[线程2] 拿到锁 B，干活中...\n");    sleep(1);    pthread_mutex_unlock(&lock_b);    pthread_mutex_unlock(&lock_a);    printf("[线程2] 完工\n");    return NULL;}int main() {    pthread_t t1, t2;    pthread_create(&t1, NULL, worker1, NULL);    pthread_create(&t2, NULL, worker2, NULL);    pthread_join(t1, NULL);    pthread_join(t2, NULL);    printf("所有线程安全退出，无死锁\n");    return 0;}

实现「超时阻塞加锁」和「非阻塞加锁」，覆盖生产环境防卡死需求：

1. 1. 线程 1 用pthread_mutex_timedlock设置 3 秒超时，超时后执行兜底逻辑；
2. 2. 线程 2 用pthread_mutex_trylock非阻塞加锁，锁被占用时直接跳过；
3. 3. 严格遵守加解锁成对规则，无任何死锁风险。

完整代码

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>#include <time.h>#include <errno.h>pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;int g_data = 0;// 线程1：超时加锁（3秒超时）void* thread_timeout(void* arg){    struct timespec ts;    // 获取当前绝对时间 + 3秒超时    clock_gettime(CLOCK_REALTIME, &ts);    ts.tv_sec += 3;    printf("线程1：尝试加锁（超时3秒）...\n");    int ret = pthread_mutex_timedlock(&g_mutex, &ts);    if(ret == 0)    {        // 加锁成功        g_data = 100;        printf("线程1：加锁成功，设置data=%d\n", g_data);        sleep(5); // 持有锁5秒        pthread_mutex_unlock(&g_mutex);        printf("线程1：解锁完成\n");    }    else if(ret == ETIMEDOUT)    {        // 超时        printf("线程1：加锁超时（3秒），执行兜底逻辑\n");    }    else    {        printf("线程1：加锁失败，错误码=%d\n", ret);    }    return NULL;}// 线程2：非阻塞加锁void* thread_trylock(void* arg){    for(int i=0; i<10; i++)    {        int ret = pthread_mutex_trylock(&g_mutex);        if(ret == 0)        {            // 加锁成功            g_data += 10;            printf("线程2：加锁成功，data=%d\n", g_data);            pthread_mutex_unlock(&g_mutex);            break;        }        else if(ret == EBUSY)        {            // 锁被占用            printf("线程2：锁被占用，跳过本次（第%d次尝试）\n", i+1);            sleep(1);        }    }    return NULL;}int main(){    pthread_t tid1, tid2;    pthread_create(&tid1, NULL, thread_timeout, NULL);    sleep(1); // 让线程1先尝试加锁    pthread_create(&tid2, NULL, thread_trylock, NULL);    pthread_join(tid1, NULL);    pthread_join(tid2, NULL);    pthread_mutex_destroy(&g_mutex);    printf("主线程：最终data=%d\n", g_data);    return 0;}

运行结果

超时加锁避免线程永久阻塞，是生产环境防卡死的核心方案；非阻塞加锁适合「不希望线程等待」的场景，如实时任务。

七、pthread 互斥锁 的优缺点（客观全面，选型参考）

✅ 优点（核心优势，无可替代）

1. 1. 简单易用：接口少、逻辑清晰，新手 1 小时即可掌握核心用法，开发成本极低；
2. 2. 线程安全：加解锁是原子操作，内核级保障，能彻底解决竞态条件问题；
3. 3. 通用性强：适配所有共享资源保护场景，是线程同步的「通用解决方案」；
4. 4. 低开销：用户态实现为主，内核态切换开销极小，性能接近理论最优；
5. 5. 灵活可控：支持阻塞 / 非阻塞 / 超时三种加锁方式，适配所有业务场景；
6. 6. 生态完善：是条件变量、读写锁等高级同步机制的基础，兼容性无死角。

✅ 缺点（局限性，客观认知）

1. 1. 只能实现互斥，无法直接控制执行顺序：需配合条件变量才能实现线程有序执行；
2. 2. 存在死锁风险：多锁嵌套时若顺序不一致，极易触发死锁；
3. 3. 大粒度锁会降低并发性能：锁粒度太大导致多线程串行，失去并发优势；
4. 4. 阻塞时放弃 CPU：相比自旋锁，短时间锁竞争的切换开销稍高；
5. 5. 无法区分读写操作：多读少写场景下，并发性能不如读写锁。

✅ 优缺点总结

✔️ 互斥锁的优点是压倒性的：简单、安全、通用，是线程同步的「基石」，没有任何技术能替代；

✔️ 互斥锁的缺点都是可规避的：通过规范编码（如统一加锁顺序、减小锁粒度）、配合其他同步机制（如条件变量），能轻松解决所有局限性；

✔️ 结论：互斥锁是 Linux 线程开发「必学、必会、必用」的核心技术，没有之一。

全文核心总结（精华提炼，直击本质，背会即用）

1. 1. 互斥锁的核心是「排他性访问」，加解锁必须成对、同线程执行，锁粒度越小越好；
2. 2. 防死锁黄金法则：多锁嵌套统一加锁顺序，持有锁不调用阻塞接口，生产环境用超时加锁；
3. 3. 核心接口：初始化→加锁（阻塞 / 非阻塞 / 超时）→解锁→销毁，逻辑简单，固定范式；
4. 4. 最核心场景是保护全局变量 / 堆内存，其次是文件 / 设备资源、多锁嵌套、超时加锁；
5. 5. 互斥锁是基础，配合条件变量可实现有序执行，配合读写锁可优化多读场景性能；
6. 6. 优点是简单通用、线程安全，缺点是有死锁风险、无法直接控制执行顺序，整体瑕不掩瑜。