Shulou(Shulou.com)06/01 Report--

This "C++ how to achieve object pool" article, the article example code introduction is very detailed, has a certain reference value, interested friends must refer to, for "C++ how to achieve object pool", the editor sorted out the following knowledge points, please follow the pace of the editor step by step slowly understand, then let's get into the topic.

Preface

When the demand is unlimited, but the resources are limited, it is necessary to manage the resources specially. Constantly requesting and releasing memory is unreasonable, resulting in memory fluctuations and unrestricted memory growth. For example, the implementation of a message queue, when the speed of sending messages is faster than the speed of processing messages, if resources are not controlled, memory will continue to grow. Unless there is a special memory management mechanism, or an explicit compiler optimizes memory reuse, it is necessary to establish a resource management module. Object pool is a module that reuses and manages a limited number of resources.

What is object Pool

Reuse objects, eliminate the performance consumption caused by frequent object creation and destruction, and avoid uncontrollable memory growth. For example, thread pooling and connection pooling are all designed to reuse objects.

For example: suppose that in the producer-consumer model, the producer creates the object while the consumer consumes it and then destroys the object. The direct and simple use of new and delete will cause additional performance consumption due to frequent object creation and destruction, and when the producer speed is faster than the consumer speed, the number of objects created will be greater than the destruction, resulting in uncontrolled memory growth. If you use object pooling, you can reuse a fixed number of objects for production and consumption, avoiding frequent creation of destroyed objects and uncontrolled memory growth.

Second, how to achieve 1. Determine the interface

(1) determine the dynamic relationship

Through the sequence diagram, we can determine the interface required by the object. We draw the sequence diagram with the socket service as the scene, as follows

(2) determine the static relationship

Draw the class diagram according to the interface determined by the above sequence diagram, as follows:

two。 Convert to code

Because the module is small and there are not many interfaces, there is no further refinement of the design. Because this article is about C++ implementation object pool, the above design is transformed into C++ interface definition. It is as follows:

/ object pool / class ObjectPool {public: / constructor / buffer of the object pool, specified externally, can be understood as an array. Array size should satisfy bufferSize > = elementSize*arraySize / / Array element size / Array length or number of elements ObjectPool (void* bufferArray, int elementSize, int arraySize) / Application object / / if there are not enough objects in the pool, it will wait until an object is returned. / returns the requested object pointer void* Applicate () / the application object / timeout. Return null / return the object pointer void* Applicate (int timeout) of the application after the timeout / return object / object to be returned void ReturnBack (void* element);}; III. Complete code

According to the above preliminary design, and then refine, as well as the implementation, and finally get the following code implementation.

ObjectPool.h

# ifndef OBJECTPOOL_H#define OBJECTPOOL_H/**** @ Project: AC::ObjectPool* @ Decription: object pool: "the demand is very large, but the quantity is limited" Special management of resources is required * it is unreasonable to constantly request and release objects (unless there is a special memory management mechanism or explicit compilation to optimize memory reuse). * this is a reuse management module for a limited number of resources. * @ Verision: v1.0.0.1* @ Author: Xin Nie* @ Create: 2018-12-21 1315 1315 00 * @ LastUpdate: 2022-1-5 13 53 15 53 15 00 * * Copyright @ 2022. All rights reserved.****/#include#include#include#includenamespace AC {/ object pool / class ObjectPool {public: / constructor / buffer of the object pool Specified externally and can be understood as an array. Array size should satisfy bufferSize > = elementSize*arraySize / / Array element size / Array length or number of elements ObjectPool (void* bufferArray, int elementSize, int arraySize); / destructing method / / ~ ObjectPool () / Application object / / if there are not enough objects in the pool, it will wait until an object is returned. / returns the requested object pointer void* Applicate () / the application object / timeout. Return null / return the object pointer void* Applicate (int timeout) of the application after the timeout / return object / object to be returned void ReturnBack (void* element) / get the buffer of the object pool, that is, the pointer void* GetPoolBuffer () of the bufferArray / buffer in the constructor. / get the size of the object, that is, the size of the elementSize / object in the constructor int GetObjectSize () / get the total number of objects, that is, the total number of objects in the constructor int GetObjectCount (); private: void*_buffer = NULL; int _ elementSize; int _ arraySize Std::vector _ unusedUnits; std::unordered_map _ usedUnits; std::mutex _ mutex; std::condition_variable _ cond;} / generic object pool / object type template class ObjectPoolGeneric:private ObjectPool {public: / Constructor / number of objects Group / / Array size / ObjectPoolGeneric (T*array Int size): ObjectPool (array, sizeof (T) Size) {} / destructor / / ~ ObjectPoolGeneric () {} / Application object / if there are not enough objects in the pool, it will wait Do not return until there is an object. / returns the requested object pointer T* Applicate () {return (T*) ObjectPool::Applicate () } / the applicant / timeout Return null / return the requested object pointer T* Applicate (int timeout) {return (T*) ObjectPool::Applicate (timeout) after timeout } / return object / object to be returned void ReturnBack (T* element) {ObjectPool::ReturnBack (element) } / get the buffer of the object pool, that is, the pointer T* GetPoolBuffer () {return (T*) ObjectPool::GetPoolBuffer () of the bufferArray / buffer in the constructor. };} # endif

