【线程】线程的同步

news2024/9/22 20:02:26

本文重点：理解条件变量和生产者消费者模型

同步是在保证数据安全的情况下，让我们的线程访问资源具有一定的顺序性

条件变量cond

当一个线程互斥地访问某个变量时，它可能发现在其它线程改变状态之前，它什么也做不了，就是申请锁失败了，它就要添加到一个队列中等待，这个队列叫做等待队列，把这个等待队列可以叫做条件变量，也就是说申请锁失败，进行等待是在条件变量下等的，这样它们排好队，就有顺序性。

条件变量依赖于锁的实现

那我怎么知道几时要在条件变量下等呢？

一定是临界资源不就绪，没错，临界资源也是有状态的！！

你怎么知道临界资源是就绪还是不就绪的？

你判断出来的！判断是访问临界资源吗？必须是的，也就是判断必须在加锁之后！！

条件变量接口

初始化接口和锁是一样的

pthread_cond_t: 系统提供的类型

cond：要初始化的条件变量
attr：条件变量的属性，设为nullptr

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
全局的条件变量，自动初始化和销毁

等待条件满足

cond：要在这个条件变量上等待
mutex：锁，后面详细解释 

 唤醒等待

signal是唤醒一个线程，broadcast是唤醒条件变量下的全部线程 

下面通过代码来理解上面的问题

注意函数接口的位置，想想为什么函数是在这？

#include<iostream>
#include<unistd.h>
#include<pthread.h>

using namespace std;

int cnt=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void* Count(void* args)
{
    pthread_detach(pthread_self());//分离线程
    uint64_t number=(uint64_t)args;
    cout<<"pthread: "<<number<<",create success"<<endl;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        // 我们怎么知道我们要让一个线程去休眠了那？一定是临界资源不就绪，没错，临界资源也是有状态的！！
        // 你怎么知道临界资源是就绪还是不就绪的？你判断出来的！判断是访问临界资源吗？必须是的，也就是判断必须在加锁之后！！！
        pthread_cond_wait(&cond,&mutex);
        //为什么这个函数在这里？因为临界资源不就绪，就要等待
        //为什么还要一个锁的参数？因为这个线程在前面的时候申请了锁，此时线程持有锁
        //1.pthread_cond_wait让线程等待的时候，会自动释放锁！2.唤醒而返回的时候，重新持有锁
        cout<<"pthread: "<<number<<", cnt: "<<cnt++<<endl;
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return nullptr;
}
int main()
{
    for(uint64_t i=0;i<5;i++)
    {
        pthread_t tid;
        pthread_create(&tid,nullptr,Count,(void*)i);
        usleep(1000);
    }
    //让主线程把等待的线程唤醒
    while(1)
    {
        sleep(1);
        pthread_cond_signal(&cond);//唤醒条件变量下的一个线程，默认第一个开始
        cout<<"signal one thread..."<<endl;

    }
    return 0;
}

 

从结果看出，线程访问临界资源时具有一定的顺序性 

要点： 

pthread_cond_wait函数的位置

我们怎么知道我们要让一个线程去休眠了那？

一定是临界资源不就绪，没错，临界资源也是有状态的！！

你怎么知道临界资源是就绪还是不就绪的？你判断出来的！判断是访问临界资源吗？必须是的，也就是判断必须在加锁之后！！！

为什么这个函数在这里？因为临界资源不就绪，就要等待

为什么还要一个锁的参数？因为这个线程在前面的时候申请了锁，此时线程持有锁

1.pthread_cond_wait让线程等待的时候，会自动释放锁！2.唤醒而返回的时候，重新持有锁

总的来说：条件变量依赖于锁的实现

可能大家还没有很理解，那就在看看下面的生产者消费者模型，再次理解线程怎么等待和唤醒的

生产者消费者模型的原理

producter  consumer

生产者生产产品供货给超市，消费者通过从超市消费，得到产品，超市就相当于一个大的缓存，生产者生产的产品都可以放在超市里，供消费者使用，这样可以提高效率，支持忙闲不均，生产和消费的行为存在一定的解耦（解耦的意思也就是生产者生产是一个执行流，消费者消费是另一个执行流，两个执行流可以同时访问超市资源，就有一定的解耦，不像只有一个执行流时，就不能同时执行）

在生产者生产产品的过程中，消费者是不能访问产品的，但是消费者可以处理产品，相反，在消费者访问产品时，生产者无法生产，但是生产者可以获取数据，这样结合，效率就会很高

