【Linux】线程互斥和同步

🕗 发布于 2024-07-22 18:36 开发语言 linux c++ 多线程

线程互斥

互斥量mutex

为了解决多个线程并发的操作共享变量所带来的问题，本质上就是需要一把锁，Linux中提供的锁被称为互斥量。

互斥量的接口

初始化互斥量

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

方法一：静态分配：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

方法二：动态分配：

int pthread_mutex_init(pthread_mutex_t *restrict mutex,

                                        const pthread_mutexattr_t *restrict attr);

        参数：

                mutex：要初始化的互斥量

                attr：NULL

销毁互斥量

销毁互斥量时需要注意：

使用PTHREAD_MUTEX_INITIALIZER初始化的互斥量不需要销毁。
不要销毁一个已经加锁的互斥量。
已经销毁的互斥量，要确保后面不会有线程再尝试加锁。

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

互斥量加锁/解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

……

int pthread_mutex_unlock(pthread_mutex_t *mutex);

//返回值 : 成功返回 0, 失败返回错误号

调用 pthread_mutex_lock 时，会有以下几种情况：

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

可重入VS线程安全

概念

线程安全：多个线程并发同一段代码的时候，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，就会出现该问题。

重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数再重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入，否则就是不可重入函数。

可重入与线程安全的联系

函数是可重入的，那就是线程安全的。
线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
如果一个函数中有全局变量，那么这个函数既不是线程安全的也不是可重入的。

可重入与线程安全的区别

可重入函数是线程安全函数的一种
线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

加锁的本质：用时间换取安全

加锁的表现：线程对于临界区代码串行执行

加锁原则：尽量的保证临界区代码，越少越好

在纯互斥的环境下，如果锁分配不够合理，容易导致其他线程的饥饿问题！当然不是说只要有互斥，必有饥饿。适合纯互斥的场景，就用互斥。

让所有的线程，获取锁按照一定的顺序，也就是按照一定的顺序获取资源--同步。

死锁

死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。

只有一把锁也是会出现死锁的情况，一个线程再持有锁的情况下，再申请锁，就会出现死锁。

死锁的四个必要条件

互斥条件：一个资源每次只能被一个执行流使用。（前提）
请求与保持条件：一个执行流因请求资源而阻塞时，对已经获得的资源保持不放。（原则1）
不剥夺条件：一个执行流已经获得的资源，再未使用完之前，不能强行剥夺。（原则2）
循环等待条件：若干个执行流之间形成一种头尾相接的循环等待资源的关系。（重要条件）

避免死锁

破坏死锁的四个必要条件（请求与保持/不剥夺/循环等待）
加锁顺序一致
避免锁未释放的场景
资源一次性分配

避免死锁的算法

死锁检测算法
银行家算法

线程同步

条件变量

当一个线程互斥地访问某个变量时，它可能发现在其它线程改变状态之前，它什么也做不了。
例如一个线程访问队列时，发现队列为空，它只能等待，只到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量。

条件变量函数初始化

int pthread_cond_init(pthread_cond_t *restrict cond,

                                const pthread_condattr_t *restrict attr);

参数：

           cond：要初始化的条件变量

           attr：NULL（条件变量的属性）

销毁

int pthread_cond_destroy(pthread_cond_t *cond)

等待条件满足

int pthread_cond_wait(pthread_cond_t *restrict cond,

                                pthread_mutex_t *restrict mutex);

参数：

        cond：要在这个条件变量上等待

        mutex：互斥量

pthread_cond_wait让线程等待的时候，会让线程释放持有的锁，也就是在等待之前，线程要先持有锁！！

唤醒等待

int pthread_cond_broadcast(pthread_cond_t *cond); //唤醒在等待队列的全部线程

int pthread_cond_signal(pthread_cond_t *cond);//唤醒等待队列的第一个线程

CP问题

consumer producter

在编写生产消费模型前，我们先梳理一下两者涉及的概念

三种关系

生产者 VS 生产者互斥关系

消费者 VS 消费者互斥关系

生产者 VS 消费者互斥关系，只有互斥可能会导致消费者饥饿问题，所有还要有同步

两种角色

生产者和消费者

一个交易场所

特定结构的内存空间

优点

支持忙闲不均
生产和消费进行解耦

代码实现

blockqueue.hpp

#pragma once

#include <iostream>
#include <queue>
#include <pthread.h>
template <class T>
class BlockQueue
{
    static const int defaultnum = 5;
    static int data=0;
public:
    BlockQueue(int maxcap = defaultnum)
        :maxcap_(maxcap)
    {
        phtread_mutex_init(&mutex_,nullptr);
        pthread_cond_init(&c_cond_,nullptr);
        pthread_cond_init(&p_cond_,nullptr);

        low_water_ = maxcap_/3;
        high_water_ = (maxcap_*2)/3;
    }

