线程封装与互斥

熬夜苦读学习2025-05-24 14:34

目录

线程互斥

进程线程间的互斥相关背景概念

互斥量mutex

互斥量的接口

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

销毁互斥量

互斥量加锁和解锁

改进售票系统

互斥量实现原理探究

互斥量的封装

线程互斥

进程线程间的互斥相关背景概念

  • 临界资源：多线程执行流共享的资源就叫做临界资源
  • 临界区：每个线程内部，访问临界资源的代码，就叫做临界区
  • 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
  • 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

互斥量mutex

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量

归属单个线程，其他线程无法获得这种变量。但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。多个线程并发的操作共享变量，会带来一些问题

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
int ticket = 100;
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;
}

上述代码用多线程模拟抢票，但是为什么抢到负数？？？

1. if 语句判断条件为真以后，代码可以并发的切换到其他线程

if判断只是对票数进行判断，在cpu内进行逻辑运算，当某个线程刚载入cpu内判断时间片到了就被替换成下一个线程，这样的线程不止一个，再次调度回来时才对--ticket，调度多了，连着减，减成了负数
2.usleep 这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码
段

计算机的运行速度很快，1毫秒内抢票很快，多个线程进入该代码陷入内核线程又被挂起
3.--ticket 操作本身就不是一个原子操作

在计算机内部，--tecket简单分为三步骤：操作要把数据从内存加载到cpu，然后cpu进行计算，最后再把结束写回内存。宏观上是cpu在进行调度，假如cpu调度时时间片到了，进程阻塞挂起时，把该线程的上下文保存，在下一次调度时拷贝回继续运行，在此期间还有别的线程在抢票，不断得对ticket操作，ticket不断减少，但是上一次还没有调度完的线程继续切回来，上一次上下文运行的结果又写回内存，此时ticket的数值反而又会增大

全局资源没有被保护，可能会有并发问题，也就是线程安全。要解决以上问题，需要做到三点：

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

要做到这三点，本质上就是需要一把锁，在内核态返回用户态时进行检查。Linux上提供的这把锁叫互斥量。

互斥量的接口

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

定义锁

方法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

销毁互斥量

释放锁

cpp 复制代码 
int pthread_mutex_destroy(pthread_mutex_t *mutex)；

销毁互斥量需要注意：

  • 使用PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁，全局的锁程序结束自动释放，局部锁才需要手动释放
  • 不要销毁一个已经加锁的互斥量
  • 已经销毁的互斥量，要确保后面不会有线程再尝试加锁

互斥量加锁和解锁

cpp 复制代码 
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

调用 pthread_ lock 时，可能会遇到以下情况:

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

申请锁是为了保护临界资源的安全，多线程竞争申请锁，首先多进程就要先看到锁，锁本身就是临界资源，所以申请锁的过程，必须是原子的，成功就继续向后访问临界资源，申请失败，阻塞挂起申请执行流，等待下一次调度唤醒，锁本身的能力本质是将临界代码区由并行转而为串行，加锁之后在临界区内部，允许线程切换，即使切出去了锁还没释放，也得等我执行完代码才会释放锁，其他线程拿到锁，开锁进入临界区

改进售票系统

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <iostream>
#include <string.h>
int ticket = 100;

class ThreadDate
{
public:
    ThreadDate(const std::string &n, pthread_mutex_t &lock)
        : name(n), lockp(&lock) {}
    ~ThreadDate() {}
    std::string name;
    pthread_mutex_t *lockp;
};
void *route(void *arg)
{
    ThreadDate *td = static_cast<ThreadDate *>(arg);
    while (1)
    {
        pthread_mutex_lock(td->lockp); // 加锁
        if (ticket > 0)
        {
            usleep(1000);                                             // 模拟抢票
            printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票
            ticket--;
            pthread_mutex_unlock(td->lockp); // 用完解锁
        }
        else
        {
            pthread_mutex_unlock(td->lockp); // 票抢完了，解锁退出，否则线程一直阻塞
            break;
        }
    }
    return nullptr;
}
int main()
{
    pthread_mutex_t lock;
    pthread_mutex_init(&lock, nullptr); // 初始化锁
    pthread_t t1, t2, t3, t4;

    ThreadDate *td1 = new ThreadDate("thread 1", lock);
    pthread_create(&t1, NULL, route, (void *)td1);

    ThreadDate *td2 = new ThreadDate("thread 2", lock);
    pthread_create(&t2, NULL, route, (void *)td2);

    ThreadDate *td3 = new ThreadDate("thread 3", lock);
    pthread_create(&t3, NULL, route, (void *)td3);

    ThreadDate *td4 = new ThreadDate("thread 4", lock);
    pthread_create(&t4, NULL, route, (void *)td4);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    pthread_mutex_destroy(&lock); // 销毁锁
    return 0;
}