记住生产者消费者模型就记住“321”原则

3种关系

2种角色--生产者，消费者

1个场所--超市

生产者消费者模型的实现

思路：创建两个线程，单生产单消费的，一个充当消费者，一个充当生产者，消费者消费任务，生产者生产任务。写一个等待队列的类，方法写生产任务和消费任务，这个是共享资源，需要加锁和解锁，看资源状态来添加条件变量，在写一个任务的类，写清楚是什么任务

大家可以把下面的三个文件的代码拷贝到自己的Visual Studio Code下看，更好看一些，代码是不难得，认真看是能看懂的

一定要特别关注条件变量的接口的使用和他的位置

main.cc

#include "blockqueue.hpp"
#include "task.hpp"
#include<time.h>

using namespace std;

void *Producter(void *p_args)
{
    int len=opers.size();
    BlockQueue<Task>* bq=static_cast<BlockQueue<Task>*>(p_args);
    while (1)
    {
        // 模拟生产者获取数据的过程
        int data1=rand()%10+1;//[1,10]
        usleep(100);
        int data2=rand()%10;
        char op=opers[rand()%len];
        Task t(data1,data2,op);
        bq->push(t);//生产任务
        // cout << "生产了一个任务:" << t.GetTask() <<endl;
        printf("生产了一个任务： %s\n",t.GetTask().c_str());
        sleep(1);
    }
    return nullptr;
}

void *Consumer(void *c_args)
{
    BlockQueue<Task>* bq=static_cast<BlockQueue<Task>*>(c_args);
    while (1)
    {
        //消费任务
        Task t= bq->pop();
        //计算
        t.run();//模拟消费者消费消费数据的过程
        // cout << "处理任务: " <<t.GetTask()<<" 运算结果："<<t.GetResult()<<endl;
        printf("处理任务：%s,运算结果：%s\n",t.GetTask().c_str(),t.GetResult().c_str());
    }
    return nullptr;
}

int main()
{
    srand(time(nullptr));
    pthread_t p, c;
    BlockQueue<Task>* bq=new BlockQueue<Task>;
    pthread_create(&p, nullptr, Producter, (void *)bq);
    pthread_create(&c, nullptr, Consumer, (void *)bq);

    pthread_join(p, nullptr);
    pthread_join(c, nullptr);

    delete bq;

    return 0;
}

blockqueue.hpp

#pragma once
#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<queue>

using namespace std;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
//生产者和消费者的条件变量要分开的，它们是不同的
pthread_cond_t c_cond=PTHREAD_COND_INITIALIZER;//消费者的条件变量
pthread_cond_t p_cond=PTHREAD_COND_INITIALIZER;//生产者的条件变量

template<class T>
class BlockQueue
{
public:
    BlockQueue(int maxcap=4):_maxcap(maxcap)
    {}

    T pop()
    {
        //加锁
        pthread_mutex_lock(&mutex);
        // 我们怎么知道我们要让一个线程去休眠了那？一定是临界资源不就绪，没错，临界资源也是有状态的！！
        // 你怎么知道临界资源是就绪还是不就绪的？你判断出来的！判断是访问临界资源吗？必须是的，也就是判断必须在加锁之后！！！
        if(_wait_q.size()==0)//队列为空，临界资源不就绪，就不能消费了，在消费者条件变量下等待
        {
            pthread_cond_wait(&c_cond,&mutex);//1.pthread_cond_wait让线程等待的时候，会自动释放锁！2.唤醒而返回的时候，重新持有锁
        }
        T out=_wait_q.front();
        _wait_q.pop();
        pthread_cond_signal(&p_cond);//消费了一个，生产者肯定可以生产了，唤醒生产者的条件变量下的一个线程
        pthread_mutex_unlock(&mutex);
        return out;
    }
    void push(const T& in)
    {
        pthread_mutex_lock(&mutex);
        if(_wait_q.size()==_maxcap)//队列满了，临界资源不就绪，就不能生产了，在生产者条件变量下等待
        {
            pthread_cond_wait(&p_cond,&mutex);
        }
        _wait_q.push(in);
        pthread_cond_signal(&c_cond);//生产了一个，消费者肯定可以消费了，唤醒消费者的条件变量下的一个线程
        pthread_mutex_unlock(&mutex);
    }
    ~BlockQueue()
    {}

private:
    queue<T> _wait_q;//等待队列
    int _maxcap;//队列的最大容量

};

task.hpp

