【项目日记(四)】第一层: 线程缓存的具体实现

这篇具有很好参考价值的文章主要介绍了【项目日记(四)】第一层: 线程缓存的具体实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

💓博主CSDN主页:杭电码农-NEO💓

⏩专栏分类:项目日记-高并发内存池⏪

🚚代码仓库:NEO的学习日记🚚

🌹关注我🫵带你做项目
  🔝🔝
开发环境: Visual Studio 2022


【项目日记(四)】第一层: 线程缓存的具体实现,项目日记--高并发内存池,项目日记,并发内存池,c++

1. 前言

由于此项目需要创建多个文件
所以我直接在.h文件中既放声明
也存放实现,减少文件的数量

本章重点:

本篇文章着重讲解ThreadCache线程
缓存结构的具体实现,包含内存对齐的
方法,申请/释放内存的函数以及向中心
缓存中索要/还回内存的函数!本篇文章
大多数都是代码实现,请大家耐心学习


2. ThreadCache结构设计

在上一章谈到,线程缓存是一个哈希桶结构
每个桶中存放的是自由链表(小块儿内存)

由于自由链表不止在ThreadCache中使用,所以定义一个shared.h存放所有文件共享的内容!

shared.h文件中的自由链表结构:

//管理切分好的小对象的自由链表
class FreeList
{
public:
	void Push(void* obj)
	{
		assert(obj);
		//头插
		*(void**)obj = _freeList;
		_freeList = obj;
		_size++;
	}
	void PushRange(void* start, void* end, size_t n)//范围型的插入
	{
		*(void**)end = _freeList;
		_freeList = start;
		_size += n;
	}
	void* Pop()
	{
		assert(_freeList);
		//头删
		void* obj = _freeList;
		_freeList = *(void**)obj;
		--_size;
		return obj;
	}
	void PopRange(void*& start, void*& end, size_t n)//start和end是输出型参数
	{
		assert(n <= _size);
		start = _freeList;
		end = start;
		for (int i = 0; i < n - 1; i++)
			end = *(void**)end;
		_freeList = *(void**)end;
		*(void**)end = nullptr;
		_size -= n;
	}
	bool Empty()
	{
		return _freeList == nullptr;
	}
	size_t& MaxSize()
	{
		return _maxSize;
	}
	size_t Size()
	{
		return _size;
	}
private:
	void* _freeList = nullptr;
	size_t _maxSize = 1;//记录ThreadCache一次性最多向CentralCache申请多少个对象
	size_t _size = 0;//记录自由链表中挂的内存个数
};

关于什么是自由链表的问题我们在
定长池的实现中已经讲解过了,如果
你不懂,简易从头开始看博客,学项目!

前置文章: 定长池的实现

然后在ThreadCache.h中,需要实现以下函数

class ThreadCache
{
public:
	//向线程缓存申请内存
	void* Allocate(size_t size);
	//向线程缓存释放内存
	void Deallocate(void* ptr, size_t size);
	// 从中心缓存获取对象
	void* FetchFromCentralCache(size_t index, size_t size);
	// 释放对象时,链表过长时,回收内存回到中心缓存
	void ListTooLong(FreeList& list, size_t size);
private:
	FreeList _freeList[208];
};

3. 哈希桶中的内存对齐规则

你可能会有以下问题:

  1. 为什么上面写的哈希桶个数是208?
  2. 要是遇见不规则的字节数该怎么办?

这里用到一个非常巧妙的方法,也就是内存对齐!比如想要申请1~7字节的内存,先把它对齐为8字节再进行后续的操作,这么做的原因有两个: 一是因为如果申请多少内存就给多少内存,那么我们需要的哈希桶的数量就太多了,不合理. 二是因为释放内存时比较方便

内存对齐的具体规则:

【项目日记(四)】第一层: 线程缓存的具体实现,项目日记--高并发内存池,项目日记,并发内存池,c++
这里有一个问题: 为什么不都使用8字节对齐?

因为若使用8字节对齐,共256KB内存
一共要使用三万多个桶,也是不合理的
这样的对齐方式只用使用208个桶!

对齐规则的具体实现:

static inline size_t AlignUp(size_t size)//将size向上对齐
{
	if (size <= 128)
		return _AlignUp(size, 8);
	else if (size <= 1024)
		return _AlignUp(size, 16);
	else if (size <= 8 * 1024)
		return _AlignUp(size, 128);
	else if (size <= 64 * 1024)
		return _AlignUp(size, 1024);
	else if (size <= 256 * 1024)
		return _AlignUp(size, 8*1024);
	else
		return _AlignUp(size, 1 << PAGE_SHIFT);
}
static inline size_t _AlignUp(size_t size, size_t align_number)
{
	return (((size)+align_number - 1) & ~(align_number - 1));
}

4. 线程缓存申请内存的全过程

首先,要先把申请的内存进行内存对齐
然后再用这个对齐后的内存去找对应
的哈希桶结构,若这个桶中有小块儿内
存,那么直接将小块儿内存返回,若桶中
没有内存了,就去中心缓存中拿内存!

