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);
相关推荐
wtblszn3 小时前
自动化包装生产线设备可视化管理方案
运维·自动化
落魄实习生4 小时前
Agent Scope Java 2.x 系列【7】工具使用
java·开发语言·ai
心之语歌4 小时前
Tkinter 画布基本梳理
运维·服务器·python
Shulex4 小时前
面向跨境电商多渠道消息系统的技术架构：亚马逊站内信合规对接与自动化执行链路设计
运维·架构·自动化
茉莉玫瑰花茶5 小时前
GO [ 方法 ]
开发语言·后端·golang
狗凯之家源码网5 小时前
微博图床 PHP 系统搭建与实战应用指南
android·开发语言·php
bloglin999995 小时前
vmware部署centos7启动docker容器后无法访问服务
运维·docker·容器
杨云龙UP6 小时前
TDengine 3.4.2.8 Community 三节点三副本生产集群部署实战（DNode/MNode/taosAdapter/Explorer）
大数据·linux·运维·数据库·tdengine·时序库
梦帮科技6 小时前
领域认知知识库图谱注入：从双式记账图网络到高质量问答对自动化合成流水线
运维·网络·数据库·人工智能·矩阵·架构·自动化
乌暮6 小时前
深入理解 Java 泛型：把「万能盒子」用对、用稳
java·开发语言·后端·学习
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03历年考研数学一、数学二、数学三真题试卷及答案PDF04Telegram APK 下载安装完整指南 — 2026年最新05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接062026 爱知・名古屋亚运会怎么看？直播平台+赛程安排分享07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）08微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新09给AI一张“业务概念地图“：本体如何从哲学走向企业智能10jev-ultrafast 深度解析：7 秒订机票的浏览器 Agent 是如何炼成的