建立某个类对象池

应用场景：比如建立数据库连接对象池，可以避免重复进行数据库连接、释放操作。

DemoClass.h

#pragma once

#include <iostream>

using namespace std;

class DemoClass
{
public:
    bool CreateConn();
    bool CloseConn();
};　

DemoClass.cpp

#include "DemoClass.h"

using namespace std;

bool DemoClass::CreateConn()
{
    //to do 
    return true;
}

bool DemoClass::CloseConn()
{
    //to do
    return true;
}　　

PoolMgr.h

#pragma once
#define HAVE_STRUCT_TIMESPEC

#include <iostream>
#include <deque>
#include <queue>
#include <pthread.h>
#include "DemoClass.h"

using namespace std;

class PoolMgr
{
public:
    PoolMgr();
    ~PoolMgr();

    bool Init(int iNum);
    void UnInit();

    DemoClass* GetValidObject();
    bool ReleaseObject(DemoClass* pDemoClass);

    deque<DemoClass*> m_deqUsed; //已经在使用的
    queue<DemoClass*> m_queIdle; //空闲的

    pthread_mutex_t m_pMutex;
};

poolMgr.cpp

#include "PoolMgr.h"

PoolMgr::PoolMgr()
{
    m_pMutex = PTHREAD_MUTEX_INITIALIZER;
}

PoolMgr::~PoolMgr()
{

}

bool PoolMgr::Init(int iNum)
{
    UnInit();

    for (int i = 0; i < iNum; i++)
    {
        DemoClass* pDemoClass = nullptr;
        pDemoClass = new DemoClass();

        if (pDemoClass != nullptr)
        {
            m_queIdle.push(pDemoClass);
        }
    }

    cout << "DemoClass pool size:" << m_queIdle.size() << endl;
    return true;
}

void PoolMgr::UnInit()
{
    pthread_mutex_lock(&m_pMutex);
    deque<DemoClass*>().swap(m_deqUsed);
    queue<DemoClass*>().swap(m_queIdle);
    pthread_mutex_unlock(&m_pMutex);
}

DemoClass* PoolMgr::GetValidObject()
{
    pthread_mutex_lock(&m_pMutex);
    if (m_queIdle.empty())
    {
        cout << "no idle demoObject" << endl;
        return nullptr;
    }

    DemoClass* pDemoClass = m_queIdle.front();
    m_deqUsed.push_back(pDemoClass);
    m_queIdle.pop();

    cout << "pool used size:" << m_deqUsed.size() << "|pool idle size:" << m_queIdle.size() << endl;
    pthread_mutex_unlock(&m_pMutex);

    return pDemoClass;
}

bool PoolMgr::ReleaseObject(DemoClass* pDemoClass)
{
    pthread_mutex_lock(&m_pMutex);
    auto iter = std::find(m_deqUsed.begin(), m_deqUsed.end(), pDemoClass);
    if (iter == m_deqUsed.end())
    {
        cout << "pDemoClass not find in used" << endl;
        return false;
    }

    m_queIdle.push(pDemoClass);
    m_deqUsed.erase(iter);

    cout << "pool used size:" << m_deqUsed.size() << "|pool idle size:" << m_queIdle.size() << endl;
    pthread_mutex_unlock(&m_pMutex);

    return true;
}

main.cpp

#include <iostream>
#include "PoolMgr.h"
using namespace std;

int main()
{
    PoolMgr poolMgr;
    poolMgr.Init(10);
    DemoClass* pDemoClass = poolMgr.GetValidObject();
    pDemoClass->CreateConn();
    pDemoClass->CloseConn();
    poolMgr.ReleaseObject(pDemoClass);

    return 0;
}

windows下配置 pthread 参见：https://blog.csdn.net/qianchenglenger/article/details/16907821