主要起到一个缓冲或者中介的作用，它指向的chunk是chunks_中唯一一个空的chunk(内存未分配出去，全部在手上)，chunks_里面只能用一个空chunk，如果没用空的chunk那么emptyChunk_为NULL。emptyChunk重要其的是一个缓冲的作用，当allocChunk指向的chunk分配完之后那么久将emptyChunk给allocChunk用，如果deallocChunk_指向chunk把分配出去的内存都回收回来变为一个空chunk之后，如果

指向chunks_中的元素，主要用于分配内存，如果为NULL或者指向的chunk已经分配完(掌管的内存都给别人用了)，那么就将emptyChunk_指向的chunk给allocChunk_用，如果emptyChunk为NULL说明chunks_里面没有一个空的chunk(这里空chunk指的是未分配过内存到外面或者内存已经全部回收回来的chunk，即自己通过pData_掌管的内存都在自己手里)，那么就会新建一个然后添加到chunks_中，并且将allocChunk_指向新添加的

指向chunk_中的元素，主要用于回收内存，当指向的chunk回收全部已经分配出去的内存之后就将这个chunk交给emptyChunk_管理，然后指向新的chunk

可以看出其实emptyChunk_起到桥梁的作用，它要保证chunks_中有且只有一个空的chunk，这样可以节约内存的使用，同时又能快速的分配，下面看一下FixedAllocator分配与回收内存代码.

/***********************************************************************
 *                                分配内存                              *
 ***********************************************************************/
void * FixedAllocator::Allocate( void )
{
    if ( ( NULL == allocChunk_ ) || allocChunk_->IsFilled() ) //如果allocChunk_不可用的话
    {
        if ( NULL != emptyChunk_ )
        {
            allocChunk_ = emptyChunk_; //将emptyChunk_保存的emptyChunk_交给allocChunk_
            emptyChunk_ = NULL;
        }
        else
        {
            // 在chunks_中找到一个合适的chunk给allocChunk否则就新建一个chunk并push到chunks中
            for ( ChunkIter i( chunks_.begin() ); ; ++i )
            {
                if ( chunks_.end() == i )
                {
                    if ( !MakeNewChunk() )
                        return NULL;
                    break;
                }
                if ( !i->IsFilled() )
                {
                    allocChunk_ = &*i;
                    break;
                }  
            }
        }
    }
    else if ( allocChunk_ == emptyChunk_)
        // detach emptyChunk_ from allocChunk_, because after 
        // calling allocChunk_->Allocate(blockSize_); the chunk 
        // is no longer empty.
        emptyChunk_ = NULL;

    assert( allocChunk_ != NULL );
    assert( !allocChunk_->IsFilled() );
    //通过
    void * place = allocChunk_->Allocate( blockSize_ );
    // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
    assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
    assert( CountEmptyChunks() < 2 );
    return place;
}

/***********************************************************************
 *                                回收内存                             *
 ***********************************************************************/
bool FixedAllocator::Deallocate( void * p, Chunk * hint )
{
// VicinityFind的作用是从chunks中找到p所属的chunk，可以简单的遍历所用的chunks元素，但是loki库中考虑到效率，用了比较特殊的查找方法，看后面代码
    Chunk * foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint; 
    if ( NULL == foundChunk )
        return false;
    assert( foundChunk->HasBlock( p, numBlocks_ * blockSize_ ) );
    deallocChunk_ = foundChunk;
    DoDeallocate(p);
    assert( CountEmptyChunks() < 2 ); //确保chunks中不会多余一个空的chunk
    return true;
}