全局锁

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <iostream>
#include <string.h>
int ticket = 100;

pthread_mutex_t glock =PTHREAD_MUTEX_INITIALIZER;//全局初始化
class ThreadDate
{
public:
    ThreadDate(const std::string &n, pthread_mutex_t &lock)
        : name(n), lockp(&lock) {}
    ~ThreadDate() {}
    std::string name;
    pthread_mutex_t *lockp;
};
void *route(void *arg)
{
    ThreadDate *td = static_cast<ThreadDate *>(arg);
    while (1)
    {
        pthread_mutex_lock(&glock); // 加锁
        if (ticket > 0)
        {
            usleep(1000);                                             // 模拟抢票
            printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票
            ticket--;
            pthread_mutex_unlock(&glock); // 用完解锁
        }
        else
        {
            pthread_mutex_unlock(&glock);  // 票抢完了，解锁退出，否则线程一直阻塞
            break;
        }
    }
    return nullptr;
}
int main()
{
    pthread_mutex_t lock;
    pthread_t t1, t2, t3, t4;

    ThreadDate *td1 = new ThreadDate("thread 1", lock);
    pthread_create(&t1, NULL, route, (void *)td1);

    ThreadDate *td2 = new ThreadDate("thread 2", lock);
    pthread_create(&t2, NULL, route, (void *)td2);

    ThreadDate *td3 = new ThreadDate("thread 3", lock);
    pthread_create(&t3, NULL, route, (void *)td3);

    ThreadDate *td4 = new ThreadDate("thread 4", lock);
    pthread_create(&t4, NULL, route, (void *)td4);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    
    return 0;
}

互斥量实现原理探究

锁的原理

1硬件实现：关闭时钟中断

2.软件实现：为了实现互斥锁操作，大多数体系结构都提供了swap或exchange指令，该指令的作用是把寄存器和内存单元的数据相交换

经过上面的例子，大家已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另⼀个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码改一下

锁的初始化把mutex初始化为1，申请锁的时候先把0写进al，然后交换 al和mutex锁的数据，此时%al里面是1，mutex是0，申请锁成功在返回，然后访问临界资源，时间片到了，挂起放到调度队列里了，也没有关系，锁还没有释放，上下文数据被带走了。其他的线程都执行move，寄存器和mutex内都是0，交换完还是0，全部进了下一个调度队列，直到拥有锁的线程执行完释放锁，把1写回mutex，才能轮到下一个线程申请锁成功，如果没有申请成功，锁被占用了，执行else挂起等待，等拥有锁的释放锁后，才可以执行后面的代码申请锁区访问临界支援，说白了，谁交换走了1，谁就持有锁，谁就有优先访问临界资源的权力

互斥量的封装

1.0

cpp 复制代码 
//Mutex.hpp


#include <pthread.h>
#include <iostream>
namespace MutexModule
{
    class Mutex
    {
    public:
        Mutex()
        {
            pthread_mutex_init(&_mutex, nullptr);
        }

        void Lock()
        {
            int n = pthread_mutex_lock(&_mutex);
            (void)n;
        }
        void Unlock()
        {
            int n = pthread_mutex_unlock(&_mutex);
            (void)n;
        }
        ~Mutex()
        {
            pthread_mutex_destroy(&_mutex);
        }

    private:
        pthread_mutex_t _mutex;
    };
}
cpp 复制代码 
//TextMutex.cc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <iostream>
#include <string.h>
#include "Mutex.hpp"
using namespace MutexModule;
int ticket = 100;

pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER; // 全局初始化
class ThreadDate
{
public:
    ThreadDate(const std::string &n, Mutex &lock)
        : name(n), lockp(&lock) {}
    ~ThreadDate() {}
    std::string name;
    Mutex *lockp;
};
void *route(void *arg)
{
    ThreadDate *td = static_cast<ThreadDate *>(arg);
    while (1)
    {
        td->lockp->Lock(); // 加锁
        if (ticket > 0)
        {
            usleep(1000);                                             // 模拟抢票
            printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票
            ticket--;
            td->lockp->Unlock(); // 用完解锁
        }
        else
        {
            td->lockp->Unlock();
            ; // 票抢完了，解锁退出，否则线程一直阻塞
            break;
        }
    }
    return nullptr;
}
int main()
{
    Mutex lock;
    pthread_t t1, t2, t3, t4;

    ThreadDate *td1 = new ThreadDate("thread 1", lock);
    pthread_create(&t1, NULL, route, (void *)td1);

    ThreadDate *td2 = new ThreadDate("thread 2", lock);
    pthread_create(&t2, NULL, route, (void *)td2);

    ThreadDate *td3 = new ThreadDate("thread 3", lock);
    pthread_create(&t3, NULL, route, (void *)td3);

    ThreadDate *td4 = new ThreadDate("thread 4", lock);
    pthread_create(&t4, NULL, route, (void *)td4);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    return 0;
}

