Linux线程同步与互斥(二)/生产消费者模型

⭐前言:本文会先后讲解生产消费者模型、条件变量和基于阻塞队列的生产消费者模型。

1.生产消费者模型

什么是生产消费者模型?

认识生产消费者模型

使用学生(消费者),超市,供货商(生产者)来举一个例子。

学生是典型的消费者,供货商是典型的生产者。假设学生有泡面、火腿肠、玩具等等的需求,而供货商会生产尽可能覆盖学生需求的商品,但是一般并不会直接卖给学生,而是供货给超市,从而在超市里做买卖。

如果是春节期间,或者是什么特殊时期,供货商暂停生产商品,但由于超市已经进了很大一批货,生产者停止生产压根不会影响到消费者消费。这里,就是生产与消费过程的互不干扰,称之为解耦。而超市作为大量进货的一方,一般不会进很少货,而是进很多,达到满足消费需求,因此可以看作是临时保存商品的地方,我们对应的是计算机中的缓冲区

接下来举一个反例,即强耦合关系的生产消费者来加深理解->在我们平时写的代码中,比如实现一个加法函数Add和调用Add函数的main函数。在调用Add函数的时候,main函数是在等待阶段的,并且Add函数是会直接影响到main函数的。

因此,从上面例子来正确认识一下生产消费者模型:

超市(缓冲区)作为消费者消费的地方,生产者放资源的地方,它必须要让消费者和生产者都看到,即它是一份共享资源!这部分共享资源会涉及到多线程访问,那就必须被保护起来。

生产者和消费者是线程,顾名思义,作为生产者的线程用于向缓冲区存入数据,消费者线程向缓冲区拿数据。

因此,生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。

生产者消费者关系

生产者和消费者,都是对应着一个或多个线程。

生产者和生产者之间的关系是互斥关系,就好像金华火腿和双汇火腿不能同时摆放在一个货架上,否则会很乱,消费者就不好消费了,一定是先摆放好一种火腿,再去摆放好另外一种火腿。

消费者和消费者之间的关系也是互斥关系。很简单的一个例子:黄牛抢票。

消费者和生产者的关系也是有互斥关系。比如超市里面有一个展架,上面刚放了生产者提供的火腿,但是还没贴价格标签,但是消费者已经来想要消费了,很明显价格还没贴是不能消费先的,因此需要互斥关系,并且这能保证资源是安全的。

消费者和生产者的关系还有同步关系。超市会根据火腿的售卖量来决定入货的数量,即向消费者卖了多少火腿,就向生产者要多少火腿,然后火腿有货的时候,就会通知消费者来消费,缺火腿的时候,就会通知生产者进货,使其有顺序性。从而达到了消费者和生产者的同步与互斥关系。

总结:“321”原则

3种关系:①生产者和生产者的互斥关系。②消费者和消费者的互斥关系。③生产者和消费者的互斥(互斥是为了保证共享资源的安全性)、同步关系。

2种角色:生产者线程和消费者线程。

1个交易场所:一段特定结构的缓冲区。

生产消费者模型的优点

解耦    支持并发     支持忙闲不均

如何维护生产消费者模型中生产者和消费者的同步关系?

现在我们有了消费者线程,也有了生产者线程,并且它们都是线程安全的,加了互斥锁。

生产者线程在生产数据加入到缓冲区中,是对消费者线程互斥的,也就是说生产者线程在生产的时候,会对缓冲区加锁,只有将生产后的数据加入到缓冲区中,并且解锁之后,理论上消费者才可以去消费。但是生产者的优先级高,即使缓冲区中已经满了,但是生产者依旧不断地加锁----到缓冲区中判断是否满了,如果没满,则放入数据,如果满了则解锁离开。离开之后,又有生产者线程来了......这样就导致消费者线程永远进不来。这就只保证了生产者和消费者之间的互斥,保证了共享资源的安全性,但是没有维护好两者的同步关系!

因此我们需要引入条件变量来维护同步关系!

2.条件变量

什么是条件变量

条件变量就是一种变量,它包含了条件变量的状态和队列的指针,它可以链接不满足条件,需要等待的线程。待线程满足条件,就可以将其唤醒拿出来,放到CPU上等待队列。

