多线程内存池

最新推荐文章于 2024-05-03 18:22:44 发布
最新推荐文章于 2024-05-03 18:22:44 发布
阅读量3.5k 收藏 5
点赞数 2
分类专栏： VC++程序设计

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

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

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

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

互斥体版本代码如下，

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

template <typename T> class MemoryPool
{
public:
    MemoryPool(size_t size = EXPANSION_SIZE)
    {
        expandTheFreeList(size);
    }
    ~MemoryPool();
    //allocate a T element from the free list.
    void* alloc(size_t size)
    {
        if (next == NULL)
        {
            expandTheFreeList();
        }
        MemoryPool<T>* head = next;
        next = head->next;
        return head;
    }
    //return a T element to the free list.
    void free(void* doomed)
    {
        MemoryPool<T>* head = static_cast< MemoryPool<T>* > (doomed);
        head->next = next;
        next = head;
    }

private:
    //next element on the free list.
    MemoryPool<T>* next;
    //if the freelist is empty, expand it by this amount.
    enum {EXPANSION_SIZE = 32};
    //add free elements to the free list
    void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

template <typename T> MemoryPool<T> :: ~MemoryPool()
{
    MemoryPool<T>* nextPtr = NULL;
    while (nextPtr)
    {
        nextPtr = next;
        next = next->next;
        delete [] nextPtr;
    }
}

template <typename T> void MemoryPool<T> :: expandTheFreeList(int howMany)
{
    //we must allocate an object enough to contain the next pointer
    size_t size = sizeof(T) > sizeof(MemoryPool<T>*) ? sizeof(T) :
                  sizeof(MemoryPool<T>*);

    MemoryPool<T>* runner = (MemoryPool<T>*) new char[size];
    next = runner;
    for (int i = 0; i < howMany; ++i)
    {
        runner->next = (MemoryPool<T>*) new char[size];
        runner = runner->next;
    }
    runner->next = NULL;
}

class ABClock //abstract base class
{
public:
    virtual ~ABClock() {}
    virtual void lock() = 0;
    virtual void unlock() = 0;
};

class MutexLock : public ABClock
{
public:
    MutexLock()
    {
        hMutex = CreateMutex(NULL, FALSE, NULL);
    }
    ~MutexLock()
    {
        CloseHandle(hMutex);
    }
    void lock()
    {
        WaitForSingleObject(hMutex, INFINITE);
    }
    void unlock()
    {
        ReleaseMutex(hMutex);
    }
private:
    HANDLE hMutex;
};

template <typename POOLTYPE, typename LOCK>
class MTMemoryPool
{
public:
    //allocate an element from the freelist.
    void* alloc(size_t size)
    {
        void* mem;
        theLock.lock();
        mem = stPool.alloc(size);
        theLock.unlock();
        return mem;
    }

    //return an element to the freelist
    void free(void* someElement)
    {
        theLock.lock();
        stPool.free(someElement);
        theLock.unlock();
    }

private:
    POOLTYPE stPool;//Single-threaded pool.
    LOCK theLock;
};

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}
    void* operator new(size_t size)
    {
        return memPool->alloc(size);
    }
    void operator delete(void* doomed, size_t size)
    {
        memPool->free(doomed);
    }
    static void newMemPool()
    {
        memPool = new MTMemoryPool< MemoryPool<Rational>, MutexLock>;
    }
    static void deleteMemPool()
    {
        delete memPool;
    }

private:
    int n;
    int d;
    static MTMemoryPool< MemoryPool<Rational>, MutexLock>* memPool;
};
MTMemoryPool< MemoryPool<Rational>, MutexLock>* Rational::memPool = NULL;

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;

    Rational* array[ARRAY_SIZE];
    clock_t beg = clock();
    Rational::newMemPool();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");
    Rational::deleteMemPool();

    return 0;
}

运行结果，

临界区版本代码如下，

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