#pragma once
#include <iostream>
#include <string>

using namespace std;
string opers="+-*/%";

enum
{
    Divzero = 1,
    Modzero,
    Unknown
};

class Task
{
public:
    Task(int data1, int data2, char op) : _data1(data1), _data2(data2), _op(op), _result(0), _exitcode(0)
    {}
    void run()
    {
        switch (_op)
        {
        case '+':
        {
            _result = _data1+_data2;
            break;
        }
        case '-':
        {
            _result = _data1-_data2;
            break;
        }
        case '*':
        {
            _result = _data1*_data2;
            break;
        }
        case '/':
        {
            if (_data2 == 0) _exitcode = Divzero;
            else _result = _data1/_data2;
            break;
        }
        case '%':
        {
            if (_data2 == 0) _exitcode = Modzero;
            else _result = _data1%_data2;
            break;
        }
        default:
        {
            _exitcode=Unknown;
            break;
        }
        }
    }
    void operator()()
    {
        run();
    }
    string GetResult()
    {
        string r=to_string(_data1);
        r+=_op;
        r+=to_string(_data2);
        r+='=';
        r+=to_string(_result);
        r+='[';
        r+=to_string(_exitcode);
        r+=']';
        return r;
    }
    string GetTask()
    {
        string r=to_string(_data1);
        r+=_op;
        r+=to_string(_data2);
        r+="=?";
        return r;
    }

private:
    int _data1;
    int _data2;
    char _op;
    int _result;
    int _exitcode;
};

main.cc中打印用printf比较好，用cout我的平台下会有点乱序

 

看懂上面的实现再来看这个问题

什么是伪唤醒？

假如多个生产者生产了四个产品，生产者条件变量下的等待的线程有三个，消费者消费了一个产品，假如用的pthread_cond_broadcast接口，那就唤醒了那三个线程，它们就pthread_cond_wait函数返回，重新持有锁，就生产产品，但是到第二个线程的时候，队列已经满了，第二个线程还会生产 ，那就越界出错了

怎么防止伪唤醒？

就在条件判断时改为循环，不要if，这样函数返回时还要判断（上面的代码还是if，你们自己改吧） 

下面的代码是把上面的实现改为多生产者多消费者

只改了main.cc

#include "blockqueue.hpp"
#include "task.hpp"
#include<time.h>

using namespace std;

void *Producter(void *p_args)
{
    int len=opers.size();
    BlockQueue<Task>* bq=static_cast<BlockQueue<Task>*>(p_args);
    while (1)
    {
        // 模拟生产者获取数据的过程
        int data1=rand()%10+1;//[1,10]
        usleep(100);
        int data2=rand()%10;
        char op=opers[rand()%len];
        Task t(data1,data2,op);
        bq->push(t);//生产任务
        // cout << "生产了一个任务:" << t.GetTask() <<endl;
        printf("生产了一个任务：%s,thread id: %x\n",t.GetTask().c_str(),pthread_self());
        sleep(1);
    }
    return nullptr;
}

void *Consumer(void *c_args)
{
    BlockQueue<Task>* bq=static_cast<BlockQueue<Task>*>(c_args);
    while (1)
    {
        //消费任务
        Task t= bq->pop();
        //计算
        t.run();//模拟消费者消费消费数据的过程
        // cout << "处理任务: " <<t.GetTask()<<" 运算结果："<<t.GetResult()<<endl;
        printf("处理任务：%s,运算结果：%s,thread id: %x\n",t.GetTask().c_str(),t.GetResult().c_str(),pthread_self());
    }
    return nullptr;
}