这里我们可以看到,所有的线程都必须要看到这个条件变量,因此条件变量需要定义为全局的。

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

用条件变量的逻辑为:

加锁----->判断生产和消费条件是否满足----->解锁。其中判断条件也是访问临界资源的一种,需要保护起来。当条件满足,则做相应的事,如果不满足,则解锁之后,不再申请锁,并且将自己阻塞挂起等待。

条件变量函数

条件变量的类型:

pthread_cond_t

①初始化

int pthread_cond_init(pthread_cond_t* restrict cond, const pthread_condattr_t* restrict attr);
参数:
	cond:要初始化的条件变量
	attr:NULL
返回值:成功返回0,失败返回错误码。

②销毁

int pthread_cond_destroy(pthread_cond_t *cond)

③等待条件满足

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
参数:
    cond:要在这个条件变量上等待
    mutex:互斥量,后面详细解释

④等待唤醒

//唤醒一批线程
int pthread_cond_broadcast(pthread_cond_t *cond);

//唤醒一个线程
int pthread_cond_signal(pthread_cond_t *cond);

下面通过条件变量的简单案例,来看看条件变量是如何工作的。

通过创建两个线程,让两个线程交替执行去抢票,通过条件变量和互斥锁,让两个线程有顺序地执行。两个线程执行的时候,先会在条件变量中排队,等待主线程的唤醒,依次执行。

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//条件变量
int tickets = 1000;
void* start_routine(void *args)
{
    std::string name = static_cast<const char*>(args);
    while(true)
    {
        pthread_mutex_lock(&mutex);//加锁
        //每一个线程进来后先等等
        pthread_cond_wait(&cond,&mutex);

        //if(tickets)
        std::cout<<name<<"-> "<<tickets<<std::endl;
        tickets--;
        pthread_mutex_unlock(&mutex);//解锁

    }
}

int main()
{
    //通过条件变量控制线程的执行
    //创建两个线程,让两个线程交替执行
    pthread_t t1,t2;
    pthread_create(&t1,nullptr,start_routine,(void*)"thread 1");
    pthread_create(&t2,nullptr,start_routine,(void*)"thread 2");

    while(true)
    {
        //主线程,控制节奏,在其它线程在条件变量的等待的时候,一次唤醒一个线程进行运行
        sleep(2);
        //每隔2秒唤醒一下
        pthread_cond_signal(&cond);
        //预期每一个线程在执行的时候,一定会有非常强的顺序性
        std::cout<<"main thread wakeup one thread..."<<std::endl;
    }
    //线程等待
    pthread_join(t1,nullptr);
    pthread_join(t2,nullptr);
    return 0;
}

可以看到结果,顺序性很强,都是1->2->1->2这样的执行顺序。

我们再创建多个线程,跟上面一样,让多个线程在执行的时候,先在条件变量中排队,等待主线程的唤醒,然后依次执行。

这里的唤醒是使用pthread_cond_signal,每次唤醒一个线程。

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//条件变量
int tickets = 1000;
void* start_routine(void *args)
{
    std::string name = static_cast<const char*>(args);
    while(true)
    {
        pthread_mutex_lock(&mutex);//加锁
        //每一个线程进来后先等等
        pthread_cond_wait(&cond,&mutex);
        std::cout<<name<<"-> "<<tickets<<std::endl;
        tickets--;
        pthread_mutex_unlock(&mutex);//解锁

    }
}

int main()
{

    //通过条件变量控制线程的执行
    //创建多个线程,让多个线程交替执行
    pthread_t t[5];
    for(int i = 0;i<5;i++)
    {
        char *name = new char[64];
        snprintf(name,64,"thread %d",i+1);
        pthread_create(t+i,nullptr,start_routine,name);
    }
    while(true)
    {
        //主线程,控制节奏,在其它线程在条件变量的等待的时候,一次唤醒一个线程进行运行
        sleep(1);
        //每隔1秒唤醒一下
        pthread_cond_signal(&cond);
        //预期每一个线程在执行的时候,一定会有非常强的顺序性
        std::cout<<"main thread wakeup one thread..."<<std::endl;
    }
    for(int i = 0;i < 5;++i)
    {
        pthread_join(t[i],nullptr);
    }
    return 0;
}

 使用pthread_cond_broadcast,一次唤醒一批线程。

        //pthread_cond_signal(&cond);
        pthread_cond_broadcast(&cond);