template <typename T> class MemoryPool
{
public:
    MemoryPool(size_t size = EXPANSION_SIZE)
    {
        expandTheFreeList(size);
    }
    ~MemoryPool();
    //allocate a T element from the free list.
    void* alloc(size_t size)
    {
        if (next == NULL)
        {
            expandTheFreeList();
        }
        MemoryPool<T>* head = next;
        next = head->next;
        return head;
    }
    //return a T element to the free list.
    void free(void* doomed)
    {
        MemoryPool<T>* head = static_cast< MemoryPool<T>* > (doomed);
        head->next = next;
        next = head;
    }

private:
    //next element on the free list.
    MemoryPool<T>* next;
    //if the freelist is empty, expand it by this amount.
    enum {EXPANSION_SIZE = 32};
    //add free elements to the free list
    void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

template <typename T> MemoryPool<T> :: ~MemoryPool()
{
    MemoryPool<T>* nextPtr = NULL;
    while (nextPtr)
    {
        nextPtr = next;
        next = next->next;
        delete [] nextPtr;
    }
}

template <typename T> void MemoryPool<T> :: expandTheFreeList(int howMany)
{
    //we must allocate an object enough to contain the next pointer
    size_t size = sizeof(T) > sizeof(MemoryPool<T>*) ? sizeof(T) :
                  sizeof(MemoryPool<T>*);

    MemoryPool<T>* runner = (MemoryPool<T>*) new char[size];
    next = runner;
    for (int i = 0; i < howMany; ++i)
    {
        runner->next = (MemoryPool<T>*) new char[size];
        runner = runner->next;
    }
    runner->next = NULL;
}

class ABClock //abstract base class
{
public:
    virtual ~ABClock() {}
    virtual void lock() = 0;
    virtual void unlock() = 0;
};

class CriticalSectionLock : public ABClock
{
public:
    CriticalSectionLock()
    {
        InitializeCriticalSection(&csMyCriticalSection);
    }
    ~CriticalSectionLock()
    {
        DeleteCriticalSection(&csMyCriticalSection);
    }
    void lock()
    {
        EnterCriticalSection(&csMyCriticalSection);
    }
    void unlock()
    {
        LeaveCriticalSection(&csMyCriticalSection);
    }
private:
    CRITICAL_SECTION csMyCriticalSection;
};

template <typename POOLTYPE, typename LOCK>
class MTMemoryPool
{
public:
    //allocate an element from the freelist.
    void* alloc(size_t size)
    {
        void* mem;
        theLock.lock();
        mem = stPool.alloc(size);
        theLock.unlock();
        return mem;
    }

    //return an element to the freelist
    void free(void* someElement)
    {
        theLock.lock();
        stPool.free(someElement);
        theLock.unlock();
    }

private:
    POOLTYPE stPool;//Single-threaded pool.
    LOCK theLock;
};

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}
    void* operator new(size_t size)
    {
        return memPool->alloc(size);
    }
    void operator delete(void* doomed, size_t size)
    {
        memPool->free(doomed);
    }
    static void newMemPool()
    {
        memPool = new MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>;
    }
    static void deleteMemPool()
    {
        delete memPool;
    }

private:
    int n;
    int d;
    static MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>* memPool;
};
MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>* Rational::memPool = NULL;

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;

    Rational* array[ARRAY_SIZE];
    clock_t beg = clock();
    Rational::newMemPool();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");
    Rational::deleteMemPool();

    return 0;
}


运行结果，

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

http://www.xpc-yx.com/2012/11/19/%e5%a4%9a%e7%ba%bf%e7%a8%8b%e5%86%85%e5%ad%98%e6%b1%a0/

