多线程内存池

最新推荐文章于 2024-10-30 11:19:43 发布
原创 最新推荐文章于 2024-10-30 11:19:43 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了多线程环境下内存池的优化方法，通过对比互斥体与临界区作为锁实现，揭示了不同锁机制对内存操作性能的影响。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

如果一个内存池需要线程同步了，估计和默认的内存操作也差不了多远了。现在对内存操作的优化只是在优化线程同步操作上面了。默认的lock和unlock可能实现得过于完美，因而要求更多的cpu周期。如果选择更原子的lock和unlock实现，还是可以加快内存操作的速度的。

多线程内存池在实现上也就是在申请和释放外面包裹了一对加锁和解锁操作而已。

如果我们采用模板编程，就可以实现一个功能强悍的模板类，该模板类有两个参数，单线程内存池和锁。这样的话，可以组合出很多情况。比如说，单线程内存池有对象大小固定和不固定两种实现，锁在Windows下可以用临界区，互斥体，信号量，事件实现。这样最多可以组合出8种不同的实例化。

一般说来互斥体比临界区慢很多，在这里可以进行很好的测试。我实现了临界区和互斥体版本的锁，经过测试发现前者比后者快30多倍。因为互斥体据说是内核对象，而临界区是用户态对象，那么互斥体的使用就需要系统在用户态和内核态之间进行切换，肯定会消耗更多的时间。

互斥体版本代码如下，

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4 #include <windows.h>
5  
6 template <typename T> class MemoryPool
7 {
8 public:
9     MemoryPool(size_t size = EXPANSION_SIZE)
10     {
11         expandTheFreeList(size);
12     }
13     ~MemoryPool();
14     //allocate a T element from the free list.
15     void* alloc(size_t size)
16     {
17         if (next == NULL)
18         {
19             expandTheFreeList();
20         }
21         MemoryPool<T>* head = next;
22         next = head->next;
23         return head;
24     }
25     //return a T element to the free list.
26     void free(void* doomed)
27     {
28         MemoryPool<T>* head = static_cast< MemoryPool<T>* > (doomed);
29         head->next = next;
30         next = head;
31     }
32  
33 private:
34     //next element on the free list.
35     MemoryPool<T>* next;
36     //if the freelist is empty, expand it by this amount.
37     enum {EXPANSION_SIZE = 32};
38     //add free elements to the free list
39     void expandTheFreeList(int howMany = EXPANSION_SIZE);
40 };
41  
42 template <typename T> MemoryPool<T> :: ~MemoryPool()
43 {
44     MemoryPool<T>* nextPtr = NULL;
45     while (nextPtr)
46     {
47         nextPtr = next;
48         next = next->next;
49         delete [] nextPtr;
50     }
51 }
52  
53 template <typename T> void MemoryPool<T> :: expandTheFreeList(inthowMany)
54 {
55     //we must allocate an object enough to contain the next pointer
56     size_t size = sizeof(T) > sizeof(MemoryPool<T>*) ? sizeof(T) :
57                   sizeof(MemoryPool<T>*);
58  
59     MemoryPool<T>* runner = (MemoryPool<T>*) new char[size];
60     next = runner;
61     for (int i = 0; i < howMany; ++i)
62     {
63         runner->next = (MemoryPool<T>*) new char[size];
64         runner = runner->next;
65     }
66     runner->next = NULL;
67 }
68  
69 class ABClock //abstract base class
70 {
71 public:
72     virtual ~ABClock() {}
73     virtual void lock() = 0;
74     virtual void unlock() = 0;
75 };
76  
77 class MutexLock : public ABClock
78 {
79 public:
80     MutexLock()
81     {
82         hMutex = CreateMutex(NULL, FALSE, NULL);
83     }
84     ~MutexLock()
85     {
86         CloseHandle(hMutex);
87     }
88     void lock()
89     {
90         WaitForSingleObject(hMutex, INFINITE);
91     }
92     void unlock()
93     {
94         ReleaseMutex(hMutex);
95     }
96 private:
97     HANDLE hMutex;
98 };
99  
100 template <typename POOLTYPE, typename LOCK>
101 class MTMemoryPool
102 {
103 public:
104     //allocate an element from the freelist.
105     void* alloc(size_t size)
106     {
107         void* mem;
108         theLock.lock();
109         mem = stPool.alloc(size);
110         theLock.unlock();
111         return mem;
112     }
113  
114     //return an element to the freelist
115     void free(void* someElement)
116     {
117         theLock.lock();
118         stPool.free(someElement);
119         theLock.unlock();
120     }
121  
122 private:
123     POOLTYPE stPool;//Single-threaded pool.
124     LOCK theLock;
125 };
126  
127 class Rational
128 {
129 public:
130     Rational(int a = 0, int b = 1) : n(a), d(b) {}
131     void* operator new(size_t size)
132     {
133         return memPool->alloc(size);
134     }
135     void operator delete(void* doomed, size_t size)
136     {
137         memPool->free(doomed);
138     }
139     static void newMemPool()
140     {
141         memPool = new MTMemoryPool< MemoryPool<Rational>, MutexLock>;
142     }
143     static void deleteMemPool()
144     {
145         delete memPool;
146     }
147  
148 private:
149     int n;
150     int d;
151     static MTMemoryPool< MemoryPool<Rational>, MutexLock>* memPool;
152 };
153 MTMemoryPool< MemoryPool<Rational>, MutexLock>* Rational::memPool = NULL;
154  
155 int main()
156 {
157     const int ARRAY_SIZE = 1000;
158     const int LOOP_TIMES = 5000;
159  
160     Rational* array[ARRAY_SIZE];
161     clock_t beg = clock();
162     Rational::newMemPool();
163     for (int i = 0; i < LOOP_TIMES; ++i)
164     {
165         for (int j = 0; j < ARRAY_SIZE; ++j)
166         {
167             array[j] = new Rational(j);
168         }
169         for (int j = 0; j < ARRAY_SIZE; ++j)
170         {
171             delete array[j];
172         }
173     }
174     clock_t end = clock();
175     printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
176     system("pause");
177     Rational::deleteMemPool();
178  
179     return 0;
180 }