void FixedAllocator::DoDeallocate(void* p)
{
    // call into the chunk, will adjust the inner list but won‘t release memory
    deallocChunk_->Deallocate(p, blockSize_);
    if ( deallocChunk_->HasAvailable( numBlocks_ ) ) // 判断deallocChunk指向的chunk是否已经回收完自己分配出去的内存,如果是就将这个chunk交给emptyChunk管理
    {
        if ( NULL != emptyChunk_ )//如果emptyChunk已经指向一个空的chunk的话，需要将这个chunk释放掉
        {
            // If last Chunk is empty, just change what deallocChunk_
            // points to, and release the last.  Otherwise, swap an empty
            // Chunk with the last, and then release it.
            // 这里为了效率，将vector的最后一个元素与emptyChunk交换，然后pop_back ，而不是直接erase
            Chunk * lastChunk = &chunks_.back();
            if ( lastChunk == deallocChunk_ ) //最后一个元素，直接指向emptyChunk就可以
                deallocChunk_ = emptyChunk_;
            else if ( lastChunk != emptyChunk_ ) 
                std::swap( *emptyChunk_, *lastChunk );
            assert( lastChunk->HasAvailable( numBlocks_ ) );
            lastChunk->Release();
            chunks_.pop_back();
            //防止该release的chunk是allocChunk
            if ( ( allocChunk_ == lastChunk ) || allocChunk_->IsFilled() ) 
                allocChunk_ = deallocChunk_;
        }
        emptyChunk_ = deallocChunk_;
    }
    // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
    assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
}

最后剩下一个问题就是，在dealloc的时候如何知道释放的内存所在的chunk，在dealloc函数中的第一行代码可以看出算法在VicintyFind中实现，大致思想是用deallocChunk指向的位置向两端查找，通过Chunk::HasBlock判断p指向的内存是否属于某个Chunk

Chunk * FixedAllocator::VicinityFind( void * p ) const
{
    if ( chunks_.empty() ) return NULL;
    const std::size_t chunkLength = numBlocks_ * blockSize_;
    Chunk * lo = deallocChunk_;
    Chunk * hi = deallocChunk_ + 1;
    const Chunk * loBound = &chunks_.front();
    const Chunk * hiBound = &chunks_.back() + 1;
    // Special case: deallocChunk_ is the last in the array
    if (hi == hiBound) hi = NULL;
    {
        if (lo)
        {
            if ( lo->HasBlock( p, chunkLength ) ) return lo;
            if ( lo == loBound )
            {
                lo = NULL;
                if ( NULL == hi ) break;
            }
            else --lo;
        }
        if (hi)
        {
            if ( hi->HasBlock( p, chunkLength ) ) return hi;
            if ( ++hi == hiBound )
            {
                hi = NULL;
                if ( NULL == lo ) break;
            }
        }
    }
    return NULL;
}

它继承自SmallObjAllocator,AllocatorSingleton有多个模板参数，主要的策略算法有用于管理自己单件模式的生命期策略，线程同步策略，类原型:

    template
    <
        template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
        std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE,
        std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
        std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
        template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
        class MutexPolicy = LOKI_DEFAULT_MUTEX
    >
    class AllocatorSingleton : public SmallObjAllocator
    {
//        ...
// 单件模式
        inline static AllocatorSingleton & Instance( void )
        {
            return MyAllocatorSingleton::Instance();
        }
     }

该类提供线程锁操作，重载了new与delete，属于应用层提供给用户使用，内存的申请与释放都是通过单例AllocatorSingleton.allocate来操作

template
<
    template <class, class> class ThreadingModel,
    std::size_t chunkSize,
    std::size_t maxSmallObjectSize,
    std::size_t objectAlignSize,
    template <class> class LifetimePolicy,
    class MutexPolicy
>
class SmallObjectBase{
    //....
    typedef AllocatorSingleton< ThreadingModel, chunkSize,
        maxSmallObjectSize, objectAlignSize, LifetimePolicy > ObjAllocatorSingleton;
    typedef typename ObjAllocatorSingleton::MyAllocatorSingleton MyAllocatorSingleton;
    // 重载new操作符
    static void * operator new ( std::size_t size ) throw ( std::bad_alloc )
    {
        typename MyThreadingModel::Lock lock;
        (void)lock; // get rid of warning
        return MyAllocatorSingleton::Instance().Allocate( size, true );
    }
    //....
    }

实际使用的SmallObject仅仅是继承自SmallObjectBase