[项目设计] 从零实现的高并发内存池(五)

news/2024/4/13 12:20:34/文章来源:https://blog.csdn.net/sdhajkdghjkawhd/article/details/136517253

🌈 博客个人主页Chris在Coding

🎥 本文所属专栏[高并发内存池]

❤️ 前置学习专栏[Linux学习]

 我们仍在旅途                     

目录

8 使用定长内存池脱离new

9. 释放对象时不传大小

10.性能优化

        10.1 与malloc在多线程下对比测试

        10.2 性能瓶颈分析

        10.3 基于基数树的性能优化


 

8 使用定长内存池脱离new

在我们这个项目中,我们是为了在高并发场景下替代 malloc 函数的使用,决定使用 tcmalloc,但由于 tcmalloc 内部不能调用 malloc 函数,因此需要避免直接使用 new 来申请内存。而我们之前使用的new 实际上是封装了 malloc 函数。 为了彻底摆脱对 malloc 函数的依赖,我们这里就要利用之前实现的定长内存池。

class PageCache
{
public:// ...
private:// ...ObjMemoryPool<Span, 18000> _Spanpool;
};

这个定长内存池主要用于管理 Span 结构的对象申请和释放,而 Span 对象在系统中主要是在 层创建的。 因此,在 PageCache 类中定义了一个_Spanpool,用于 Span 对象的申请和释放。这样一来,系统在申请 Span 对象的空间时,可以直接从_Spanpool 中获取,而不需要通过调用 malloc 函数。这样做可以彻底避免对 malloc 函数的调用,使得系统更加适合在高并发场景下运行,并且能够充分利用 tcmalloc 提供的内存管理功能。这里为了应对大量的内存申请释放我们将每一次申请的Span个数设置为了18000,具体数字可以自行斟酌。

Span* span = _Spanpool.New();
_Spanpool.Delete(span);

现在我们就可以将之前的new,delete分别改写成我们新的接口 


之后我们也记得将申请ThreadCache的部分也替换,但是要注意的是此处从该定长内存池中申请内存时需要加锁,防止多个线程同时申请自己的ThreadCache对象而导致线程安全问题。

static void* ConcurrentAlloc(size_t size)
{// ...if (pTLSThreadCache == nullptr){static ObjMemoryPool<ThreadCache, 50> TdPool;static std::mutex tdMtx;tdMtx.lock();pTLSThreadCache = TdPool.New();tdMtx.unlock();}// ...
}

9. 释放对象时不传大小

实际上在使用free去释放内存时,我们是不会去传入申请的内存块的大小,所以这里实现的接口也应该能做到不传入对象的大小也能正常释放内存

为了实现在释放对象时不再需要显式传入对象的大小,我们可以通过在 Span 结构中增加一个 _size 成员来实现。每个 Span 管理的内存块被切分成多个对象,而这些对象的大小可能不同。因此,为每个 Span 增加一个_size 成员,用于表示这个 Span 管理的内存块被切分的对象的大小。这样一来,在释放对象时,系统可以通过对象的地址找到其对应的 Span,并从中获取对象的大小,而无需显式传入对象的大小。

struct Span
{PAGEID _pageId = 0;size_t _n = 0;Span* _next = nullptr;Span* _prv = nullptr;size_t _used = 0;void* _freeList = nullptr;bool _isused = false;size_t _size = 0;
};

而所有的Span都是从PageCache中拿出来的,因此每当我们调用NewSpan获取到一个k页的Span时,就应该将这个Span的_size确定下来。

Span* CentralCache::GetOneSpan(SpanList& list, size_t align_size)
{// ...PageCache::GetInstance()._pagemtx.lock();Span* span = PageCache::GetInstance().NewSpan(SizeTable::PageSizeLimit(align_size));span->_size = align_size;span->_isused = true;PageCache::GetInstance()._pagemtx.unlock();// ...
}

这里我们还要记得给申请大于256KB内存时获得的kspan写上size大小