Augusdi
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
004.多线程内存池
行走
01-11 630
多线程安全内存池 内存分配通常是影响一个系统性能的关键所在。内存分配的主要性能瓶颈有： 1.由于Windows分配时需要进入操作系统内核态，而进入一个内核态至少需要2000个CPU时钟周期 2.频繁的小内存分配会导致内存出现大量碎片，另外容易引发内存页面错误 3.当有多个线程需要分配内存时，内存池必须加锁,加锁也需要进入内核态，更重要的是锁碰撞引起自旋等待将浪费大量cpu空转时间 实现思...
C++多线程内存池和简单的BUFFER类
08-16
C++多线程内存池和简单的BUFFER类。C++多线程内存池和简单的BUFFER类
c++性能优化：多线程内存池
weixin_34764432的博客
10-14 1011
前言 上一章，我们的视线全部都放在单线程的内存池，这一节主要讲的是多线程的内存池。由于多线程的问题，需要讲内存分配和释放的合适地方加上互斥锁，这样才能保证线程访问资源的安全。 实现 通过模板的实现，可以带入任意类型的锁，这样的话就可以使得内存池的应用更加灵活。 template<class POOLTYPE, class LOCK> class MTMemoryPool{ public: inline void* alloc(size_t size); inline void.
http_nicevrl_cpp实现http_多线程内存池_
09-29
在本项目中，"http_nicevrl_cpp实现http_多线程内存池_" 是一个用C++语言编写的HTTP服务器实现，它着重关注了多线程和内存池的优化技术。下面将详细阐述这个项目的重点内容。 首先，HTTP协议是互联网上应用最广泛的...
一种Linux多线程应用下内存池的设计与实现
10-18
在Linux多线程应用下，内存池的设计和实现尤为重要，因为它能有效解决传统内存分配带来的性能问题和内存碎片。 传统的动态内存管理（如malloc和new）在频繁的分配和释放过程中，会带来较高的开销，因为每次分配和...
多线程安全的内存池支持类
11-17
提供两个多线程安全的内存池支持类，详细的内容请看类说明
一种Linux多线程应用下内存池的设计与实现.pdf
09-06
Linux 多线程应用下内存池的设计与实现 在本文中，我们将深入探讨 Linux 多线程应用下内存池的设计与实现。内存池是一种高效的内存管理机制，它可以在多线程环境下快速地分配和释放内存，从而提高系统的性能和效率...
多线程内存池实现
Always On The Way
01-08 1359
多线程的内存池是基于模板的类： 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 1361
为了使多个线程并发地分配和释放内存，必须在分配器方法中添加互斥锁。 全局内存管理器(通过new()和delete()实现)是通用的，因此它的开销也非常大。 因为单线程内存管理器要比多线程内存管理器快的多，所以如果要分配的大多数内存块限于单线程中使用，那么可以显著提升性能。 如果开发了一套有效的单线程分配器，那么通过模板可以方便地将它们扩展到多线程环境中。 以下是测试代码(multi_thr...
用C++实现自己的内存池
热门推荐
Bruce Che 的专栏
12-14 1万+
打开浏览器，搜索了下内存管理的概念，百度百科中是这样定义的：内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。说到内存，与之紧密相联系的一个概念就是指针。回想起上学那会儿，自己对指针是即喜欢，又害怕。因为学好了指针，就可以学好C，继而学好C++，但面对那些晦涩的概念，和程序运行中一些莫名其妙的指针越界、内存泄露……
Qt的内存管理
leon
01-04 1万+
在QT的程序中经常会看到只有new而不delete的情况，其实是因为QT有一套回收内存的机制，主要的规则如下：1.所有继承自QOBJECT类的类，如果在new的时候指定了父亲，那么它的清理时在父亲被delete的时候delete的，所以如果一个程序中，所有的QOBJECT类都指定了父亲，那么他们是会一级级的在最上面的父亲清理时被清理，而不用自己清理；2.程序通常最上层会有一个根的QOBJE
linux进程线程内存分布,一种Linux多线程应用下内存池的设计与实现
weixin_39671467的博客
04-28 198
摘 要：对内存池中内存块获取、分配机制、内存块大小、内存释放，以及在多线程环境下的安全处理等细节进行了研究，保证了在多线程环境下能够快速同时采用一种基于数组的链表机制，改进内存池中内存块的查找算法，将其时间复杂度稳定在O(1)，避免了传统内存池中请求的线程数目过多时，引发的获取内存块性能下降的问题。同时在内部设置管理线程，动态增加或删除空闲的内存块。实验结果表明，改进后的内存池与传统的内存分配方式...
多线程高并发内存池c语言实现,高并发内存池的实现
weixin_32042959的博客
05-22 752
第一层:Thread Cache(线程缓存)1.thread cache是内存池中的第一层缓存，这一层缓存主要解决的问题就是并发状态下锁竞争的效率问题。线程在这里申请不需要加锁，每一个线程都有自己独立的cache，这也就是这个项目并发高效的地方。怎么实现每个线程都拥有自己唯一的线程缓存呢？为了避免加锁带来的效率，在Thread Cache中使用(tls)thread local storage保存...
一步一步写线程之十一线程池应用内存池
最新发布
fpcc的专栏
05-03 373
可能有的同学说这个和在网上或者书上看到的内存池不大一样啊？其实本质是一样的。直接分配内存控制比特流，然后再分块拆分和上面的直接进行对象分配本质是相同的，不同的在于可能直接使用比特流会更灵活。或者说把本文叫做对象池，可能就更容易理解了。这一篇只是针对线程池中的内存池应用进行一个基础的分析说明，后面会抽时间对内存池有一个全面的分析说明。诸如内存池的大小分组（微型、小型、中型、大型）和是否连续处置（内存一次分配，分块使用）等，本文都没有涉及，目的只是一个很简单的在线程池中使用内存池，知其所以然即可。
你要的多线程内存池 GNU 帮你写好了
weixin_41041321的博客
09-05 142
#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...
发布一个多线程安全的内存池
12-21 721
根据肖舸的《0bug C++商用编程之道》中的内存池做的一些修改。 关于其中读写部分，各位可参照肖舸的读写锁，或者自行替换，毕竟这东西只有写没有读。 主要改进1.去掉递归查找分配块大小部分。改用函数直接计算出到需要的块大小 改进2.使用双向链表取代固定大小的数组。 改进3.释放和没释放的内存块均在双向链表中保存。方便调试输出 *******************************
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值