ObjectPool.cpp

# include "ObjectPool.h" # include namespace AC {ObjectPool::ObjectPool (void* bufferArray, int elementSize, int arraySize) {if (elementSize)

< 1 || arraySize < 1) return; _buffer = bufferArray; _elementSize = elementSize; _arraySize = arraySize; char* firstAdress = (char*)bufferArray; //记录未使用的索引 for (int i = 0; i < arraySize; i++) { _unusedUnits.push_back(&(firstAdress[i * elementSize])); } } ObjectPool::~ObjectPool() { } void* ObjectPool::Applicate() { return Applicate(-1); } void* ObjectPool::Applicate(int timeout) { void* resource = NULL; std::unique_lock l(_mutex); while (_unusedUnits.size() < 1) { if (timeout == -1) { _cond.wait(l); } else if (_cond.wait_for(l, std::chrono::microseconds(timeout)) == std::cv_status::timeout) { return nullptr; } } resource = _unusedUnits.back(); _usedUnits[resource] = 1; _unusedUnits.pop_back(); return resource; } void ObjectPool::ReturnBack(void* element) { _mutex.lock(); auto iter = _usedUnits.find(element); if (iter != _usedUnits.end()) { _unusedUnits.push_back(element); _usedUnits.erase(iter); _cond.notify_one(); } _mutex.unlock(); } void* ObjectPool::GetPoolBuffer() { return _buffer; } int ObjectPool::GetObjectSize() { return _elementSize; } int ObjectPool::GetObjectCount() { return _arraySize; }}四、使用示例1、对象复用，示例：#include "ObjectPool.h"class A {public: A() { printf("%p\n", this); }};int main(int argc, char** argv) { //初始化对象池，2个对象 AC::ObjectPool objectPool(new char[sizeof(A) * 2], sizeof(A), 2); A* a, * b, * c; //申请对象，使用定位new初始化对象 a = new (objectPool.Applicate())A; b = new (objectPool.Applicate())A; //归还对象 a->

~ A (); / / reinitialize object objectPool.ReturnBack (a); c = new (objectPool.Applicate ()) A; b-> ~ A (); c-> ~ A (); / / delete cache delete objectPool.GetPoolBuffer () at the end of use; return 0;}

Output:

016502E9

016502E8

016502E9

2. Simple thread pool, for example: # include # include "ObjectPool.h" class ThreadInfo {public: std::thread* pThread; std::mutex _ mutext; std::condition_variable _ cv; std::function _ threadPoc;}; / / an array of thread information. The array length is the number of threads in the thread pool ThreadInfo _ threadArray [3] / object pool, initializing AC::ObjectPoolGeneric_threadPool (_ threadArray, 3) with thread information array; bool _ exitThreadPool = false;// thread pool running method void RunInThreadPool (std::function f) {/ / Application thread auto threadInfo = _ threadPool.Applicate (); threadInfo- > _ threadPoc = f If (threadInfo- > pThread) / / Multiplexing thread {threadInfo- > _ cv.notify_one () } else / / create thread {threadInfo- > pThread = new std::thread ([=] () {while (! _ exitThreadPool) {printf ("thread% d run\ n", threadInfo- > pThread- > get_id ()) If (threadInfo- > _ threadPoc) {/ / execute thread operation threadInfo- > _ threadPoc () } printf ("thread% d stop\ n", threadInfo- > pThread- > get_id ()); / / return thread _ threadPool.ReturnBack (threadInfo); std::unique_locklck (threadInfo- > _ mutext) ThreadInfo- > _ cv.wait (lck);}}) }} int main (int argc, char** argv) {while (true) {/ / running method RunInThreadPool in thread pool ([] () {std::this_thread::sleep_for (std::chrono::milliseconds (1000));});} return 0;}

Output:

Thread 69664 run

Thread 57540 run

Thread 56876 run

Thread 69664 stop

Thread 69664 run

Thread 57540 stop

Thread 56876 stop

Thread 57540 run

Thread 56876 run

Thread 69664 stop

Thread 69664 run

Thread 56876 stop

Thread 57540 stop

Thread 56876 run

Thread 57540 run

Thread 69664 stop

...

These are all the contents of the article "how C++ achieves object pooling". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.