3.基于阻塞队列的生产消费者模型

终于,我们知道了什么叫做生产消费者模型,什么是条件变量,并且简单了解了条件变量如何去使用了。

现在,我们左手一个生产消费者模型,右手一个条件变量和互斥量,是时候徒手搓氢弹....呃....基于阻塞队列的生产消费者模型了!

什么是基于阻塞队列的生产消费者模型?

在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于,当队列为空时,从队列获取元素的操作将会被阻塞,直到队列中被放入了元素;当队列满时,往队列里存放元素的操作也会被阻塞,直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的,线程在对阻塞队列进程操作时会被阻塞)。

 C++queue模拟阻塞队列的生产消费者模型

以单生产者,单消费者,来进行学习。

头文件BlockQueue.hpp:

#pragma once

#include <iostream>
#include<queue>
#include<pthread.h>
using namespace std;
const int gmaxcap = 5;//设置默认缺省值为5,方便进行测试
template<class T>
class BlockQueue
{
public:
    BlockQueue(const int &_maxcap = gmaxcap)
        :_maxcap(gmaxcap)
    {
        pthread_mutex_init(&_mutex,nullptr);//初始化锁
        pthread_cond_init(&_pcond,nullptr);//初始化条件变量
        pthread_cond_init(&_ccond,nullptr);

    }

    //放数据
    void push(const T &in)//输入型参数,一般用const 和引用&修饰
    {
        //线程进来先加锁,生产者
        pthread_mutex_lock(&_mutex);
        //在放入数据的前,需要判断阻塞队列是否满了
        if(is_full())
        {
           //满了不能生产,那就去对应的条件变量中等待
           pthread_cond_wait(&_pcond,&_mutex);
        }
        //没满,就放入数据
         _q.push(in);
        //此时我们可以绝对保证,阻塞队列里面一定有数据,至少有一个
        //此时可以让消费者来消费,即唤醒消费者
        pthread_cond_signal(&_ccond);//这里可以加一定的策略,待队列的元素超过三分之一再唤醒消费者
        //最后解锁
        pthread_mutex_unlock(&_mutex);
    }

    //拿数据
    void pop(T *out)//输出型参数,一般用*
    {
        pthread_mutex_lock(&_mutex);//消费者和生产者用的是同一把锁,因为必须让生产者和消费者互斥
        //判断队列是否空的,如果空,那就等待
        if(is_empty())
        {
            pthread_cond_wait(&_ccond,&_mutex);
        }
        //走到这里,我们能保证一定不为空
        //拿数据
        *out =_q.front();
        _q.pop();

        //绝对能保证,阻塞队列里面至少有一个空的位置
        //此时可以将生产者唤醒,去生产
        pthread_cond_signal(&_pcond);//这里也可以有一定的策略
        pthread_mutex_unlock(&_mutex);
    }

    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_pcond);
        pthread_cond_destroy(&_ccond);

    }

private:
//判断阻队列是否为空
    bool is_empty()
    {
        return _q.empty();
    }

//判断阻队列是否满了
    bool is_full()
    {
        return _q.size()==_maxcap;
    }
private:
    std::queue<T> _q;
    int _maxcap;//阻塞队列中最多能有多少个元素
    //_q这个队列本身不是线程安全的,因此我们保护起来
    pthread_mutex_t _mutex;
    //当队列满了之后,生产者进入休眠,队列空,消费者进入休眠,因此定义条件变量
    pthread_cond_t _pcond;//生产者对应的条件变量
    pthread_cond_t _ccond;//消费者对应的条件变量
};

①生产速度比消费速度慢,那么会出现生产一个,消费一个这样的情况,因为会阻塞嘛。