运行结果，

临界区版本代码如下，

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4 #include <windows.h>
5  
6 template <typename T> class MemoryPool
7 {
8 public:
9     MemoryPool(size_t size = EXPANSION_SIZE)
10     {
11         expandTheFreeList(size);
12     }
13     ~MemoryPool();
14     //allocate a T element from the free list.
15     void* alloc(size_t size)
16     {
17         if (next == NULL)
18         {
19             expandTheFreeList();
20         }
21         MemoryPool<T>* head = next;
22         next = head->next;
23         return head;
24     }
25     //return a T element to the free list.
26     void free(void* doomed)
27     {
28         MemoryPool<T>* head = static_cast< MemoryPool<T>* > (doomed);
29         head->next = next;
30         next = head;
31     }
32  
33 private:
34     //next element on the free list.
35     MemoryPool<T>* next;
36     //if the freelist is empty, expand it by this amount.
37     enum {EXPANSION_SIZE = 32};
38     //add free elements to the free list
39     void expandTheFreeList(int howMany = EXPANSION_SIZE);
40 };
41  
42 template <typename T> MemoryPool<T> :: ~MemoryPool()
43 {
44     MemoryPool<T>* nextPtr = NULL;
45     while (nextPtr)
46     {
47         nextPtr = next;
48         next = next->next;
49         delete [] nextPtr;
50     }
51 }
52  
53 template <typename T> void MemoryPool<T> :: expandTheFreeList(inthowMany)
54 {
55     //we must allocate an object enough to contain the next pointer
56     size_t size = sizeof(T) > sizeof(MemoryPool<T>*) ? sizeof(T) :
57                   sizeof(MemoryPool<T>*);
58  
59     MemoryPool<T>* runner = (MemoryPool<T>*) new char[size];
60     next = runner;
61     for (int i = 0; i < howMany; ++i)
62     {
63         runner->next = (MemoryPool<T>*) new char[size];
64         runner = runner->next;
65     }
66     runner->next = NULL;
67 }
68  
69 class ABClock //abstract base class
70 {
71 public:
72     virtual ~ABClock() {}
73     virtual void lock() = 0;
74     virtual void unlock() = 0;
75 };
76  
77 class CriticalSectionLock : public ABClock
78 {
79 public:
80     CriticalSectionLock()
81     {
82         InitializeCriticalSection(&csMyCriticalSection);
83     }
84     ~CriticalSectionLock()
85     {
86         DeleteCriticalSection(&csMyCriticalSection);
87     }
88     void lock()
89     {
90         EnterCriticalSection(&csMyCriticalSection);
91     }
92     void unlock()
93     {
94         LeaveCriticalSection(&csMyCriticalSection);
95     }
96 private:
97     CRITICAL_SECTION csMyCriticalSection;
98 };
99  
100 template <typename POOLTYPE, typename LOCK>
101 class MTMemoryPool
102 {
103 public:
104     //allocate an element from the freelist.
105     void* alloc(size_t size)
106     {
107         void* mem;
108         theLock.lock();
109         mem = stPool.alloc(size);
110         theLock.unlock();
111         return mem;
112     }
113  
114     //return an element to the freelist
115     void free(void* someElement)
116     {
117         theLock.lock();
118         stPool.free(someElement);
119         theLock.unlock();
120     }
121  
122 private:
123     POOLTYPE stPool;//Single-threaded pool.
124     LOCK theLock;
125 };
126  
127 class Rational
128 {
129 public:
130     Rational(int a = 0, int b = 1) : n(a), d(b) {}
131     void* operator new(size_t size)
132     {
133         return memPool->alloc(size);
134     }
135     void operator delete(void* doomed, size_t size)
136     {
137         memPool->free(doomed);
138     }
139     static void newMemPool()
140     {
141         memPool = new MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>;
142     }
143     static void deleteMemPool()
144     {
145         delete memPool;
146     }
147  
148 private:
149     int n;
150     int d;
151     static MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>* memPool;
152 };
153 MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>* Rational::memPool = NULL;
154  
155 int main()
156 {
157     const int ARRAY_SIZE = 1000;
158     const int LOOP_TIMES = 5000;
159  
160     Rational* array[ARRAY_SIZE];
161     clock_t beg = clock();
162     Rational::newMemPool();
163     for (int i = 0; i < LOOP_TIMES; ++i)
164     {
165         for (int j = 0; j < ARRAY_SIZE; ++j)
166         {
167             array[j] = new Rational(j);
168         }
169         for (int j = 0; j < ARRAY_SIZE; ++j)
170         {
171             delete array[j];
172         }
173     }
174     clock_t end = clock();
175     printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
176     system("pause");
177     Rational::deleteMemPool();
178  
179     return 0;
180 }

