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

🌈 博客个人主页：Chris在Coding

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

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

⏰ 我们仍在旅途                     

​

目录

6.内存回收

        6.1 ThreadCache回收内存

        6.2 CentralCache回收内存

        ReleaseListToSpans

        MapObjToSpan

         6.3 PageCache回收内存

        ReleaseSpanToPageCache

回收内存测试

7.解决大内存申请释放

        7.1 申请内存

        RoundUp

        ConcurrentAlloc

        NewSpan

        7.2 释放内存

        ConcurrentFree

        ReleaseSpanToPageCache

大内存测试

6.内存回收

        6.1 ThreadCache回收内存

这是之前我们deallocate的代码:

//void ThreadCache::deallocate(void* ptr, size_t size)
//{
//	assert(ptr);
//	assert(size <= MAXSIZE);
//	// 找对映射的空闲链表桶，对象插入进入
//	size_t index = SizeTable::Index(size);
//	_freelists[index].push(ptr);
//}

这样可能潜在着这样的问题 : 随着线程不断的释放，对应自由链表的长度也会越来越长，这些内存堆积在一个ThreadCache中如果不去使用那么其实就是一种浪费，因此我们应该将这些内存还给CentralCache。这样一来，这些内存对其他线程来说也是可申请的，因此当ThreadCache某个桶当中的自由链表太长时我们应该做更多处理。

 于是我们在原来的基础上加入下面的判断:

inline void _FreeListTooLong(FreeList& list, size_t size)
{//我们从_FreeList中抽回MaxSize,返还给CentralCachevoid* start = nullptr;list.pop_range(start,list.MaxSize());CentralCache::GetInstance().ReleaseListToSpans(start, size);
}
void ThreadCache::deallocate(void* ptr, size_t size)
{assert(ptr);assert(size <= MAXSIZE);// 找对映射的自由链表桶，对象插入进入size_t index = SizeTable::Index(size);_freelists[index].push(ptr);if (_freelists[index].size() > _freelists[index].MaxSize()){//_FreeList过长了_FreeListTooLong(_freelists[index],size);}
}

这里我们选择认为,当该空闲链表的内存块数量大于该链表可以向CentralCache申请的数量时,我们就执行_FreeListTooLong的逻辑归还

因为空闲链ReleaseListToSpans表用到内存块数量,这里我们就得对之前的FreeList类进行一些改造以适应需求

class FreeList
{
public:void push(void* obj) {// ...++_size;}void push_range(void* start, void* end,size_t n){// ..._size += n;}void* pop() //头删{// ...--_size;return obj;}// ...size_t size(){return _size;}void pop_range(void*& start,size_t n){assert(n <= _size);start = _FreeList;void* end = start;for (int i = 0; i < n - 1; i++){end = *(void**)end;}_FreeList = *(void**)end;*(void**)end = nullptr;_size-=n;}
private:// ...size_t _size = 0;
};

因为这里我们改动了push_range接口,那么当时ThreadCache从CentralCache获取了actual_num个对象，剩下的actual_num-1个挂到了ThreadCache对应的桶当中的代码也会随之修改

_freelists[index].push_range(*(void**)start, end,actual_num-1);