#include <ctime>
#include <sys/types.h>
#include <unistd.h>
using namespace std;
#include "BlockQueue.hpp"
void* consumer(void *_bq)
{
    BlockQueue<int> *bq = static_cast<BlockQueue<int>*>(_bq);
    while(true)
    {
        //消费活动
        int data;
        bq->pop(&data);
        std::cout<<"消费数据: "<<data<<std::endl;

    }
    return nullptr;

}

void* productor(void *_bq)
{
    BlockQueue<int> *bq = static_cast<BlockQueue<int>*>(_bq);

    while(true)
    {
        //生产活动
        int data = rand()%10 +1;//1到10的数据
        bq->push(data);
        std::cout<<"生产数据: "<<data<<std::endl;
        sleep(1);//让生产速度比消费速度慢一点
    }
    return nullptr;

}
int main()
{
    srand((unsigned long)time(nullptr)^getpid());//随机生成数据据
    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);


    return 0; 
}

 

②生产速度比消费速度快,那么一开始会生产出好几个,然后会生产一下,消费一下。接着我们可以通过结果看出,消费的都是先生产出来的。

通过上面的代码和结果,我们很明显地感受到了生产者和消费者之间的协同,也就是同步了!

接下来我们完善这一份代码和一些细节的说明:

⭐细节1:我们在放入数据或拿数据的时候,是添加了互斥锁的!也就是说,线程在拿到锁后,进入等待的时候,是拿着锁一起等待的!那么这就意味着,锁被拿走了,谁也无法进入这个临界区了!

可事实上并不是这样,因为pthread_cond_wait这个函数的第二个参数,必须是我们正在使用的互斥锁,该函数会以原子性的方式将锁释放,并且将自己(线程)挂起,在被唤醒返回的时候,会自动重新获取我们传入的锁。

⭐细节2:如果生产者有10个,此时的队列是满的,只有一个消费者。那么消费者在消费后,阻塞队列就有一个位置空了出来,如果我们让一批生产者唤,而空间只有1个,那么在放入数据的时候,就有很大的可能会放入很多个数据!因此,我们将放入数据的操作中的判空操作,从if语句改为while循环,生产者醒来之后,再判断一下队列是否为空或者为满!同样的道理,消费者拿数据也一样,将if改为while循环。

⭐细节3:pthread_cond_signal这个函数,可以放在临界区内部,也可以放在外部。

⭐细节4:上面的代码中,只有打印1,2,3,4这样的数据,实在有点捞,我们可以改一下代码,让生产者给消费者派发任务!

派发任务Task.hpp:

#pragma once
#include <iostream>
#include <functional>
using namespace std;

class Task
{
    using func_t = std::function<int(int,int)>;
    // typedef std::function<int(int,int)> func_t;
public:
    Task()
    {}
    Task(int x, int y, func_t func):_x(x), _y(y), _callback(func)
    {}
    int operator()()
    {
        int result = _callback(_x, _y);
        return result;
    }
private:
    int _x;
    int _y;
    func_t _callback;
};

修改后的代码: 


#include <ctime>
#include <sys/types.h>
#include <unistd.h>
using namespace std;
#include "BlockQueue.hpp"
#include "Task.hpp"

int myadd(int x,int y)
{
    return x+y;
}
void* consumer(void *_bq)
{
    BlockQueue<Task> *bq = static_cast<BlockQueue<Task>*>(_bq);
    while(true)
    {

        //消费活动
        Task t;
        bq->pop(&t);
        std::cout<<"消费数据: "<<t()<<std::endl;
        sleep(1);

    }
    return nullptr;

}

void* productor(void *_bq)
{
    BlockQueue<Task> *bq = static_cast<BlockQueue<Task>*>(_bq);

    while(true)
    {
        //生产活动
        int x = rand()%10 +1;//1到10的数据
        int y = rand()%5 +1;//1到5
        Task t(x,y,myadd);
        bq->push(t);
        //std::cout<<"生产数据: "<<data<<std::endl;
    }
    return nullptr;

}
int main()
{
    srand((unsigned long)time(nullptr)^getpid());//随机生成数据据
    BlockQueue<Task>* bq = new BlockQueue<Task>();//阻塞队列

    pthread_t c,p;//消费者和生产者线程
    pthread_create(&c,nullptr,consumer,bq);//消费者 
    pthread_create(&p,nullptr,productor,bq);//生产者

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


    return 0; 
}

 

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