int main()
{
    srand(time(nullptr));
    pthread_t p[5], c[3];
    BlockQueue<Task>* bq=new BlockQueue<Task>;
    for(int i=0;i<5;i++)
    pthread_create(p+i, nullptr, Producter, (void *)bq);
    for(int i=0;i<3;i++)
    pthread_create(c+i, nullptr, Consumer, (void *)bq);

    for(int i=0;i<5;i++)
    pthread_join(p[i], nullptr);
    for(int i=0;i<3;i++)
    pthread_join(c[i], nullptr);

    delete bq;

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2155800.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CSS 选择器的分类与使用要点一

CSS 选择器的分类与使用要点一

目录 非 VIP 用户可前往公众号进行免费阅读 标签选择器 id 选择器 类选择器 介绍 公共类 CSS 中优先用 class 选择器，慎用 id 选择器 后代选择器 交集选择器 以标签名作为开头 以类名作为开头 连续交集 并集选择器（分组选择器） 通配符* 儿子选择器 >（IE7…
阅读更多...
Elasticsearch——介绍、安装与初步使用

Elasticsearch——介绍、安装与初步使用

目录 1.初识 Elasticsearch1.1.了解 ES1.1.1.Elasticsearch 的作用1.1.2.ELK技术栈1.1.3.Elasticsearch 和 Lucene1.1.4.为什么不是其他搜索技术&#xff1f;1.1.5.总结 1.2.倒排索引1.2.1.正向索引1.2.2.倒排索引1.2.3.正向和倒排 1.3.Elasticsearch 的一些概念1.3.1.文档和字…
阅读更多...
基于单片机的智能温控风扇系统的设计

基于单片机的智能温控风扇系统的设计

&#xff3b;摘 要&#xff3d; 设计一种基于单片机的智能温控风扇系统&#xff0c;系统由 STC 系列的 51 单片机 、 温度传感器 、 LED 数码管和风扇等模块组成。 本系统具有对外界温度感知以及对感知数据进行分析处理 、 智能调节等功能&#xff0c;避免因温度过高而产生…
阅读更多...
【全部更新】2024华为杯数学建模研赛F题思路代码文章全国研究生数学建模-X射线脉冲星光子到达时间建模

【全部更新】2024华为杯数学建模研赛F题思路代码文章全国研究生数学建模-X射线脉冲星光子到达时间建模

截止9.22 14:00 已更新全部文章内容完整求解代码(正版授权) ### https://docs.qq.com/doc/DVVBUREF2SmFhRUl3X射线脉冲星光子到达时间建模 摘要 脉冲星是一类高速自转的中子星&#xff0c;其自转形成规律性脉冲信号&#xff0c;类似于“宇宙中的灯塔”&#xff0c;因此被认为是…
阅读更多...
鸿蒙 WebView 如何 Debug

鸿蒙 WebView 如何 Debug

前置&#xff1a; hdc chrome //----------------------------------------------------------------------------------------------- hdc shell cat /proc/net/unix | grep devtools 0: 00000002 0 10000 1 1 81134005 webview_devtools_remote_62479exit执行&…
阅读更多...
[001-02-001].第2节：java开发环境搭建

[001-02-001].第2节：java开发环境搭建

4.1.书籍推荐&#xff1a; 4.2.人机交互方式 1.图形化界面(Graphical User Interface GUI)这种方式简单直观&#xff0c;使用者易于接受&#xff0c;容易上手操作2.命令行方式(Command Line Interface CLI)&#xff1a;需要有一个控制台&#xff0c;输入特定的指令&#xff0c…
阅读更多...
828华为云征文｜云服务器Flexus X实例｜MacOS系统-宝塔部署Nuxt项目

828华为云征文｜云服务器Flexus X实例｜MacOS系统-宝塔部署Nuxt项目

文章目录 1. Flexus云服务器X实例1.1 与Flexus应用服务器L实例相比具备以下优势1.2 服务器的详细配置 2.宝塔部署Nuxt项目2.1 登录实例2.1 宝塔面板 3. Nuxt 项目与部署3.1 Nuxt3.2创建Nuxt项目3.3 部署3.4 部署成功 4.结语 1. Flexus云服务器X实例 华为云的Flexus云服务是为中…
阅读更多...
股指期权交易详细基础介绍

股指期权交易详细基础介绍

股指期权是期权市场中的一种特定类型&#xff0c;其标的资产为股票指数。简而言之&#xff0c;它允许投资者在未来某个特定时间&#xff0c;以预先约定的价格&#xff0c;买入或卖出股票指数的权利。在中国&#xff0c;已上市的股指期权包括上证50、沪深300和中证1000股指期权&…
阅读更多...
【C++ Primer Plus习题】17.5

【C++ Primer Plus习题】17.5

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: #include <iostream> #include <fstream> #include <…
阅读更多...
数据库系统基础概述

数据库系统基础概述

文章目录 前言一、数据库基础概念 1.数据库系统的组成2.数据模型3.数据库的体系结构二、MySQL数据库 1.了解MySQL2.MySQL的特性3.MySQL的应用场景总结 前言 MySQL数据库是一款完全免费的产品&#xff0c;用户可以直接从网上下载使用&#xff0c;不用花费任何费用。这点对于初学…
阅读更多...
react开发环境搭建

react开发环境搭建

文章目录 准备工作创建 React 项目使用 create-react-app 创建 React 项目使用 Vite 创建 React 项目启动项目效果安装出现的情况 react项目文件讲解1. 项目根目录2. 其他可能的目录和文件3. 配置文件 准备工作 Node.js 安装方法&#xff1a; 方式一&#xff1a;使用 NVM 安装…
阅读更多...
制作一个rabbitmq-sdk以及rabbitmq消费者实现定时上下线功能

制作一个rabbitmq-sdk以及rabbitmq消费者实现定时上下线功能

目录结构 pom.xml <project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">&l…
阅读更多...
力扣中等 33.搜索旋转排序数组

力扣中等 33.搜索旋转排序数组

文章目录 题目介绍题解 题目介绍 题解 首先用 153. 寻找旋转排序数组中的最小值 的方法&#xff0c;找到 nums 的最小值的下标 i。 然后分类讨论&#xff1a; 如果 target>nums[n−1]&#xff0c;在 [0,i−1] 中二分查找 target。 如果 target≤nums[n−1]&#xff0c;那…
阅读更多...
利士策分享，家庭内耗：隐形的风暴，无声的侵蚀

利士策分享，家庭内耗：隐形的风暴，无声的侵蚀

利士策分享&#xff0c;家庭内耗&#xff1a;隐形的风暴&#xff0c;无声的侵蚀 在温馨的灯光下&#xff0c;家本应是我们心灵的港湾&#xff0c;是疲惫时最坚实的依靠。 然而&#xff0c;当家庭内部出现裂痕&#xff0c;无形的内耗便如同冬日里的寒风&#xff0c;悄无声息地…
阅读更多...
11年408考研真题解析-计算机网络

11年408考研真题解析-计算机网络

第一题&#xff1a; 解析&#xff1a;网络层虚电路服务和数据报服务 传输服务只有&#xff1a;有连接可靠和无连接不可靠两种&#xff0c;直接排除BC。 网络层指的是IP协议&#xff0c;由图二可知&#xff1a;运输层&#xff0c;网际层&#xff0c;网络接口层唯一有连接可靠的协…
阅读更多...
Spark MLlib实践指南：从大数据推荐系统到客户流失预测的全流程建模

Spark MLlib实践指南：从大数据推荐系统到客户流失预测的全流程建模

问题一 背景&#xff1a; 本题目基于用户数据&#xff0c;将据数据切分为训练集和验证集&#xff0c;供建模使用。训练集与测试集切分比例为8:2。 数据说明&#xff1a; capter5_2ml.csv中每列数据分别为userId , movieId , rating , timestamp。 数据&#xff1a; capte…
阅读更多...
详解 Linux 系统下的进程（下）

详解 Linux 系统下的进程（下）

目录 一.进程控制 1.进程创建 a.Linux 系统中&#xff0c;如何创建一个进程&#xff1f; b.进程创建成功后&#xff0c;Linux 底层会为其做些什么&#xff1f; 2.进程终止 a.什么是进程终止&#xff1f; b.进程终止的方法有哪些&#xff1f; c.exit 与 _exit的区别 3.…
阅读更多...
通过logstash同步elasticsearch数据

通过logstash同步elasticsearch数据

1 概述 logstash是一个对数据进行抽取、转换、输出的工具&#xff0c;能对接多种数据源和目标数据。本文介绍通过它来同步elasticsearch的数据。 2 环境 实验仅仅需要一台logstash机器和两台elasticsearch机器&#xff08;elasticsearch v7.1.0&#xff09;。本文用docker来模…
阅读更多...
NLP 序列标注任务核心梳理

NLP 序列标注任务核心梳理

句向量标注 用 bert 生成句向量用 lstm 或 bert 承接 bert 的输出&#xff0c;保证模型可以学习到内容的连续性。此时 lstm 输入形状为&#xff1a; pooled_output.unsqueeze(0) (1, num_sentence, vector_size) 应用场景 词性标注句法分析 文本加标点 相当于粗粒度的分词任…
阅读更多...
实时同步 解决存储问题 sersync

实时同步 解决存储问题 sersync

目录 1.sersync服务 2.sersync同步整体架构 ​编辑 3.rsync服务准备 4.sersync部署使用 5.修改配置文件 6.启动sersync 7.接入nfs服务 8.联调测试 1.sersync服务 sersync服务其实就是由两个服务组成一个是inotify服务和rsync服务组成 inotify服务用来监控那个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023