【Linux】线程互斥之线程加锁

一、锁的定义

线程加锁是在多线程编程环境中，为了确保在同一时刻只有一个线程能够访问特定的共享资源或执行特定的代码段，而采取的一种同步手段，通过在需要保护的资源或代码段前获取锁，在访问完成后释放锁，来实现对共享资源的互斥访问

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

返回值：成功返回0，失败返回非零错误码 mutex：表示要初始化的互斥锁，pthread_mutex_t是POSIX线程库中定义的互斥锁类型 attr：包含互斥锁的属性，设置为NULL表示使用默认属性

#include int pthread_mutex_destroy(pthread_mutex_t *mutex);

返回值：成功返回0，失败返回非零错误码 mutex：表示要销毁的互斥锁

#include int pthread_mutex_lock(pthread_mutex_t *mutex);

返回值：成功返回0，失败返回非零错误码 mutex：表示要加锁的互斥锁

#include int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值：成功返回0，失败返回非零错误码 mutex：表示要解锁的互斥锁

#include #include #include #include #include using namespace std;//定义一个全局锁就可以不需要初始化和销毁锁的函数了//pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;#define NUM 4//共500张票int tickets = 500;class ThreadInfo{public:    ThreadInfo(const string &threadname, pthread_mutex_t *lock)    :threadname_(threadname)    ,lock_(lock)    {}public:    string threadname_;    pthread_mutex_t *lock_;};void *GrabTickets(void *args){    ThreadInfo *ti = static_cast(args);    string name(ti->threadname_);    while(true)    {        pthread_mutex_lock(ti->lock_); // 加锁        if(tickets > 0)        {            usleep(10000);            printf("%s get a ticket: %d\n", name.c_str(), tickets);            tickets--;            pthread_mutex_unlock(ti->lock_); // 解锁        }        else         {            pthread_mutex_unlock(ti->lock_); // 解锁            break;        }        //这里上面的代码        usleep(13); // 用休眠来模拟抢到票的后续动作    }    printf("%s quit...\n", name.c_str());}int main(){    pthread_mutex_t lock; // 定义互斥锁    pthread_mutex_init(&lock, nullptr); // 初始化互斥锁    vector tids;    vector tis;    for(int i = 1; i <= NUM; i++)    {        pthread_t tid;        ThreadInfo *ti = new ThreadInfo("Thread-"+to_string(i), &lock);        pthread_create(&tid, nullptr, GrabTickets, ti);        tids.push_back(tid);        tis.push_back(ti);    }    // 等待所有线程    for(auto tid : tids)    {        pthread_join(tid, nullptr);    }    // 释放资源    for(auto ti : tis)    {        delete ti;    }// 销毁互斥锁    pthread_mutex_destroy(&lock);         return 0;}

这样就不会出现好多线程抢到一张票或者抢到不存在的票的问题了

我们将上方代码中表示抢到票后续动作的休眠代码注释掉再次执行程序我们会发现，都是线程1抢的票，多次执行代码之后发现这是概率性问题，但是在抢票的时候，有一段时间的票都是一个线程抢到的，我们预想的应该是几乎平均分配的样子

这说明了几个问题： 第一，线程对于锁的竞争能力不同，一定有一个首先抢到锁的线程 第二，一般来说，刚解锁再去抢锁的更容易一些，类似于上面的结果，一直是线程1在抢票

对于上面第二个问题来说，我们有处理方法，这种方法就是同步，同步可以让所有的线程按照一定的顺序获取锁

对于其他线程来讲，一个线程要么获取到了锁，要么释放了锁，当前进程访问临界区的过程对于其他线程是原子的

有道智云AI开放平台

有道智云AI开放平台

下载

在加锁期间，即解锁之前，是可以发生线程切换的，线程切换的时候是拿着锁走的，被锁起来的内容其他线程也是访问不到临界区的的，在该线程再次切换回来的时候，恢复线程上下文继续访问临界区代码

加锁的本质就是用时间来换取安全，我们知道在加锁后，临界区的代码只能由一个线程执行，如果是并发执行，至少时间要缩短5倍，但是锁给我们消除了安全隐患，即可能出现的++、--的隐患

加锁的表现就是线程对于临界区代码串行执行，一条线从上到下

我们加锁的原则就是尽量保证临界区的代码要少一些，可以使单线程执行的代码量更小，多线程综合处理的代码量更大，提高效率

锁的本身是共享资源，所以加锁和解锁本身就被设计成为了原子性操作（加锁和解锁通过硬件提供的原子指令，结合操作系统内核态的底层同步原语支持以及库层面的合理封装，来确保操作的原子性），这样可以确保在多线程环境下对共享资源加锁和解锁操作的完整性与一致性，避免因多线程并发干扰导致锁状态异常，进而保障线程安全和数据的正确性

下面来看一下加锁解锁对应的汇编指令，我们说，一条汇编指令就是原子性的

首先al寄存器中的数字为0时，代表锁已被拿走，为非零（一般为1）时，代表锁当前空闲，可以上锁

#pragma once#include //简单的封装了一下函数，用的时候方便一些class Mutex{public:    Mutex(pthread_mutex_t *lock)    :lock_(lock)    {}    void Lock()    {        pthread_mutex_lock(lock_);    }    void Unlock()    {        pthread_mutex_unlock(lock_);    }private:    pthread_mutex_t *lock_;};class LockGuard{public:    LockGuard(pthread_mutex_t *lock)    :mutex_(lock)    {        mutex_.Lock(); // 对象创建的时候加锁    }    ~LockGuard()    {        mutex_.Unlock(); // 对象销毁的时候解锁    }private:    Mutex mutex_;};

#include #include #include #include #include #include "LockGuard.hpp"using namespace std;#define NUM 4int tickets = 500; //全局变量定义锁pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;class ThreadInfo{public:    ThreadInfo(const string &threadname)        : threadname_(threadname)public:    string threadname_;};void *GrabTickets(void *args){    ThreadInfo *ti = static_cast(args);    string name(ti->threadname_);    while (true)    {        {            LockGuard lockguard(&lock); // RAII 风格的锁            if (tickets > 0)            {                usleep(10000);                printf("%s get a ticket: %d\n", name.c_str(), tickets);                tickets--;            }            else            {                break;            }        }        usleep(13); // 用休眠来模拟抢到票的后续动作    }    printf("%s quit...\n", name.c_str());}int main(){    vector tids;    vector tis;    for (int i = 1; i <= NUM; i++)    {        pthread_t tid;        ThreadInfo *ti = new ThreadInfo("Thread-" + to_string(i));        pthread_create(&tid, nullptr, GrabTickets, ti);        tids.push_back(tid);        tis.push_back(ti);    }    // 等待所有线程    for (auto tid : tids)    {        pthread_join(tid, nullptr);    }    // 释放资源    for (auto ti : tis)    {        delete ti;    }    pthread_mutex_destroy(&lock);    return 0;}

这里封装的锁是RAII风格的锁，RAII风格是一种在 C++ 等编程语言中利用对象的构造和析构函数来自动管理资源的技术，确保资源在对象创建时获取，在对象生命周期结束时自动释放，以防止资源泄漏并简化资源管理

今日分享就到这里了~