        6.2 CentralCache回收内存

ReleaseListToSpans

void CentralCache::ReleaseListToSpans(void* start, size_t size)
{//先找到派发出_FreeList的span类//该过程中会改动span类需要加锁size_t index = SizeTable::Index(size);_spanlists[index]._mtx.lock();while (start){void* next = *(void**)start;Span* span=PageCache::GetInstance().MapObjToSpan(start);*(void**)start = span->_freeList;span->_freeList = start;span->_used--;if (span->_used == 0){_spanlists->erase(span);span->_next = nullptr;span->_prv = nullptr;span->_freeList = nullptr;_spanlists[index]._mtx.unlock();PageCache::GetInstance()._pagemtx.lock();PageCache::GetInstance().ReleaseSpanToPageCache(span);PageCache::GetInstance()._pagemtx.unlock();_spanlists[index]._mtx.lock();}start = next;}_spanlists[index]._mtx.unlock();
}
  • SizeTable::Index(size)：根据对象大小确定在大小表中的索引，用于找到对应的 span 列表。
  • 锁操作：在对 span 列表进行操作时，先对其加锁 _mtx，以确保线程安全。
  • 遍历释放对象：通过循环遍历释放对象，首先获取下一个对象的指针 next，然后根据对象的地址找到其对应的 span，将当前对象插入到 span 的空闲列表 _freeList 中，并更新 span 的使用计数 _used。
  • 判断 span 是否完全空闲：如果 span 的使用计数 _used 减为 0，表示这个 span 分配出去的对象全部都已经回收回来了。在这种情况下，需要将该 span 从 span 列表 _spanlists[index] 中移除，并将其自身的指针 _next、_prev、_freeList 置空。
  • 回收 span：一旦确定要回收 span，就需要将其释放回页缓存（PageCache）中。这一步涉及到了两个锁的操作，首先释放 span 需要持有 _pagemtx 锁，以确保对页缓存的操作线程安全；同时，也需要确保释放 span 的过程是原子的，因此在释放前后都需要释放掉 _spanlists[index]._mtx 锁。

MapObjToSpan

通过内存块地址怎么找到原先的Sapn

在实现ReleaseListToSpans时,我们是默认通过MapObjToSpan()实现从内存块地址找到Span。

首先我们必须理解的是，某个页当中的所有地址除以页的大小都等该页的页号。比如我们这里假设一页的大小是100，那么地址0~99都属于第0页，它们除以100都等于0，而地址100~199都属于第1页，它们除以100都等于1。

虽然我们现在可以通过对象的地址得到其所在的页号，但是我们还是不能知道这个对象到底属于哪一个span。因为一个span管理的可能是多个页。为了解决这个问题，我们可以建立页号和span之间的映射。这里可以用C++当中的unordered_map进行实现，并且添加一个函数接口，用于让central cache获取这里的映射关系。

class PageCache
{
public:// ...Span* MapObjToSpan(void* obj);
private:// ...std::unordered_map<PAGEID,Span*> _IdToSpan;
};
Span* PageCache::MapObjToSpan(void* obj)
{PAGEID id = ((PAGEID)obj >> PAGESHIFT);std::unique_lock<std::mutex> lock(_pagemtx);auto ret = _IdToSpan.find(id);if (ret != _IdToSpan.end()){return ret->second;}else{assert(false);return nullptr;}
}

 建立映射关系

在 PageCache 类中，当分配 Span 给 CentralCache 时，需要记录下分配的 span 的页号和 span 之间的映射关系。因此，在 NewSpan 函数中，分配完 Span 后，我们会遍历该 Span 的所有页，将每个页号与该 Span 建立映射关系。

Span* PageCache::NewSpan(size_t k)
{if (!_Spanlists[k].empty()){Span* kspan = _Spanlists[k].pop_front();for (PAGEID i = 0; i < kspan->_n; i++){_IdToSpan[kspan->_pageId + i] = kspan;}return kspan;}for (size_t n = k + 1; n < NPAGES; n++){if (!_Spanlists[n].empty()){Span* nspan = _Spanlists[n].pop_front();Span* kspan = new Span;kspan->_pageId = nspan->_pageId;kspan->_n = k;nspan->_pageId += k;nspan->_n -= k;_Spanlists[nspan->_n].push_front(nspan);for (PAGEID i = 0; i < kspan->_n; i++){_IdToSpan[kspan->_pageId + i] = kspan;}return kspan;}}Span* maxspan = new Span;void* ptr = SystemAlloc(NPAGES - 1);maxspan->_pageId = (PAGEID)ptr >> PAGESHIFT;maxspan->_n = NPAGES - 1;_Spanlists[maxspan->_n].push_front(maxspan);return NewSpan(k);
}

         6.3 PageCache回收内存

Page Cache 回收内存的过程是为了释放已经被 Central Cache 使用过的 Span，并尝试将这些 Span 与其他空闲的 Span 进行合并，从而缓解内存碎片问题。

这个过程涉及以下几个关键步骤：

  • 判断 Span 是否可以合并： 首先，需要判断回收的 Span 周围是否有空闲的 Span 可以合并。这包括向前合并和向后合并两种情况。如果回收的 Span 的前后页号对应的 Span 存在且未被使用，则可以进行合并。

  • 向前合并和向后合并： 如果条件允许，就可以进行向前和向后的合并操作。向前合并就是将回收的 Span 与前一个未使用的 Span 进行合并，向后合并则是将回收的 Span 与后一个未使用的 Span 进行合并。合并的过程包括更新 Span 的起始页号和页数，并从 Page Cache 的对应双链表中移除被合并的 Span。