static void* ConcurrentAlloc(size_t size)
{if (size > MAXSIZE){// ...PageCache::GetInstance()._pagemtx.lock();Span* span = PageCache::GetInstance().NewSpan(kpage);span->_size = size;PageCache::GetInstance()._pagemtx.unlock();// ...}// ...
}

现在当我们释放对象时,就不用再传入大小了。

static void ConcurrentFree(void* ptr)
{Span* span = PageCache::GetInstance().MapObjToSpan(ptr);size_t size = span->_size;if (size > MAXSIZE){Span* span = PageCache::GetInstance().MapObjToSpan(ptr);//超过256KB的内存,ThreadCache中无法维护,都是以Span类型储存并维护PageCache::GetInstance()._pagemtx.lock();PageCache::GetInstance().ReleaseSpanToPageCache(span);PageCache::GetInstance()._pagemtx.unlock();}else{assert(pTLSThreadCache);pTLSThreadCache->deallocate(ptr, size);}
}

10.性能优化

        10.1 与malloc在多线程下对比测试

#include"ConcurrentAlloc.h"// ntimes 一轮申请和释放内存的次数
// rounds 轮次
void BenchmarkMalloc(size_t ntimes, size_t nworks, size_t rounds)
{std::vector<std::thread> vthread(nworks);std::atomic<size_t> malloc_costtime = 0;std::atomic<size_t> free_costtime = 0;for (size_t k = 0; k < nworks; ++k){vthread[k] = std::thread([&, k]() {std::vector<void*> v;v.reserve(ntimes);for (size_t j = 0; j < rounds; ++j){size_t begin1 = clock();for (size_t i = 0; i < ntimes; i++){//v.push_back(malloc(16));v.push_back(malloc((16 + i) % 8192 + 1));}size_t end1 = clock();size_t begin2 = clock();for (size_t i = 0; i < ntimes; i++){free(v[i]);}size_t end2 = clock();v.clear();malloc_costtime += (end1 - begin1);free_costtime += (end2 - begin2);}});}for (auto& t : vthread){t.join();}printf("%u个线程并发执行%u轮次,每轮次malloc %u次: 花费:%u ms\n",nworks, rounds, ntimes, (size_t)malloc_costtime);printf("%u个线程并发执行%u轮次,每轮次free %u次: 花费:%u ms\n",nworks, rounds, ntimes, (size_t)free_costtime);printf("%u个线程并发malloc&free %u次,总计花费:%u ms\n",nworks, nworks * rounds * ntimes, (size_t)malloc_costtime + free_costtime);
}// 单轮次申请释放次数 线程数 轮次
void BenchmarkConcurrentMalloc(size_t ntimes, size_t nworks, size_t rounds)
{std::vector<std::thread> vthread(nworks);std::atomic<size_t> malloc_costtime = 0;std::atomic<size_t> free_costtime = 0;for (size_t k = 0; k < nworks; ++k){vthread[k] = std::thread([&]() {std::vector<void*> v;v.reserve(ntimes);for (size_t j = 0; j < rounds; ++j){size_t begin1 = clock();for (size_t i = 0; i < ntimes; i++){//v.push_back(ConcurrentAlloc(16));v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));}size_t end1 = clock();size_t begin2 = clock();for (size_t i = 0; i < ntimes; i++){ConcurrentFree(v[i]);}size_t end2 = clock();v.clear();malloc_costtime += (end1 - begin1);free_costtime += (end2 - begin2);}});}for (auto& t : vthread){t.join();}printf("%u个线程并发执行%u轮次,每轮次concurrent alloc %u次: 花费:%u ms\n",nworks, rounds, ntimes, (size_t)malloc_costtime);printf("%u个线程并发执行%u轮次,每轮次concurrent dealloc %u次: 花费:%u ms\n",nworks, rounds, ntimes, (size_t)free_costtime);printf("%u个线程并发concurrent alloc&dealloc %u次,总计花费:%u ms\n",nworks, nworks * rounds * ntimes, (size_t)malloc_costtime + free_costtime);
}int main()
{size_t n = 10000;cout << "==========================================================" << endl;BenchmarkConcurrentMalloc(n, 4, 10);cout << endl << endl;BenchmarkMalloc(n, 4, 10);cout << "==========================================================" << endl;return 0;
}

经过测试我们会发现我们现在实现的TcMalloc跟malloc在多线程情况下相比仍显得捉襟见肘, 这里我们进一步分析再次优化我们得代码

        10.2 性能瓶颈分析

这里我使用的是VS2022自带的性能探查器,这里我们先进入项目属性页面,把链接器下面高级这一栏中的配置文件改成/PROFILE

 再进入调试栏打开性能探查器

 

 等待系统分析结束后,我们可以得到这样的分析结果

这里我们不难发现,内存块的释放其实占用了大部分的运行时间,而其中花费时间最多的就是MapObjToSpan

通过分析我们不难得出,之所以调用MapObjToSpan会花费如此多的时间,其主要原因是因为在锁的竞争上,因此本项目的性能优化点就在于解决映射时,锁的竞争问题

        10.3 基于基数树的性能优化

基数树(Radix Trie)是一种多叉树,也称为基数特里树或压缩前缀树。相比于普通的Trie(前缀树),基数树具有更高的空间利用率。在基数树中,具有唯一子节点的每个节点都与其父节点合并,这样可以大大减少内部节点的数量,提高了空间利用率。

 为什么使用基数树不需要加锁?

  1. 对于使用 C++ 中的 mapunordered_map 进行映射关系的读取,需要加锁的原因在于它们的底层数据结构(红黑树和哈希表)在插入数据时可能会引起结构变化,为了避免数据不一致性问题,需要在读取操作时加锁。

  2. 相比之下,基数树的特性不同。基数树在空间开辟后不会发生结构变化,因此不需要在读取操作时加锁。此外,基数树的读取和建立映射操作不会同时对同一个页进行操作,因为读取映射时是针对 _useCount 不为 0 的页,而建立映射时是针对 _useCount 等于 0 的页,所以不存在同时对同一页面进行读取和建立映射操作的情况。

 二层基数树

在32位的环境下,一页的大小为8K为例,此时存储页号最多需要19个比特位。而二层基数树实际上就是把这19个比特位分为两次进行映射。

比如用前5个比特位在基数树的第一层进行映射,映射后得到对应的第二层,然后用剩下的比特位在基数树的第二层进行映射,映射后最终得到该页号对应的span指针。

在二层基数树中,第一层的数组占用的空间为 2^{5} X 4 = 2^{7} 字节(即 128 字节),而第二层的数组最多占用的空间为 2^{5}​​X 2^{14}X 4 = 2^{7}  字节(即 2 MB)。这意味整个二层基数树加起来对系统的花销并不大。

二层基数树只需要在一开始分配第一层的数组空间,当需要对某个页面号进行映射时,再分配相应的第二层数组空间即可。这种延迟分配的策略可以节省内存,并在实际需要时才分配所需的内存空间,提高了内存的利用率。

template<int bits>
class PageMap_Two
{
private:static const int _rootbits = 5;static const int _leafbits = bits - _rootbits;static const int _rootlen = 1 << _rootbits;static const int _leaflen = 1 << _leafbits;struct Leaf{void* _points[_leaflen];};Leaf* _root[_rootlen];
public:PageMap_Two(){//先把root层清理干净memset(_root, 0, sizeof _root);_PreMemoryAlloc();}inline void _Ensure(size_t start, size_t n){for (uintptr_t key = start; key <= start + n - 1;){const uintptr_t i1 = key >> _leafbits;if (_root[i1] == NULL) //第一层i1下标指向的空间未开辟{//开辟对应空间static ObjMemoryPool<Leaf, 100>leafPool;Leaf* leaf = (Leaf*)leafPool.New();memset(leaf, 0, sizeof(*leaf));_root[i1] = leaf;}key = ((key >> _leafbits) + 1) << _leafbits; //继续后续检查}}void _PreMemoryAlloc(){_Ensure(0, 1 << bits);}void* get(uintptr_t k) const{const uintptr_t i1 = k >> _leafbits;const uintptr_t i2 = k & (_leaflen - 1);if ((k >> bits) > 0 || _root[i1] == nullptr) {return nullptr;}return _root[i1]->_points[i2];}void set(uintptr_t k, void* v) {const uintptr_t i1 = k >> _leafbits;const uintptr_t i2 = k & (_leaflen - 1);assert(i1 < _rootlen);_root[i1]->_points[i2] = v;}
};
  • 类模板 PageMap_Two 接受一个整数模板参数 bits,用于确定页面编号的位数。
  • 类内部定义了一个名为 Leaf 的结构体,用于表示基数树的叶子节点,每个叶子节点包含一个指针数组 _points,用于存储页面的指针。
  • 类内部使用 _root 数组来表示基数树的根节点数组,数组长度为 _rootlen,每个元素存储一个指向叶子节点的指针。
  • 构造函数 PageMap_Two() 初始化 _root 数组,并调用 _PreMemoryAlloc() 函数预先分配内存。
  • _PreMemoryAlloc() 函数用于预先分配内存空间,确保根据页面编号的位数 bits 来确定需要的节点数量,并对应创建相应的叶子节点。
  • get(uintptr_t k) 函数用于根据页面编号 k 获取对应页面的指针。它首先计算页面编号所在的根节点索引 i1 和叶子节点索引 i2,然后根据索引访问对应的叶子节点 _root[i1] 并返回指针数组 _points[i2] 中的值。
  • set(uintptr_t k, void* v) 函数用于设置页面编号为 k 的页面指针为 v。它首先计算页面编号所在的根节点索引 i1 和叶子节点索引 i2,然后直接将指针 v 赋值给 _root[i1] 的指针数组 _points[i2]。 

 三层基数树 

在64位系统下,页面编号需要更多的位数来表示,因此使用三层基数树可以更有效地管理页面的映射关系。下面是为什么需要在64位系统下使用三层基数树的几个原因:

  1. 更大的地址空间: 在64位系统下,地址空间更大,通常为 2^{64},因此需要更多的位来表示页面编号。单层基数树可能不足以覆盖整个地址空间,因此需要更多的层级来管理更多的页面编号。

  2. 减少内存消耗: 在64位系统下,单层基数树需要分配更大的数组来存储映射关系,这可能会导致较大的内存消耗。使用多层基数树可以将地址空间分成更小的部分,每一层的数组大小相对较小,从而减少了每层的内存消耗。

  3. 更快的查找速度: 在多层基数树中,每一层的数组相对较小,因此可以更快地进行查找操作。单层基数树可能会出现较深的树结构,导致查找速度较慢,而多层基数树可以将查找路径分解成多个较短的路径,提高了查找效率。

template <int bits>
class PageMap_Three
{
private:static const int _interiorbits = (bits + 2) / 3;       //第一、二层对应页号的比特位个数static const int _interiorlen = 1 << _interiorbits; //第一、二层存储元素的个数static const int _leafbits = bits - 2 * _interiorbits; //第三层对应页号的比特位个数static const int _leaflen = 1 << _leafbits;         //第三层存储元素的个数struct Node{Node* nodes[_interiorlen];};struct Leaf{void* points[_leaflen];};Node* NewNode(){static ObjMemoryPool<Node, 1000> nodePool;Node* result = nodePool.New();if (result != NULL){memset(result, 0, sizeof(*result));}return result;}Node* _root;
public:PageMap_Three(){_root = NewNode();}void* get(uintptr_t k) const{const uintptr_t i1 = k >> (_leafbits + _interiorbits);         //第一层对应的下标const uintptr_t i2 = (k >> _leafbits) & (_interiorlen - 1); //第二层对应的下标const uintptr_t i3 = k & (_leaflen - 1);                    //第三层对应的下标//页号超出范围,或映射该页号的空间未开辟if ((k >> bits) > 0 || _root->nodes[i1] == NULL || _root->nodes[i1]->nodes[i2] == NULL){return NULL;}return reinterpret_cast<Leaf*>(_root->nodes[i1]->nodes[i2])->points[i3]; //返回该页号对应span的指针}void set(uintptr_t  k, void* v){assert(k >> bits == 0);const uintptr_t i1 = k >> (_leafbits + _interiorbits);         //第一层对应的下标const uintptr_t i2 = (k >> _leafbits) & (_interiorlen - 1); //第二层对应的下标const uintptr_t i3 = k & (_leaflen - 1);                    //第三层对应的下标Ensure(k, 1); //确保映射第k页页号的空间是开辟好了的reinterpret_cast<Leaf*>(_root->nodes[i1]->nodes[i2])->points[i3] = v; //建立该页号与对应span的映射}//确保映射[start,start+n-1]页号的空间是开辟好了的void Ensure(uintptr_t start, size_t n){for (uintptr_t key = start; key <= start + n - 1;){const uintptr_t i1 = key >> (_leafbits + _interiorbits);         //第一层对应的下标const uintptr_t i2 = (key >> _leafbits) & (_interiorlen - 1); //第二层对应的下标if (_root->nodes[i1] == NULL) //第一层i1下标指向的空间未开辟{//开辟对应空间Node* n = NewNode();_root->nodes[i1] = n;}if (_root->nodes[i1]->nodes[i2] == NULL) //第二层i2下标指向的空间未开辟{//开辟对应空间static ObjMemoryPool<Leaf, 100> leafPool;Leaf* leaf = leafPool.New();;memset(leaf, 0, sizeof(*leaf));_root->nodes[i1]->nodes[i2] = reinterpret_cast<Node*>(leaf);}key = ((key >> _leafbits) + 1) << _leafbits; //继续后续检查}}
};

 代码更改

class PageCache
{
public:static PageCache& GetInstance(){return _SingleInstance;}std::mutex _pagemtx;Span* NewSpan(size_t k);Span* MapObjToSpan(void* obj);void ReleaseSpanToPageCache(Span* span);
private:PageCache(){}PageCache(const PageCache&) = delete;static PageCache  _SingleInstance;SpanList _Spanlists[NPAGES];/*std::unordered_map<PAGEID,Span*> _IdToSpan;*/
#ifdef _WIN64PageMap_Three <64 - PAGESHIFT> _IdToSpan;
#elif _WIN32PageMap_Two <32 - PAGESHIFT> _IdToSpan;
#endifObjMemoryPool<Span, 18000> _Spanpool;
};

同时我们的MapObjSpan也不需要再加锁访问 

Span* PageCache::MapObjToSpan(void* obj)
{PAGEID id = ((PAGEID)obj >> PAGESHIFT);Span* ret = (Span*)_IdToSpan.get(id);if (ret != nullptr){return ret;}else{assert(false);return nullptr;}
}

 此时当我们需要建立页号与span的映射时,就调用基数树当中的set函数。

_IdToSpan.set(span->_pageId, span);

而当我们需要读取某一页号对应的span时,就调用基数树当中的get函数。

Span* ret = (Span*)_IdToSpan.get(id);

更改后再次运行测试程序,我们可以明显看到优化效果

 

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

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

相关文章

强大的ps 命令 -o 自定义输出内容选项

强大的ps 命令 -o 自定义输出内容选项 1、ps命令介绍和作用2、问题描述 1、ps命令介绍和作用 ps 是一个 Unix 和类 Unix 操作系统中常用的命令&#xff0c;用于显示当前运行的进程信息。ps 命令的作用包括&#xff1a; 查看进程信息&#xff1a; ps 命令可以列出当前系统中正…

SL1585 24V降压5V电源芯片 24V降压3.3V电源芯片

SL1585 24V降压5V电源芯片与24V降压3.3V电源芯片是两款广泛应用于电子设备中的电源管理芯片。它们的主要功能是将较高的输入电压&#xff08;通常为24V&#xff09;降至更低的输出电压&#xff08;分别为5V和3.3V&#xff09;&#xff0c;以满足各种电子元器件的供电需求。在深…

Redis中的RDB和AOF持久化机制(一)

Redis持久化 RDB快照(snapshot). 在默认情况下&#xff0c;Redis将内存数据库快照保存在名字为dump.rdb的二进制文件中.Redis可以进行设置,让它在"N秒内数据集至少有M个改动"这一条件被满足时&#xff0c;自动保存一次数据集。比如说&#xff0c;以下设置会让Redis…

ZYNQ--MIG核配置

文章目录 MIG核配置界面多通道AXI读写DDR3MIG核配置界面 Clock Period: DDR3 芯片运行时钟周期,这个参数的范围和 FPGA 的芯片类型以及具体类型的速度等级有关。本实验选择 1250ps,对应 800M,这是本次实验所采用芯片可选的最大频率。注意这个时钟是 MIG IP 核产生,并输出给…

手写分布式配置中心(二)实现分布式配置中心的简单版本

这一篇文章比较简单&#xff0c;就是一个增删改查的服务端和一个获取配置的客户端&#xff0c;旨在搭建一个简单的配置中心架构&#xff0c;代码在 https://gitee.com/summer-cat001/config-center 服务端 服务端选择用springboot 2.7.14搭建&#xff0c;设计了4个接口/confi…

<网络安全>《61 微课堂<第1课 南北向流量是什么?>》

1 形象化解释 在网络安全中&#xff0c;经常听到南北向流量这个词。那究竟是什么意思呢&#xff1f; 这里的南北&#xff0c;就是地图上的东西南北&#xff0c;是方向。我们在画网络架构图时&#xff0c;往往是由上到下依次是web层、应用层、数据层&#xff0c;流量从web层到…

coqui-ai/TTS 安装使用

Coqui AI的TTS是一款开源深度学习文本转语音工具&#xff0c;以高质量、多语言合成著称。它提供超过1100种语言的预训练模型库&#xff0c;能够轻松集成到各种应用中&#xff0c;并允许用户通过简单API进行个性化声音训练与微调。其技术亮点包括但不限于低资源适应性&#xff0…

企业IPv6网关负载分担方案的设计与实现

背景需求 &#xff08;1&#xff09;随着企业业务数量大幅增加&#xff0c;以及网络应用的高速发展&#xff0c;现有IPv4地址已不能满足需求&#xff0c;根据通信架构合理规划IPv6网络&#xff0c;对企业网络进行构建及扩充。 &#xff08;2&#xff09;企业业务量上升网络主…

Linux--Redis 群集

9.1.1 关系型数据库与非关系型数据库 数据库按照其结构可以分为关系型数据库与其他数据库&#xff0c;而这些其他数据库我们将其统称为非 关系型数据库。Redis数据库是一个非关系型数据库。 1、关系型数据库 关系型数据库是一个结构化的数据库&#xff0c;创建在关系模型基础上…

Seata 2.x 系列【2】数据库事务

有道无术&#xff0c;术尚可求&#xff0c;有术无道&#xff0c;止于术。 本系列Spring Boot 版本 3.1.0 本系列Seata 版本 2.0.0 源码地址&#xff1a;https://gitee.com/pearl-organization/study-seata-demo 文章目录 1. 概述2. ACID 模型2.1 原子性2.2 一致性2.3 隔离性2…

ChatGPT如何干涉教育?

OpenAI又整大活儿了。 他们在ChatGPT引入了自定义指令&#xff0c;什么是自定义指令呢&#xff0c;我截图了他们在推特上发布的解释&#xff0c;比较让人期待的是&#xff0c;现在ChatGPT能够更好地为小说和编剧们服务了&#xff0c;以及&#xff0c;它可以模仿你的语言风格&a…

element-ui radio 组件源码分享

今日简单分享 radio 组件的实现原理&#xff0c;主要从以下三个方面来分享&#xff1a; 1、radio 页面结构 2、radio 组件属性 3、radio 组件方法 一、radio 页面结构 1.1 页面结构如下&#xff1a; 二、radio 属性 2.1 value / v-model 属性&#xff0c;类型为 string / …

【C++】C/C++内存管理详解

个人主页 &#xff1a; zxctscl 文章封面来自&#xff1a;艺术家–贤海林 如有转载请先通知 目录 1. 前言2. C/C内存分布3. C语言中动态内存管理方式4. C中动态内存管理4.1 new/delete操作内置类型4.2 new和delete操作自定义类型 5. operator new与operator delete函数5.1 oper…

Claude3、Gemini、Sora VS GPT-4:AI技术如何助力科研与产业发展?

【最新增加Claude3、Gemini、Sora、GPTs讲解及AI领域中的集中大模型的最新技术】 2023年随着OpenAI开发者大会的召开&#xff0c;最重磅更新当属GPTs&#xff0c;多模态API&#xff0c;未来自定义专属的GPT。微软创始人比尔盖茨称ChatGPT的出现有着重大历史意义&#xff0c;不亚…

社区店选址评估:利用大数据选址的技巧与策略

在当今数字化的时代&#xff0c;利用大数据进行社区店选址评估已成为一种高效、科学的方法。作为一名开鲜奶吧5年的创业者&#xff0c;我将分享一些利用大数据选址的技巧与策略&#xff0c;帮助你找到最适合的店铺位置。 1、确定目标商圈 在选址之前&#xff0c;首先要明确自己…

C++初阶:初识C++

目录 1. 前言&#xff1a;C 与 C语言2. C对于C语言语法的完善与补充2.1 命名冲突与命名空间2.1.1 命名空间的定义2.1.2 调用方式 2.3 补充&#xff1a;流的概念2.4 缺省参数2.4.1 缺省参数的使用 2.5 函数重载2.5.1 什么是函数重载2.5.2 函数重载的使用2.5.3 特殊情况&#xff…

SpringBoot 热部署。

SpringBoot 热部署。 文章目录 SpringBoot 热部署。 pom.xml。 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional…

Android 12.0 系统wifi列表显示已连接但无法访问网络问题解决

1.前言 在12.0的系统rom产品定制化开发中,在wifi模块也很重要,但是在某些情况下对于一些wifi连接成功后,确显示已连接成功,但是无法访问互联网 的情况,所以实际上这时可以正常上网的,就是显示的不正常,所以就需要分析连接流程然后解决问题 如图所示: 2.系统wifi列表显示…

IEEE 802.11 RTS/CTS/BA/Management

RTS/CTS IEEE 802.11 RTS/CTS即RTS/CTS协议(Request To Send/Clear To Send)即请求发送/清除发送协议是被802.11无线网络协议采用的一种用来减少由隐藏节点问题所造成的冲突的机制。 相当于一种握手协议,主要用来解决"隐藏终端"问题。"隐藏终端"(Hid…

HTML静态网页成品作业(HTML+CSS)——舞蹈网页设计制作(5个页面)

&#x1f389;不定期分享源码&#xff0c;关注不丢失哦 文章目录 一、作品介绍二、作品演示三、代码目录四、网站代码HTML部分代码CSS部分代码 五、源码获取 一、作品介绍 &#x1f3f7;️本套采用HTMLCSS&#xff0c;未使用Javacsript代码&#xff0c;共有5个页面。 &#x1…