    T &pop()
    {
        pthread_mutex_lock(&mutex_);
        //这里有while循环防止伪唤醒的情况
        while(q.size() == 0)
        {
            //没有东西了，消费者去排队挂起
            pthread_cond_wait(&c_cond_,&mutex_);
        }
        T out = q.pop();
        //消费了一个，一定有空间给生产者生产，所以这里唤醒生产者
        if(q.size()<=low_water_)
            pthread_cond_signal(&p_cond_);
        pthread_mutex_unlock(&mutex_);

        return out;
    }
    void push(const T &in)
    {
        pthread_mutex_lock(&mutex_);
        //这里有while循环防止伪唤醒的情况
        while(q.size() == maxcap_)
        {
            //1.调用的时候自动释放锁
            //2.生产的到达极值不能继续生产了
            pthread_cond_wait(&p_cond_,&mutex_);
        }
        //1.队列没满 2.被唤醒
        q.push(in);
        //生产了一个，可以通知消费者来消费了
        if(q.size()>=high_water_)
            pthread_cond_signal(&c_cond_);
        pthread_mutex_unlock(&mutex_)
    }
    ~BlockQueue()
    {
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&c_cond_);
        pthread_cond_destroy(&p_cond_);

    }
private:
    std::queue<T> q_;
    int maxcap_;        //极值，到多少就不生产了
    int low_water_;
    int high_water_;    
    pthread_mutex_t mutex_;
    pthread_cond_t c_cond_; //消费者条件变量
    pthread_cond_t p_cond_; //生产者条件变量
    

};

main.cc

#include "BlockQueue.hpp"

void *Consumer(void *args)
{
    BlockQueue<int> *bq = static_cast<BlockQueue<int>*>(args);
    while(true)
    {
        //消费
        int data = bq->pop();
        std::cout<<"消费了一个数据："<< data <<std::endl;
    }
}
void *Productor(void *args)
{
     BlockQueue<int> *bq = static_cast<BlockQueue<int> *>(args);
    while(true)
    {
        //生产
        data++;
        bq->push(data);
        std::cout<<"生产了一个数据："<<data<<std::end;
    }
}
int main()
{
    BlockQueue<int> *bq = new BlockQueue<int>();
    pthread_t c,p;
    pthread_create(&c,nullptr,Consumer,bq);
    pthread_create(&p,nullptr,Productor,bq);

    pthread_join(c,nullptr);
    pthread_join(p,nullptr);
    delete bq; 
    return 0;
}

makefile

test_blockqueue:main.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clea:
rm -f test_blockqueue

原文地址：https://blog.csdn.net/lzb_kkk/article/details/140385545

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Linux（CentOS7）部署httpd-2.4.37源码包
下一篇：什么是等级保护，等级保护的认证流程有哪些？

网络安全在线网站/靶场：全面探索与实践
CyberPatriot 是由美国空军协会（AFA）赞助的一项全国性网络安全教育计划，主要面向中小学生。该平台通过模拟真实的网络环境，帮助学生们学习如何检测和防御网络攻击。
阅读更多2024-11-17
Javascript垃圾回收机制-运行机制（大厂内部培训版本）
分代式机制把一些新、小、存活时间短的对象作为新生代，采用一小块内存频率较高的快速清理，而一些大、老、存活时间长的对象作为老生代，使其很少接受检查，新老生代的回收机制及频率是不同的，可以说此机制的出现很
阅读更多2024-11-17
算法练习：438. 找到字符串中所有字母异位词
找到字符串中所有字母异位词详解
阅读更多2024-11-17
ubuntu固定ip
ifconfig。
阅读更多2024-11-17
【每日 C/C++ 问题】
适用于两个相关的类型之间的自动转换，类型不相关时编译器会识别出来并报错。
阅读更多2024-11-17
sb.append(a + b)；与sb.append(a).append(b)；详解
sb.append(a + b);与sb.append(a).append(b); 详解
阅读更多2024-11-17
Java学习教程，从入门到精通，Java中super关键字的语法知识点及案例（31）
super是Java中的一个关键字，主要用于引用当前对象的父类或超类。通过super，可以在子类中访问父类的成员变量、方法和构造函数。
阅读更多2024-11-17
6. Keepalived配置Nginx自动重启，实现7x24提供服务
Keepalived配置Nginx自动重启，实现7x24提供服务实现步骤
阅读更多2024-11-17
unity3d————场景异步加载
本文介绍了Unity中场景切换的两种方法：同步切换和异步切换。同步切换在切换场景时会删除当前场景的所有对象并加载下一个场景的信息，可能导致卡顿。因此，异步切换被引入来解决这个问题。异步切换有两种实现方
阅读更多2024-11-17
Android Studio 控制台输出的中文显示乱码
安卓在调试阶段，需要查看app运行时的输出信息、出错提示信息。乱码，会极大的阻碍开发者前进的信心，不能及时的根据提示信息定位问题，因此我们需要查看没有乱码的打印信息。代码运行报错的时候，Build O
阅读更多2024-11-17