  • 建立映射关系： 在合并结束后，需要重新建立 Span 的页号与 Span 之间的映射关系，以便后续操作能够快速定位到对应的 Span。这包括更新合并后 Span 的首尾页号与 Span 之间的映射关系，并将合并后的 Span 挂到对应的双链表中。

  • 更新 Span 的状态： 最后，需要将合并后的 Span 标记为未被使用的状态，以便之后的分配过程能够正确识别并使用这些 Span。

通过以上步骤，Page Cache 在回收内存时不仅释放了被使用过的 Span，还尝试将空闲的 Span 进行合并，以优化内存的利用效率，并且通过建立映射关系，确保后续操作能够快速定位到对应的 Span，提高了内存回收的效率和性能。

如何判断Span是否正在使用

由于PageCache回收内存的步骤中涉及到了Span内存块的合并,在这一过程中判断Span内存块是否正在使用将很重要。但是我们不能通过Span结构当中的_used成员，来判断某个Span到底是在CentralCache还是在PageCache。因为当CentralCache刚向PageCache申请到一个Span时，这个span的_used就是等于0的，这时可能当我们正在对该Span进行切分的时候，PageCache就把这个Span拿去进行合并了。

为了避免这些问题,我们直接在最初就给Span类中新增一个成员变量用来标记这个Span内存块是否正在使用的过程中。

struct Span
{// ...bool _isused = false;
};

因此当central cache向page cache申请到一个span时，需要立即将该span的_isUse改为true。

span->_isused = true;

而当central cache将某个span还给page cache时，也就需要将该span的_isUse改成false。

span->_isused = false;

ReleaseSpanToPageCache

void PageCache::ReleaseSpanToPageCache(Span* span)
{//先判断销毁的span类型是不是大于能维护的最大值if (span->_n>NPAGES-1){//直接调用系统接口销毁void* ptr = (void*)(span->_pageId<<PAGESHIFT);SystemFree(ptr);_Spanpool.Delete(span);return;}// 对span前后的页，尝试进行合并，缓解内存碎片问题while (1){PAGEID prvid = span->_pageId - 1;Span* prvit = (Span*)_IdToSpan.get(prvid);if (prvit == nullptr|| prvit->_isused == true||(prvit->_n+span->_n)>NPAGES-1) //前页不在或在使用或合成后超过最大值{break;}span->_pageId = prvit->_pageId;span->_n += prvit->_n;_Spanlists[prvit->_n].erase(prvit);_Spanpool.Delete(prvit);}while (1){PAGEID nxtid = span->_pageId +span->_n;Span* nxtit = (Span*)_IdToSpan.get(nxtid);if (nxtit == nullptr || nxtit->_isused == true || (nxtit->_n + span->_n) > NPAGES - 1) //后页不在或在使用或合成后超过最大值{break;}span->_pageId = nxtit->_pageId;span->_n += nxtit->_n;_Spanlists[nxtit->_n].erase(nxtit);_Spanpool.Delete(nxtit);}_Spanlists[span->_n].push_front(span);span->_isused = false;//此时从span->_pageId到span->_pageId + span->_n - 1页的所有Id在_IdToSpan的映射关系还没有更新,但没必要现在更新,在newspan时,会覆盖原来的更新//现在更新头尾是防止出现合成后再被别的span合成的情况(兼容我们的前后页合并接口)_IdToSpan.set(span->_pageId,span);_IdToSpan.set(span->_pageId + span->_n - 1, span);
}

  1. 处理大于最大值的 Span： 首先，函数检查传入的 Span 的页数是否大于 NPAGES - 1，如果是的话，说明这个 Span 超过了系统能维护的最大值，那么就直接调用系统接口销毁内存，并释放 Span 对象的内存，然后返回。这个操作是为了防止系统无法管理过大的 Span 而造成的问题。

  2. 合并相邻的 Span： 接下来，函数尝试对传入的 Span 的前后页进行合并操作，从而缓解内存碎片问题。首先，通过循环向前查找前一个 Span 是否可以合并，如果找到了合适的 Span，就进行合并操作，并在合并后将该 Span 从对应的 SpanList 中删除，并释放其内存。然后，再通过循环向后查找后一个 Span 是否可以合并，同样找到合适的 Span 后进行合并操作，并释放其内存。

