Linux：线程互斥，线程锁

Run_Teenage2026-05-07 15:59

一、进程线程间互斥相关概念

理解：共享资源

**临界资源：**多线程执行流被保护的共享的资源就叫做临界资源

临界区： 每个线程内部，访问临界资源的代码，就叫做临界区

**互斥：**任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用

**原子性（后面讨论如何实现）：**不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

二、互斥量 mutex

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。

但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

多个线程并发的操作共享变量，会带来一些问题。

下面看一个模拟抢票的案例：

4个线程同时抢票

cpp 复制代码 
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>

int ticket = 1000;
void* route(void* arg)
{
    char* id = (char*)arg;
    while(1)
    {
        if(ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket: %d \n", id, ticket);
            ticket--;
        }
        else
        {
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t t1, t2, t3, t4;

    pthread_create(&t1, NULL, route, (void*)"thread-1");
    pthread_create(&t2, NULL, route, (void*)"thread-2");
    pthread_create(&t3, NULL, route, (void*)"thread-3");
    pthread_create(&t4, NULL, route, (void*)"thread-4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    return 0;
}

运行结果：

bash 复制代码 
......
thread-2 sells ticket: 7 
thread-4 sells ticket: 6 
thread-3 sells ticket: 6 
thread-1 sells ticket: 4 
thread-2 sells ticket: 3 
thread-4 sells ticket: 2 
thread-3 sells ticket: 2 
thread-1 sells ticket: 0 
thread-2 sells ticket: -1 
thread-4 sells ticket: -2

会发现，票数怎么是负的呢？？

  1. if 语句判断条件为真以后，代码可以并发的切换到其他线程
  2. usleep 这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段
  3. --ticket 操作本身就不是一个原子操作
  4. 也就是说这一段代码被重入了，当一个线程进入**if**判断后就被切走了，其他线程会进入route函数，将票抢完，但是，被切走的线程回来后，继续执行后面的代码（因为已经判断了是有票的），所以就会出现负数的票

取出 ticket-- 部分的汇编代码

bash 复制代码 
objdump -d a.out > test.objdump
bash 复制代码 
152  40064b:  8b 05 e3 04 20 00    mov    0x2004e3(%rip),%eax        # 600b34 <ticket>
153  400651:  83 e8 01             sub    $0x1,%eax
154  400654:  89 05 da 04 20 00    mov    %eax,0x2004da(%rip)        # 600b34 <ticket>

--操作并不是原子操作，而是对应三条汇编指令：

  • load：将共享变量 ticket 从内存加载到寄存器中
  • update：更新寄存器里面的值，执行 - 1 操作
  • store：将新值，从寄存器写回共享变量 ticket 的内存地址

要解决以上问题，需要做到三点:

  1. 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
  2. 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
  3. 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁。Linux 上提供的这把锁叫互斥量。

三、互斥量的接口

1.初始化互斥量

初始化互斥量有两种方法：

方法 1，静态分配：

cpp 复制代码 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

方法 2，动态分配：

cpp 复制代码 
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

参数：

mutex：要初始化的互斥

attr：NULL

2.销毁互斥量

销毁互斥量需要注意：

  • 使用 PTHREAD_MUTEX_INITIALIZER 初始化的互斥量不需要销毁
  • 不要销毁一个已经加锁的互斥量
  • 已经销毁的互斥量，要确保后面不会有线程再尝试加锁
cpp 复制代码 
int pthread_mutex_destroy(pthread_mutex_t *mutex);

3. 互斥量加锁和解锁

复制代码 
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值： 成功返回0，失败返回错误号

调用 pthread_lock 时，可能会遇到以下情况：

  • 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
  • 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_lock调用会陷入阻塞（执行流被挂起），等待互斥量解锁。

用锁对上面的售票系统进行修改

cpp 复制代码 
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>

int ticket = 1000;
pthread_mutex_t mutex;
void* route(void* arg)
{
    char* id = (char*)arg;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket: %d \n", id, ticket);
            ticket--;
            pthread_mutex_unlock(&mutex);
        }
        else
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t t1, t2, t3, t4;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&t1, NULL, route, (void*)"thread-1");
    pthread_create(&t2, NULL, route, (void*)"thread-2");
    pthread_create(&t3, NULL, route, (void*)"thread-3");
    pthread_create(&t4, NULL, route, (void*)"thread-4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

运行结果：

bash 复制代码 
......
thread-2 sells ticket: 4 
thread-2 sells ticket: 3 
thread-2 sells ticket: 2 
thread-2 sells ticket: 1 
zhangsan@hcss-ecs-f571:~/learn_-linux/thread/test_pthread_mutex$

思考：

1.加锁，解锁在代码的什么地方比较合适？？

加锁会导致效率降低，所以加锁的粒度必须足够细

（加锁相当于把并行的线程变成了串行的线程）

2.mutex是共享资源，他保护别人，谁来保护它？？

lock && unlock被设计成为了原子的！！

3.会不会一些线程遵守加锁和解锁，一些线程不遵守？

不会。对临界资源进行保护，加锁和解锁是所有相关线程的共识！
经过上面的例子，已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题

为了实现互斥锁操作，大多数体系结构都提供了**swap或exchange指令**，该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性，即使是多处理器平台，访问内存的总线周期也有先后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。

四、理解加锁和解锁的过程：

lock和unlock的伪代码：

加锁的过程：

  1. 线程把 al 寄存器置为0
  2. 交换al与mutex，交换完成：al 是 1， mutex 是 0
  3. al > 0 加锁完成，返回函数，继续执行函数的代码

已经加锁，又来一个线程：

  1. 线程把 al 寄存器置为0
  2. 交换al与mutex，交换完成：al 是 0，mutex 是 0 （因为锁已经被拿走了）
  3. al 是 0 挂起等待，当收到时钟中断时（被唤醒），goto去执行lock代码

解锁过程：

  1. 将mutex的1还回去，即置1
  2. 唤醒被挂起的线程
  3. 返回函数

五、互斥量的封装

1.常规版本

cpp 复制代码 
#pragma once
#include <iostream>
#include <pthread.h>

class Mutex
{
public:
    Mutex()
    {
        pthread_mutex_init(&_lock, NULL);
    }
    void Lock()
    {
        pthread_mutex_lock(&_lock);
    }
    void Unlock()
    {
        pthread_mutex_unlock(&_lock);
    }
    ~Mutex()
    {
        pthread_mutex_destroy(&_lock);
    }
private:
    pthread_mutex_t _lock;
};

使用：

cpp 复制代码 
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include "Mutex.hpp"

int ticket = 1000;
pthread_mutex_t mutex;
Mutex lock;
void* route(void* arg)
{
    char* id = (char*)arg;
    while(1)
    {
        // pthread_mutex_lock(&mutex);
        lock.Lock();
        if(ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket: %d \n", id, ticket);
            ticket--;
            // pthread_mutex_unlock(&mutex);
            lock.Unlock();
        }
        else
        {
            // pthread_mutex_unlock(&mutex);
            lock.Unlock();
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t t1, t2, t3, t4;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&t1, NULL, route, (void*)"thread-1");
    pthread_create(&t2, NULL, route, (void*)"thread-2");
    pthread_create(&t3, NULL, route, (void*)"thread-3");
    pthread_create(&t4, NULL, route, (void*)"thread-4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

2.RAII风格的互斥锁

cpp 复制代码 
class LockGuard
{
public:
    LockGuard(Mutex &mutex):_mutex(mutex)
    {
        _mutex.Lock();
    }
    ~LockGuard()
    {
        _mutex.Unlock();
    }

private:
    Mutex &_mutex;
};

使用：

cpp 复制代码 
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include "Mutex.hpp"

int ticket = 1000;
pthread_mutex_t mutex;
Mutex lock;
void *route(void *arg)
{
    char *id = (char *)arg;
    while (1)
    {
        // 临界区！
        {
            LockGuard lockguard(lock);
            // pthread_mutex_lock(&mutex);
            // lock.Lock();
            if (ticket > 0)
            {
                usleep(1000);
                printf("%s sells ticket: %d \n", id, ticket);
                ticket--;
                // pthread_mutex_unlock(&mutex);
                // lock.Unlock();
            }
            else
            {
                // pthread_mutex_unlock(&mutex);
                // lock.Unlock();
                break;
            }
        }
    }
    return nullptr;
}

int main()
{
    pthread_t t1, t2, t3, t4;
    // pthread_mutex_init(&mutex, NULL);
    pthread_create(&t1, NULL, route, (void *)"thread-1");
    pthread_create(&t2, NULL, route, (void *)"thread-2");
    pthread_create(&t3, NULL, route, (void *)"thread-3");
    pthread_create(&t4, NULL, route, (void *)"thread-4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    // pthread_mutex_destroy(&mutex);
    return 0;
}

RAII 风格的互斥锁，C++11 也有：

cpp 复制代码 
std::mutex mtx;
std::lock_guard<std::mutex> guard(mtx);
相关推荐
小小de风呀1 小时前
de风——【从零开始学C++】（四）：类和对象（下）
开发语言·c++·算法
覆东流1 小时前
第10天：python元组
开发语言·后端·python
CSCN新手听安1 小时前
【Qt】系统相关（一）内容简介，事件概念，事件的处理
开发语言·c++·qt
不想写代码的星星1 小时前
重识 std::tuple：一个被低估的编译期异构容器
开发语言·c++
DigitalOcean1 小时前
DigitalOcean VPC 网络故障排查 Runbook 实战指南
运维·服务器
techdashen2 小时前
用 Rust 写生产级服务要踩多少坑——Cloudflare 把答案做成了一个开源库
开发语言·rust·开源
嵌入式×边缘AI：打怪升级日志2 小时前
Tina SDK Linux Kernel 基本使用（实战篇：为开发板添加用户按键驱动支持）
linux·运维·服务器
码界奇点2 小时前
基于Python的微信公众号爬虫系统设计与实现
开发语言·爬虫·python·毕业设计·web·源代码管理
2401_846339562 小时前
Vue 3 中集成 Three.js 场景的完整实现指南
jvm·数据库·python
热门推荐
01要裂开了！ChatGPT要手机号验证了？注册Codex要求验证电话号码怎么办？2026年登陆Codex要手机号验证的解决办法02GitHub 镜像站点03Codex 接入 DeepSeek API 完整配置文档04零基础教你claude code 接入 deepseek V405Linux 核弹级高危漏洞 CVE-2026-31431 完整修复指南06CVE-2026-31431 (Copy Fail) 漏洞复现与验证记录07裂开！ChatGPT 居然开始要手机号验证，附详细解决方法08CC-Switch & Claude 基于 Linux 服务器安装使用指南09【AI】2026 年具身智能模型和世界模型总结102026 年 AI 辅助编程工具全景对比：Copilot、Cursor、Claude Code 与 Codex 深度解析