void* ThreadCache::Allocate(size_t size)
{
	assert(size <= MAX_BYTES);//申请的字节数不能大于了256KB
	size_t align_size = AlignmentRule::AlignUp(size);//计算对齐数
	size_t index = AlignmentRule::Index(size);//计算在哪个桶
	if (!_freeList[index].Empty())//若当前自由链表有资源则优先拿释放掉的资源
		return _freeList[index].Pop();
	else//自由链表没有就从中心缓存获取空间
		return ThreadCache::FetchFromCentralCache(index, align_size);
}

注:计算在哪个桶的函数会放在文章最后

当走到else语句,也就是要去中心缓存获取内存时,会有个问题:一次性拿几个小块儿内存过来?拿多了怕浪费,拿少了又怕要重新再来拿,这里采用的是慢启动的算法,第一次先拿一个,第二次再拿两个,以此类推.除此之外,小对象应该多拿,大对象应该少拿.所以拿的个数应该是这两个条件中较小的内一个

void* ThreadCache::FetchFromCentralCache(size_t index, size_t size)
{
	//采用慢开始的反馈调节算法,小对象给多一点,大对象给少一点
	size_t massNum = min(_freeList[index].MaxSize(),AlignmentRule::NumMoveSize(size));//向中心缓存获取多少个对象
	if (_freeList[index].MaxSize() == massNum)//慢增长,最开始一定是给1,不会一次性给它很多内存,若不断有size大小的内存需求,再慢慢多给你
		_freeList[index].MaxSize() += 1;
	void* begin = nullptr;
	void* end = nullptr;
	//需要massnum个对象,但是实际上不一定有这么多个,返回值为实际上获取到的个数
	size_t fact = CentralCache::GetInstance()->CentralCache::FetchRangeObj(begin,end,massNum,size);//要massmun个对象,每个对象的大小是size
	assert(fact != 0);
	if (fact == 1)
	{
		assert(begin == end);
		return begin;
	}
	else
	{
		//如果从中心缓存获取了多个,则将第一个返回给threadcachee,然后再将剩余的内存挂在threadcache的自由链表中
		_freeList[index].PushRange((*(void**)begin), end, fact - 1);
		return begin;
	}
	return nullptr;
}

注: 根据对象大小获取个数的函数放在文章最后
FetchRangeObj函数是中心缓存要关心的东西


5. 线程缓存释放内存的全过程

由于申请内存时已经内存对齐了,所以释放的内存肯定是已经对齐过的了,找到对应的桶,直接将这个小块儿内存挂在桶后面,若当换回来的内存在自由链表中的长度大于一次性向中心缓存申请的长度,就将内存还给中心缓存

void ThreadCache::Deallocate(void* ptr, size_t size)
{
	assert(ptr);
	assert(size <= MAX_BYTES);
	//找到对应的自由链表桶[[0,208]
	size_t index = AlignmentRule::Index(size);
	_freeList[index].Push(ptr);
	//当换回来的内存在自由链表中的长度大于一次性向中心缓存申请的长度,就将内存还给中心缓存
	if (_freeList[index].Size() >= _freeList[index].MaxSize())
		ListTooLong(_freeList[index],size);
}
void ThreadCache::ListTooLong(FreeList& list, size_t size)//大于等于一个批量内存就还回去一个批量,不一定全部还回去
{
	void* start = nullptr;
	void* end = nullptr;
	list.PopRange(start, end, list.MaxSize());//start和end是输出型参数
	CentralCache::GetInstance()->ReleaseListToSpans(start, size);
}

注:ReleaseListToSpans函数是中心缓存需要关心的


6. 对项目边角代码的拓展

这里存放的是shared.h文件中,存放
如何通过字节数来找到对应的桶的函数
以及慢增长函数的具体实现:

慢增长函数:

static const size_t MAX_BYTES = 256 * 1024; //最大内存限制,256KB
static const size_t N_FREE_LIST = 208; //哈希桶的数量

static size_t NumMoveSize(size_t size)//此函数代表从中心缓存取多少个对象(和慢增长对比)
{
	assert(size > 0);
	// [2, 512],一次批量移动多少个对象的(慢启动)上限值
	// 小对象一次批量上限高
	// 大对象一次批量上限低
	int num = MAX_BYTES / size; //256KB除单个对象大小
	if (num < 2)//最少给2个
		num = 2;
	if (num > 512)//最大给512个
		num = 512;
	return num;
}

通过字节数计算在哪个桶:

// 计算映射的哪一个自由链表桶
static inline size_t Index(size_t bytes)
{
	assert(bytes <= MAX_BYTES);
	// 每个区间有多少个链
	static int group_array[4] = { 16, 56, 56, 56 };
	if (bytes <= 128) 
		return _Index(bytes, 3);
	else if (bytes <= 1024) 
		return _Index(bytes - 128, 4) + group_array[0];
	else if (bytes <= 8 * 1024) 
		return _Index(bytes - 1024, 7) + group_array[1] + group_array[0];
	else if (bytes <= 64 * 1024) 
		return _Index(bytes - 8 * 1024, 10) + group_array[2] + group_array[1]
			+ group_array[0];
	else if (bytes <= 256 * 1024) 
		return _Index(bytes - 64 * 1024, 13) + group_array[3] +
			group_array[2] + group_array[1] + group_array[0];
	else
		return -1;
}
static inline size_t _Index(size_t bytes, size_t align_shift)
{
	return ((bytes + (1 << align_shift) - 1) >> align_shift) - 1;
}

对于边角的函数,我们了解它的原理即可
不需要完全掌握它是如何实现的!
文章来源地址https://www.toymoban.com/news/detail-824352.html


🔎 下期预告:中心缓存的具体实现🔍

到了这里,关于【项目日记(四)】第一层: 线程缓存的具体实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++修炼之筑基期第一层——认识类与对象

    🌸作者简介: 花想云 ,在读本科生一枚,致力于 C/C++、Linux 学习。 🌸 本文收录于 C++系列,本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等,专为大学生打造全套 C++ 学习教程,持续更新! 🌸 相关专栏推荐: C语言初阶系列 、 C语言进阶系列 、 数据结构与算法 本章内容

    2023年04月08日
    浏览(40)
  • 【go项目-geecache】动手写分布式缓存 day2 - 单机并发缓存

    [ Github- geecache ](luckly-0/geecache (github.com)) 收获总结: 了解接口的使用场景,它和函数之间的差别和优略势 测试文件要以_test结尾 系统设计要严谨,要考虑后期的拓展性和维护 ,比如load函数考虑到了分布式场景 数据结构之间的封装 sync.Mutex 互斥锁 如果我们要是实现并发缓存

    2023年04月18日
    浏览(86)
  • 基于多线程并发-线程同步-系统实现

    系统实现:相对于STL来说非标准的实现,Linux和Windows平台各自的实现。 线程同步:通过限制多个线程同时执行某段代码来保护资源的。 1、线程互斥量 pthread_mutex_t 的初始化 a、定义再初始化: pthread_mutex_init函数的第二个参数attr是定义互斥锁的属性,一般为NULL。成功初始化返

    2024年02月08日
    浏览(36)
  • 高并发缓存问题分析以及分布式锁的实现

    在高并发的环境下,比如淘宝,京东不定时的促销活动,大量的用户访问会导致数据库的性能下降,进而有可能数据库宕机从而不能产生正常的服务,一般一个系统最大的性能瓶颈,就是数据库的io操作,如果发生大量的io那么他的问题也会随之而来。从数据库入手也是调优性价比最高

    2024年01月19日
    浏览(69)
  • 基于多线程实现服务器并发

    看大丙老师的B站视频总结的笔记 19-基于多线程实现服务器并发分析_哔哩哔哩_bilibili https://www.bilibili.com/video/BV1F64y1U7A2/?p=19spm_id_from=pageDrivervd_source=a934d7fc6f47698a29dac90a922ba5a3 思路:首先accept是有一个线程的,另外只要这个accept成功的和一个客户端建立了连接,那么我们就需要创

    2024年02月14日
    浏览(35)
  • Java多线程——并发和并行、实现方法

    代码演示 方式一 方式二 方式三

    2024年01月16日
    浏览(43)
  • qt 线程状态机实现并发自动任务

    一、状态机类 头文件 MyStateMachine.h 状态机 cpp

    2024年02月13日
    浏览(41)
  • 【项目日记(二)】开胃菜--定长池的实现

    💓博主CSDN主页:杭电码农-NEO💓   ⏩专栏分类:项目日记-高并发内存池⏪   🚚代码仓库:NEO的学习日记🚚   🌹关注我🫵带你学习C++   🔝🔝 开发环境: Visual Studio 2022 在真正开始实现并发内存池前 我们先做一个子项目-定长池. 掌握了定长池对后面学习并发内存池 有很大的

    2024年02月04日
    浏览(20)
  • Go源码实现使用多线程并发下载大文件的功能

    摘要:Go语言编码实现了使用多线程并发下载文件的功能。 1. 获取系统的CPU核心数量,并将其作为线程数的参考值,并打印出来。 2. 定义要下载的文件的URL、线程数和输出文件名。 3. 使用`getFileSize()`函数获取文件大小,并打印出来。 4. 根据文件大小和线程数计算文件块大小

    2024年02月08日
    浏览(65)
  • 万物的算法日记|第一天

    笔者自述: 一直有一个声音也一直能听到身边的大佬经常说,要把算法学习搞好,一定要重视平时的算法学习,虽然每天也在学算法,但是感觉自己一直在假装努力表面功夫骗了自己,没有规划好自己的算法学习和总结,因为后半年也该找实习了,所以每日的算法题要进行恶

    2024年02月13日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包