  3. 更新数据结构： 在合并结束后，将合并后的 Span 插入到对应的 SpanList 中，并将其标记为未使用。然后，更新 Span 的页号与 Span 之间的映射关系，以便后续操作能够快速定位到对应的 Span。

在合并 page cache 中的 span 时，需要通过页号找到对应的 span。与 central cache 不同的是，page cache 中的 span 需要建立页号与 span 之间的映射关系。在 page cache 中，只需建立一个 span 的首尾页号与该 span 之间的映射关系即可。因为在进行合并时，只需要通过一个 span 的尾页或首页找到这个 span，无需建立每个页与 span 的映射关系。

当申请 k 页的 span 时，如果将 n 页的 span 切割为一个 k 页的 span 和一个 n-k 页的 span，除了需要建立 k 页 span 中每个页与该 span 之间的映射关系外，还需要建立剩余的 n-k 页 span 的首尾页号与其间的映射关系。

Span* PageCache::NewSpan(size_t k)
{// ...for (size_t n = k + 1; n < NPAGES; n++){if (!_Spanlists[n].empty()){// .../*nspan->_pageId += k;nspan->_n -= k;*/// 存储nSpan的首位页号跟nSpan映射，方便page cache回收内存时// 进行的合并查找_IdToSpan[nspan->_pageId] = nspan;_IdToSpan[nspan->_pageId + nspan->_n - 1] = nspan;/*_Spanlists[nspan->_n].push_front(nspan);for (PAGEID i = 0; i < kspan->_n; i++){_IdToSpan[kspan->_pageId + i] = kspan;}return kspan;*/}}// ...
}

回收内存测试

void MultiThreadAlloc1()
{std::vector<void*> v;for (size_t i = 0; i < 1000; ++i){void* ptr = ConcurrentAlloc(6);v.push_back(ptr);}for (auto e : v){ConcurrentFree(e, 6);}
}
void MultiThreadAlloc2()
{std::vector<void*> v;for (size_t i = 0; i < 1000; ++i){void* ptr = ConcurrentAlloc(16);v.push_back(ptr);}for (auto e : v){ConcurrentFree(e, 16);}
}
void MultiThreadAlloc3()
{std::vector<void*> v;for (size_t i = 0; i < 1000; ++i){void* ptr = ConcurrentAlloc(256);v.push_back(ptr);}for (auto e : v){ConcurrentFree(e, 256);}
}
void MultiThreadAlloc4()
{std::vector<void*> v;for (size_t i = 0; i < 1000; ++i){void* ptr = ConcurrentAlloc(2048);v.push_back(ptr);}for (auto e : v){ConcurrentFree(e, 2048);}
}
void MultiThreadAlloc5()
{std::vector<void*> v;for (size_t i = 0; i < 1000; ++i){void* ptr = ConcurrentAlloc(66*1024);v.push_back(ptr);}for (auto e : v){ConcurrentFree(e, 66 * 1024);}
}
void TestMultiThread()
{std::thread t1(MultiThreadAlloc1);std::thread t2(MultiThreadAlloc2);std::thread t3(MultiThreadAlloc3);std::thread t4(MultiThreadAlloc4);std::thread t5(MultiThreadAlloc5);t1.join();t2.join();t3.join();t4.join();t5.join();
}
int main()
{//TLSTest();//TestAlloc();TestMultiThread();return 0;
}

这里我们简单的跑一下程序,看一下是否能稳定运行 。

7.解决大内存申请释放