C++ 26 常用算法

目录 一、概述 1.1 常用遍历算法 1.1.1 算法简介 1.1.2 for_each遍历算法 1.1.3 transform遍历算法 1.2 常用查找算法 1.2.1 算法简介 1.2.2 find 查找算法 1.2.3 find_if 查找算法 1.2.4 adjacent_find 查找算法 1.2.5 binary_search 查找算法 1.2.6 count 查找算法…

【面试题】JS的一些优雅写法 reduce和map

大厂面试题分享 面试题库 前后端面试题库 &#xff08;面试必备&#xff09; 推荐&#xff1a;★★★★★ 地址&#xff1a;前端面试题库 web前端面试题库 VS java后端面试题库大全 JS的一些优雅写法 reduce 1、可以使用 reduce 方法来实现对象数组中根据某一key值求和 …

LFM雷达实现及USRP验证【章节3:连续雷达测距测速】

第一章介绍了在相对速度为0时候的雷达测距原理 目录 1. LFM测速 1.1 雷达测速原理 1.2 Chrip信号测速 2. LFM测速代码实现 参数设置 仿真图像 matlab源码 代码分析 第一章介绍了在相对速度为0时候的雷达测距原理&#xff0c;第二章介绍了基于LFM的雷达测距原理及其实现…

数据结构第十一期——线段树的原理和应用

目录 一、前言 二、线段树的概念 1、区间最值问题RMQ (Range Minimum/Maximum Query) &#xff08;1&#xff09;暴力法 &#xff08;2&#xff09;高效的办法&#xff1a;线段树 &#xff08;3&#xff09;把数列放在二叉树上 &#xff08;4&#xff09;查询最小值的复…

43-二叉树练习-LeetCode236二叉树的最近公共祖先

题目 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为&#xff1a;“对于有根树 T 的两个节点 p、q&#xff0c;最近公共祖先表示为一个节点 x&#xff0c;满足 x 是 p、q 的祖先且 x 的深度尽可能大&#xff08;一个节点也可以是它…

一款全新的基于GPT4的Python神器,关键还免费

chartgpt大火之后&#xff0c;随之而来的就是一大类衍生物了。 然后&#xff0c;今天要给大家介绍的是一款基于GPT4的新一代辅助编程神器——Cursor。 它最值得介绍的地方在于它免费&#xff0c;我们可以直接利用它来辅助我们编程&#xff0c;真正做到事半功倍。 注意&#…

k8s实践 | configmapsecretpvpvc

文章目录configmap&secret&pv&pvc一、configMap1、应用场景2、创建configMap2.1、help文档2.2、使用目录创建2.3、根据文件创建2.4、文字创建2.5、直接方法2.6、pod中应用2.7、热更新二、secret1、Service Account2、opaque Secret2.1、创建示例2.2、使用方式三、k…

eNSP 本地AAA配置实验

关于本实验本实验要求将路由器AR1配置为AAA服务器&#xff0c;以本地认证方式对尝试登录AR1的用户进行身份认证和授权。路由器AR2作为登录用户&#xff08;AAA客户端&#xff09;&#xff0c;以Telnet的方式登录AR1.读者需要在AR1中创建一个名为datacom的管理员域&#xff0c;并…

【Unity游戏开发教程】零基础带你从小白到超神22——旧动画和新动画组件的使用

制作一个动画 创建动画 添加变化属性 实现方块向右移动10 添加关键帧 实现先慢后快的效果 录制动画 旧动画组件(Animation组件) 如果想让一个游

PMP项管2023年5月的备考准备攻略!

2023年共有4次PMP考试&#xff0c;分别是3月、5月、8月、11月&#xff0c;由于3月份考试不开放新报名&#xff0c;所以第一次备考PMP的同学可以选择参加5月份考试。那么&#xff0c;现在备考5月份PMP考试还来得及吗&#xff1f; 现在开始备考5月PMP考试&#xff0c;时间是非常…