运行结果，

两个版本的代码只在线程同步锁的实现上有差别，但是速度却相差了30多倍。

004.多线程内存池
行走
01-11 699
多线程安全内存池 内存分配通常是影响一个系统性能的关键所在。内存分配的主要性能瓶颈有： 1.由于Windows分配时需要进入操作系统内核态，而进入一个内核态至少需要2000个CPU时钟周期 2.频繁的小内存分配会导致内存出现大量碎片，另外容易引发内存页面错误 3.当有多个线程需要分配内存时，内存池必须加锁,加锁也需要进入内核态，更重要的是锁碰撞引起自旋等待将浪费大量cpu空转时间 实现思...
[原创]网络专用高效内存池,支持多线程.原创,非sgi的内存池
weixin_30437847的博客
05-27 124
　　首先要说明一点,这个内存池使用时需要注意的,如果想用在长期分配出去的内存,请慎用.　 因为假如一个区块被分配完了,只有在这个区块里已分配的内存被完全释放后,这个区块才能重用. 因为当初是设计为网络分包用的内存池.为了效率而采用这个策略的. 　　发代码之前先简单介绍下内存池的思路.　　内存池分256个区块,编号为0~255区块的结构为: 区块记录了3个信息一个指针 _left_mem是剩...
(源码)基于C++的多线程内存池系统.zip
最新发布
11-24
# 基于C++的多线程内存池系统 ## 项目简介 本项目是一个基于C++开发的多线程内存池系统，旨在优化内存分配和释放的效率，特别适用于高并发的场景。通过内存复用和减少内存碎片，本系统能够显著提升内存管理的性能。...
C++多线程内存池和简单的BUFFER类
08-16
总的来说，C++多线程内存池和简单的BUFFER类是解决高并发、高性能问题的有效手段。通过合理的设计和实现，我们可以创建出高效、稳定、线程安全的程序。在实际应用中，这不仅可以优化内存管理，还能降低延迟，提升...
http_nicevrl_cpp实现http_多线程内存池_
09-29
在本项目中，"http_nicevrl_cpp实现http_多线程内存池_" 是一个用C++语言编写的HTTP服务器实现，它着重关注了多线程和内存池的优化技术。下面将详细阐述这个项目的重点内容。 首先，HTTP协议是互联网上应用最广泛的...
C++实现高效多线程内存池与BUFFER类设计
根据提供的信息，我们可以提炼出两个关键主题：C++多线程内存池和简单的BUFFER类。接下来将对这两个主题进行详细的知识点说明。 ### C++多线程内存池 #### 知识点概述 内存池是一种特殊的内存管理技术，它预先从...
一种Linux多线程应用下内存池的设计与实现
10-18
在Linux多线程应用下，内存池的设计和实现尤为重要，因为它能有效解决传统内存分配带来的性能问题和内存碎片。 传统的动态内存管理（如malloc和new）在频繁的分配和释放过程中，会带来较高的开销，因为每次分配和...
线程安全的内存池NedAllocator
07-16
nedmalloc是一个跨平台的高性能多线程内存分配库，很多库都使用它，例如:OGRE。 这个内存池主要用在需要频繁使用动态分配内存的情况下，我测试了这个内存池分配内存和malloc分配内存的效率。NedAllocator是malloc的5倍速度。而且不会存在内存泄漏。 使用方法如下： 1.拷贝文件NedAllocatorImpl.h和NedAllocator.lib到你自己的工程目录中； 2.在你的工程中加上如下的语句： #include "NedAllocatorImpl.h" #pragma comment(lib,"NedAllocator.lib") 3.然后就可以NedAllocator来使用内存池了。 MemoryMalloc：分配内存 MemoryFree： 释放内存 DestroyMemory：释放内存池（这个方法是在程序结束的时候才调用的。不过不调用好像也没有什么影响！也没有内存泄漏）
多线程内存池实现
Always On The Way
01-08 1413
多线程的内存池是基于模板的类： template class MTMemoryPool { public: void* alloc(size_t size); void free(void* someElement); private: POOLTYPE stPool; LOCK theLock; }; template void* MTMemoryPool::alloc(size
提高C++性能的编程技术笔记：多线程内存池+测试代码
网络资源是无限的
11-28 1507
为了使多个线程并发地分配和释放内存，必须在分配器方法中添加互斥锁。 全局内存管理器(通过new()和delete()实现)是通用的，因此它的开销也非常大。 因为单线程内存管理器要比多线程内存管理器快的多，所以如果要分配的大多数内存块限于单线程中使用，那么可以显著提升性能。 如果开发了一套有效的单线程分配器，那么通过模板可以方便地将它们扩展到多线程环境中。 以下是测试代码(multi_thr...
多线程环境下内存池的实现（C++）
weixin_43364551的博客
10-30 803
可能发生一块内存被多个线程获取的情况，导致这几个线程的数据出现错乱。获取后，还没释放，就被线程。
c++性能优化：多线程内存池
weixin_34764432的博客
10-14 1130
前言 上一章，我们的视线全部都放在单线程的内存池，这一节主要讲的是多线程的内存池。由于多线程的问题，需要讲内存分配和释放的合适地方加上互斥锁，这样才能保证线程访问资源的安全。 实现 通过模板的实现，可以带入任意类型的锁，这样的话就可以使得内存池的应用更加灵活。 template<class POOLTYPE, class LOCK> class MTMemoryPool{ public: inline void* alloc(size_t size); inline void.
多线程高并发内存池c语言实现,高并发内存池的实现
weixin_32042959的博客
05-22 851
第一层:Thread Cache(线程缓存)1.thread cache是内存池中的第一层缓存，这一层缓存主要解决的问题就是并发状态下锁竞争的效率问题。线程在这里申请不需要加锁，每一个线程都有自己独立的cache，这也就是这个项目并发高效的地方。怎么实现每个线程都拥有自己唯一的线程缓存呢？为了避免加锁带来的效率，在Thread Cache中使用(tls)thread local storage保存...
多线程---线程池
qq_57283958的博客
05-25 147
线程池: * 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着 监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利 用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 * 线程池的应用场景： * 1. 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技 术是非常合适
你要的多线程内存池 GNU 帮你写好了
weixin_41041321的博客
09-05 178
#include <iostream> #include <ext/mt_allocator.h> typedef __gnu_cxx::__mt_alloc<int> allocator_type; int main() { std::cout << "dddd"; allocator_type att; allocator_type::pointer p1 = att.allocate(128); allocator_typ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值