2.0

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <iostream>
#include <string.h>
#include "Mutex.hpp"
using namespace MutexModule;
int ticket = 100;

pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER; // 全局初始化
class ThreadDate
{
public:
    ThreadDate(const std::string &n, Mutex &lock)
        : name(n), lockp(&lock) {}
    ~ThreadDate() {}
    std::string name;
    Mutex *lockp;
};
void *route(void *arg)
{
    ThreadDate *td = static_cast<ThreadDate *>(arg);
    while (1)
    {
        LockGuard guard(*td->lockp);
        if (ticket > 0)
        {
            usleep(1000);                                             // 模拟抢票
            printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票
            ticket--;
          
        }
        else
        {
            td->lockp->Unlock();
            break;
        }
    }
    return nullptr;
}
int main()
{
    Mutex lock;
    pthread_t t1, t2, t3, t4;

    ThreadDate *td1 = new ThreadDate("thread 1", lock);
    pthread_create(&t1, NULL, route, (void *)td1);

    ThreadDate *td2 = new ThreadDate("thread 2", lock);
    pthread_create(&t2, NULL, route, (void *)td2);

    ThreadDate *td3 = new ThreadDate("thread 3", lock);
    pthread_create(&t3, NULL, route, (void *)td3);

    ThreadDate *td4 = new ThreadDate("thread 4", lock);
    pthread_create(&t4, NULL, route, (void *)td4);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    return 0;
}
cpp 复制代码 
#include <pthread.h>
#include <iostream>
namespace MutexModule
{
    class Mutex
    {
    public:
        Mutex()
        {
            pthread_mutex_init(&_mutex, nullptr);
        }

        void Lock()
        {
            int n = pthread_mutex_lock(&_mutex);
            (void)n;
        }
        void Unlock()
        {
            int n = pthread_mutex_unlock(&_mutex);
            (void)n;
        }
        ~Mutex()
        {
            pthread_mutex_destroy(&_mutex);
        }

    private:
        pthread_mutex_t _mutex;
    };
    class LockGuard
    {
        public:
        LockGuard(Mutex &mutex):_mutex(mutex)
        {
        _mutex.Lock();
        }
        ~LockGuard()
        {
            _mutex.Unlock();
        }
        private:
        Mutex &_mutex;
    };
}
相关推荐
0xCC说逆向9 分钟前
Windows逆向工程提升之IMAGE_EXPORT_DIRECTORY
开发语言·数据结构·windows·安全·网络安全·pe结构·逆向工程
带电的小王10 分钟前
C++：动态刷新打印内容
开发语言·c++
不会c嘎嘎11 分钟前
linux初识--基础指令
linux·运维·服务器
飞飞98711 分钟前
spring mvc
java·服务器·前端
贺函不是涵12 分钟前
【沉浸式求职学习day47】【JSP详解】
java·开发语言·学习
网硕互联的小客服14 分钟前
如何排查服务器 CPU 温度过高的问题并解决？
linux·运维·服务器·网络·安全
南方以南_20 分钟前
VMware虚拟机突然无法ssh连接
运维·ssh
满怀101527 分钟前
【Python正则表达式终极指南】从零到工程级实战
开发语言·python·正则表达式·自动化·文本处理·数据清晰
草莓熊Lotso39 分钟前
【自定义类型-结构体】--结构体类型，结构体变量的创建和初始化，结构体内存对齐，结构体传参，结构体实现位段
c语言·开发语言·经验分享·笔记·其他
旋风菠萝1 小时前
八股--SSM(2)
java·开发语言·数据库·八股·八股文·复习
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06DeepSeek各版本说明与优缺点分析07Android Termux 安装Kali Linux 或 kali Nethunter史诗级详细教程08VMware虚拟机安装Win7专业版保姆级教程（附镜像包）09Coze扣子平台完整体验和实践（附国内和国际版对比）10【解决】Android Gradle Sync 报错 Could not read workspace metadata