GEE:克里金 Kriging 插值(以陕西省2013年生物量为例)

本文记录了在Google Earth Engine(GEE)平台上进行 Kriging 插值的介绍和代码案例。本文通过选取的2013年陕西省生物量样本点数据为例,利用 Kriging 插值对未知区域做了插值计算。 Google Earth Engine(GEE)是一个用于分析地理空间数据的云平台,其中包含了许多地理空间分…

Office E5 OneDrive API使用指南:注册+密钥获取+获取临时上传链接+分片

异想之旅&#xff1a;本人原创博客完全手敲&#xff0c;绝对非搬运&#xff0c;全网不可能有重复&#xff1b;本人无团队&#xff0c;仅为技术爱好者进行分享&#xff0c;所有内容不牵扯广告。本人所有文章仅在CSDN、掘金和个人博客&#xff08;一定是异想之旅域名&#xff09;…

Java 各种锁的理解与实现

1. volatile 是轻量级锁&#xff1a; 只能修饰在变量上&#xff0c;使得 cpu 每次对于该变量的修改和读取都从内存中操作&#xff0c;而不是从CPU cache 中操作&#xff0c;保证共享变量对所有线程的可见性&#xff0c;但是并不能保证原子性 2. synchronized 悲观锁&#xff…

Mybatis的CRUD使用详解

文章目录一.Mybatis的CRUD使用详解1.1 select1.2 insert1.3 update1.3 delete二.常见错误一.Mybatis的CRUD使用详解 注意&#xff1a;增删改需要提交事务。 namespace&#xff08;UserMapper.xml&#xff09; namespace中的包名需要和Dao/mapper接口的包名一致。 <!--na…

论文阅读 10 | Instance Credibility Inference for Few-Shot Learning

小样本学习的实例可信度推理作者摘要1. Introduction2. Related Work作者 摘要 小样本学习&#xff08;FSL&#xff09;旨在识别每个类别极其有限的训练数据的新对象。以前的努力是通过利用元学习范式或数据增强中的新原理来缓解这个极其缺乏数据的问题。相比之下&#xff0c;本…

taro--之使用nutui组件库

安装 Taro 脚手架# 使用 npm 安装 CLI npm install -g tarojs/cli# 使用 yarn 安装 CLI yarn global add tarojs/cli# 使用 cnpm 安装 CLI cnpm install -g tarojs/cli使用 NutUI 模板创建项目1、使用命令创建 Taro 项目&#xff1a;taro init myApp2、按照下方图片依次选择&am…

ChatGPT如何批量撰写最新的热点自媒体文章

如何用ChatGPT创作高质量的自媒体文章 自媒体已成为互联网上的一个重要组成部分&#xff0c;无论您是想在社交媒体、博客中发布内容&#xff0c;高质量的文章都是自媒体成功的重要组成部分。ChatGPT是一个智能文章生成器&#xff0c;能够帮助创作者快速、高效地生成高质量的自…

数据结构——二叉搜索树

一、二叉搜索树概念 二叉搜索树又叫二叉排序树&#xff0c;它或是空树&#xff0c;或是具有以下性质的二叉树&#xff1a; &#xff08;1&#xff09;若它的左子树不为空&#xff0c;则左子树上的所有节点的值都小于根节点的值&#xff1b; &#xff08;2&#xff09;若它的…

LeetCode-718. 最长重复子数组

目录题目思路动态规划遇到的坑动态规划(优化)题目来源 718. 最长重复子数组 题目思路 用二维数组可以记录两个字符串的所有比较情况&#xff0c;这样就比较好推递推公式了。 动态规划 1.确定dp数组&#xff08;dp table&#xff09;以及下标的含义 dp[i][j]的定义也就决定…

【云原生】我将ChatGPT变成Kubernetes 和Helm 终端

{kubectl get po&#xff0c;deploy&#xff0c;svc}{kubectl run --imagenginx nginx-app --port80 --env“DOMAINcluster”}{kubectl expose deployment nginx-app --port80 --namenginx-http}{kubectl get po&#xff0c;svc&#xff0c;deploy}{curl 10.100.67.94:80}{helm…
最新文章