        7.1 申请内存

这里我们用梳理一下之前的内存申请方式, ThreadCache是用于申请小于等于256KB的内存的，而对于大于256KB的内存，我们可以考虑直接向PageCache申请，但PageCache中最大的页也就只有128页,所以我们现在还无法实现大于128页内存的申请释放 。于是我们现在选择把大于128页的内存直接向堆上申请释放来解决这个问题。

当申请的内存大于256KB时，虽然不是从ThreadCache进行获取，但在分配内存时也是需要按页为单位向上对齐的。

RoundUp

class SizeTable
{
public:static size_t RoundUp(size_t bytes){// ...else if (bytes <= 256 * 1024){// return _RoundUp(bytes, 8 * 1024);}else{return _RoundUp(bytes, 1 << PAGESHIFT);}
};

ConcurrentAlloc

我们最初申请内存时的逻辑也会随之改变,我们就不选择走向ThreadCache申请内存的流程,直接判断完后调用Newspan接口申请页。

static void* ConcurrentAlloc(size_t size)
{if (size > MAXSIZE){//超过256KB的内存,ThreadCache中已经放不下了,直接申请Span来用size_t align_size = SizeTable::RoundUp(size);size_t kpage = align_size >> PAGESHIFT; //计算一共要去PageCache中去拿k页SpanPageCache::GetInstance()._pagemtx.lock();Span* span = PageCache::GetInstance().NewSpan(kpage);PageCache::GetInstance()._pagemtx.unlock();return (void*)(span->_pageId << PAGESHIFT);}// ...
}

NewSpan

我们在这里实现超过128页内存的申请,并且对申请的span类建立头指针的映射关系,这样便于后续销毁工作。

Span* PageCache::NewSpan(size_t k)
{if (k > NPAGES - 1){//此时申请的内存大于了1024*1024 bytes ,即1M ,超过PageCache维护的最大限制,此时我们直接去堆上申请内存void* ptr = SystemAlloc(k);Span* kspan = new Span;kspan->_n = k;kspan->_pageId = (PAGEID)ptr >> PAGESHIFT;//对申请的span类建立头指针的映射关系,便于后续销毁工作_IdToSpan[kspan->_pageId] = kspan;return kspan;}// ...
}

        7.2 释放内存

我们释放的流程总结如下:

释放内存的大小释放方式
x ≤ 256KB (32页)释放给 thread cache
32页 < x ≤ 128页释放给 page cache
x ≥ 128页释放给堆

ConcurrentFree

因此当释放对象时，我们需要先找到该对象对应的span，但是在释放对象时我们只知道该对象的起始地址。但是我们是给申请到的内存建立了span结构，并建立起始页号与该span之间的映射关系的原因。此时我们就可以通过释放对象的起始地址计算出起始页号，进而通过页号找到该对象对应的span。

static void ConcurrentFree(void* ptr, size_t 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);}
}

ReleaseSpanToPageCache

因此Page Cache在回收Span时也需要进行判断，如果该span的大小是大于128页的，那么说明该span是直接向堆申请的，我们直接将这块内存释放给堆，然后将这个span结构进行delete就行了。

void PageCache::ReleaseSpanToPageCache(Span* span)
{if (span->_n > NPAGES - 1){void* ptr = (void*)(span->_pageId << PAGESHIFT);SystemFree(ptr);delete span;return;}// ...
}

大内存测试

void BigAlloc()
{void* p1 = ConcurrentAlloc(257 * 1024);ConcurrentFree(p1, 257 * 1024);void* p2 = ConcurrentAlloc(129 * 8 * 1024);ConcurrentFree(p2, 129 * 8 * 1024);
}
int main()
{//TLSTest();//TestAlloc();//TestMultiThread();BigAlloc();return 0;
}

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

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

相关文章

事务(transaction)

事务(transaction)

事务&#xff0c;什么是事务&#xff0c;事务就是由单独单元的一个或多个sql语句组成&#xff0c;在这个单元中&#xff0c;每个sql语句都是相互依赖的。而整个单独单元是作为一个不可分割的整体存在&#xff0c;类似于物理当中的原子&#xff08;一种不可分割的最小单位&#…
阅读更多...
探索神经网络在商品销售和图像识别中的应用

探索神经网络在商品销售和图像识别中的应用

目录 前言人工神经网络简介1.1 人工神经网络与深度学习简介1.2 生物神经元结构与神经元机器模型1.3 神经网络的数据量与性能关系 2 需求预测2.1 需求预测的背景2.2 商品销售神经元机器模型2.3 多层神经网络结构的优势 3 图像识别3.1 图像识别神经网络技术3.2 实际应用场景 结语…
阅读更多...
【Docker】提交Docker镜像改变(自定义Redis镜像)

【Docker】提交Docker镜像改变(自定义Redis镜像)

查看某个容器发生改变(操作日志) docker diff redis A: 添加文件或目录(ADD)D:文件或者目录删除(DELETE)C:文件或者目录更改(CHANGE) 对更改的容器进行保存 我们平时使用镜像&#xff0c;会做一些自定义&#xff0c;比如配置文件的修改&#xff0c;数据的增删改等等有很多&…
阅读更多...
android应用开发基础大纲，【绝对干货】

android应用开发基础大纲，【绝对干货】

背景 首先我是个菜鸡&#xff0c;工资也低的一笔。 刚毕业时候在一家国企上班干 app 开发&#xff0c;干了快两年的时候&#xff0c;跳槽到了一家伪大厂干安全。投了不少简历都没有回音&#xff0c;只有这加伪大厂要我就来了。当时说好了会接触一些底层的东西&#xff0c;然而…
阅读更多...
打印螺旋矩阵

打印螺旋矩阵

打印螺旋矩阵 题目 如&#xff1a;输入 n 5&#xff1b; 输出&#xff1a; 1 2 3 4 5 16 17 18 19 6 15 24 25 20 7 14 23 22 21 8 13 12 11 10 9解题 这种规律打印题我个人感觉是真的不好写&#xff0c;一看答案感觉也就那回事&#xff0c;真自己琢磨&#xff0c;半…
阅读更多...
Draft-P802.11be-D3.2协议学习__$Annex-Z-HE-SIG-B-and-EHT-SIG-content-examples

Draft-P802.11be-D3.2协议学习__$Annex-Z-HE-SIG-B-and-EHT-SIG-content-examples

Draft-P802.11be-D3.2协议学习__$Annex-Z-HE-SIG-B-and-EHT-SIG-content-examples Z.1 GeneralZ.2 HE-SIG-B example 1Z.3 HE-SIG-B example 2Z.4 HE-SIG-B example 3Z.5 HE-SIG-B example 4Z.6 EHT-SIG example 1&#xff08;EHT OFDMA 80MHz&#xff09;Z.7 EHT-SIG example …
阅读更多...
C++写食堂菜品管理系统

C++写食堂菜品管理系统

说明：本博文来自CSDN-问答板块，题主提问。 需要：学校拟开发一套食堂菜品管理系统，以便对菜品和同学们的评价进行管理，其中包含如下信息： 商户：商户名称、柜面位置、电话…… 菜品：菜品编号、菜品名称、价格、所属商户…… 学生：注册账号、昵称、电话…… 食堂里的商户…
阅读更多...
YOLOv8改进 | 独家创新篇 | 给YOLOv8增加辅助可逆分支结构（PGI,1:1改进）（全网独家创新，附视频讲解）

YOLOv8改进 | 独家创新篇 | 给YOLOv8增加辅助可逆分支结构（PGI,1:1改进）（全网独家创新，附视频讲解）

一、本文介绍 本文给大家带来的是结合最新SOTA模型YOLOv9提出的辅助可逆分支结构（也就是增加辅助训练分支，PGI），该结构改动内容非常大，首先需要修改我们的yaml文件，之后需要修改检测头因为辅助可逆分支需要使用YOLOv9的DualDDetect检测头，之后我们还需要修改损失函数的…
阅读更多...
观其大略之HybridCLR学习笔记

观其大略之HybridCLR学习笔记

问题背景 1 现有热更方案的开发效率、性能没有到达极限&#xff0c;还有提升的空间 2 ios多平台政策导致热更新受限问题&#xff0c;ios禁止jit。根据我查找的资料&#xff0c;ios的代码段启动的时候就确定了&#xff0c;不能增加新的代码段。IOS封了内存&#xff08;或者堆&…
阅读更多...
ChatGPT使用的SSE协议接口怎么做测试

ChatGPT使用的SSE协议接口怎么做测试

SSE是server-sent events协议简称，SSE协议主要是依托于HTTP链接用来从服务端将消息、信息、事件推动给客户端的协议。 SSE简介 SSE最近突然的被很多人关注还有一个主要原因就是ChatGPT等大模型的聊天类系统就采用了SSE协议。在使用ChatGPT的时候，输入Prompt后的反馈是逐渐的…
阅读更多...
vite 自动导入组件样式插件及其原理（vite-plugin-style-import）

vite 自动导入组件样式插件及其原理（vite-plugin-style-import）

Vite 是一个快速的现代化前端构建工具。它在开发过程中使用了 ES 模块的原生导入方式&#xff0c;可以实现快速的冷启动和热模块替换。为了支持自动导入组件样式&#xff0c;Vite 提供了一个插件叫做 vite-plugin-style-import。 vite-plugin-style-import 插件是一个 Vite 的…
阅读更多...
JS 实现AES方式加密数据实现示例

JS 实现AES方式加密数据实现示例

简介&#xff1a;全称高级加密标准&#xff08;英文名称&#xff1a;Advanced Encryption Standard&#xff09;&#xff0c;在密码学中又称 Rijndael 加密法&#xff0c;由美国国家标准与技术研究院 &#xff08;NIST&#xff09;于 2001 年发布&#xff0c;并在 2002 年成为有…
阅读更多...
数据库搭建11.2

数据库搭建11.2

数据库之搭建 1、rpm -qa|grep 服务名称 案例&#xff1a;rpm -qa|grep mysql 2、将所有msyql的包删除干净 删除方法&#xff1a; &#xff08;1&#xff09;yum remove mysql * 删除linux中的数据库 &#xff08;2&#xff09;yum erase 包名 &#xff0…
阅读更多...
Oracle 提示(hint)方法：use_nl

Oracle 提示(hint)方法：use_nl

select /* index(e) index(d) use_nl(e d) */ * from emp e inner join dept d on e.deptnod.deptno where e.ename :b1 or d.dname :b2; USE_NL 是一个提示&#xff08;hint&#xff09;&#xff0c;用于指示查询优化器使用"NESTED LOOPS"连接方式。该提示告诉…
阅读更多...
Xilinx 7系列 FPGA硬件知识系列（一）——FPGA选型参考

Xilinx 7系列 FPGA硬件知识系列（一）——FPGA选型参考

目录 1.1 Xilinx-7系列产品的工艺级别 ​编辑1.2 Xilinx-7系列产品的特点 1.2.1 Spartan-7系列 1.2.2 Artix-7系列 1.2.3 Kintex-7系列 1.2.4 Virtex-7系列 1.3 Xilinx-7系列FPGA对比 1.3.1 DSP资源柱状图 ​1.3.2 Block RAM资源柱状图 ​1.3.3 高速串行收…
阅读更多...
结构体的基本使用

结构体的基本使用

在C语言中&#xff0c;结构体&#xff08;Struct&#xff09;是一种自定义的数据类型&#xff0c;它允许你将多个不同类型的变量组合成一个单一的类型。结构体在组织和处理具有实体属性的数据时非常有用&#xff0c;如学生、汽车、坐标点等。它们是数据封装的基础。 定义结构体…
阅读更多...
实验笔记之——Gaussian Splatting SLAM配置与测试

实验笔记之——Gaussian Splatting SLAM配置与测试

之前博客对基于3DGS的SLAM进行了调研 学习笔记之——3D Gaussian Splatting及其在SLAM与自动驾驶上的应用调研_3d gaussian splatting slam-CSDN博客文章浏览阅读3.2k次&#xff0c;点赞40次&#xff0c;收藏58次。论文主页3D Gaussian Splatting是最近NeRF方面的突破性工作&a…
阅读更多...
C语言数组全面解析：从初学到精通

C语言数组全面解析：从初学到精通

数组 1. 前言2. 一维数组的创建和初始化3. 一维数组的使用4. 一维数组在内存中的存储5. 二维数组的创建和初始化6. 二维数组的使用7. 二维数组在内存中的存储8. 数组越界9. 数组作为函数参数10. 综合练习10.1 用函数初始化&#xff0c;逆置&#xff0c;打印整型数组10.2 交换两…
阅读更多...
Java面试篇【MyCat】常见面试题（2024最新）

Java面试篇【MyCat】常见面试题（2024最新）

Mycat 1.Mycat 分库分表中间件&#xff0c;将存放在一个数据库的数据存放在不同的多个数据库中。来分散负载。 scheme 逻辑库&#xff0c;对应mysql的数据库&#xff0c;一个逻辑库定义了包含的所有table.是数据库集群对外的统一访问接口。table 逻辑表&#xff0c;和物理数…
阅读更多...
【Java EE】文件内容的读写⸺数据流

【Java EE】文件内容的读写⸺数据流

目录 &#x1f334;数据流的概念&#x1f338;数据流分类 &#x1f333;字节流的读写&#x1f338;InputStream&#xff08;从文件中读取字节内容)&#x1f33b;示例1&#x1f33b;示例2&#x1f33b;利用 Scanner 进行字符读取 &#x1f338;OutputStream(向文件中写内容&…
阅读更多...
最新文章

Copyright @ 2022~2023