mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-12-04 21:42:39 +00:00
304 lines
7.7 KiB
C++
304 lines
7.7 KiB
C++
//
|
|
// ObjectPool.h
|
|
//
|
|
// Library: Foundation
|
|
// Package: Core
|
|
// Module: ObjectPool
|
|
//
|
|
// Definition of the ObjectPool template class and friends.
|
|
//
|
|
// Copyright (c) 2010-2012, Applied Informatics Software Engineering GmbH.
|
|
// and Contributors.
|
|
//
|
|
// SPDX-License-Identifier: BSL-1.0
|
|
//
|
|
|
|
|
|
#ifndef Foundation_ObjectPool_INCLUDED
|
|
#define Foundation_ObjectPool_INCLUDED
|
|
|
|
|
|
#include <cctype>
|
|
#include <vector>
|
|
#include "Poco/AutoPtr.h"
|
|
#include "Poco/Condition.h"
|
|
#include "Poco/Mutex.h"
|
|
#include "Poco/Poco.h"
|
|
#include "Poco/SharedPtr.h"
|
|
|
|
|
|
namespace Poco
|
|
{
|
|
|
|
|
|
template <class C, class P = C *>
|
|
class PoolableObjectFactory
|
|
/// A PoolableObjectFactory is responsible for creating and resetting
|
|
/// objects managed by an ObjectPool.
|
|
///
|
|
/// Together with an ObjectPool, a PoolableObjectFactory is used as
|
|
/// a policy class to change the behavior of the ObjectPool when
|
|
/// creating new objects, returning used objects back to the pool
|
|
/// and destroying objects, when the pool itself is destroyed or
|
|
/// shrunk.
|
|
{
|
|
public:
|
|
P createObject()
|
|
/// Create and return a new object.
|
|
{
|
|
return new C;
|
|
}
|
|
|
|
bool validateObject(P pObject)
|
|
/// Checks whether the object is still valid
|
|
/// and can be reused.
|
|
///
|
|
/// Returns true if the object is valid,
|
|
/// false otherwise.
|
|
///
|
|
/// To maintain the integrity of the pool, this method
|
|
/// must not throw an exception.
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void activateObject(P pObject)
|
|
/// Called before an object is handed out by the pool.
|
|
/// Also called for newly created objects, before
|
|
/// they are given out for the first time.
|
|
{
|
|
}
|
|
|
|
void deactivateObject(P pObject)
|
|
/// Called after an object has been given back to the
|
|
/// pool and the object is still valid (a prior call
|
|
/// to validateObject() returned true).
|
|
///
|
|
/// To maintain the integrity of the pool, this method
|
|
/// must not throw an exception.
|
|
{
|
|
}
|
|
|
|
void destroyObject(P pObject)
|
|
/// Destroy an object.
|
|
///
|
|
/// To maintain the integrity of the pool, this method
|
|
/// must not throw an exception.
|
|
{
|
|
delete pObject;
|
|
}
|
|
};
|
|
|
|
|
|
template <class C>
|
|
class PoolableObjectFactory<C, Poco::AutoPtr<C>>
|
|
{
|
|
public:
|
|
Poco::AutoPtr<C> createObject() { return new C; }
|
|
|
|
bool validateObject(Poco::AutoPtr<C> pObject) { return true; }
|
|
|
|
void activateObject(Poco::AutoPtr<C> pObject) { }
|
|
|
|
void deactivateObject(Poco::AutoPtr<C> pObject) { }
|
|
|
|
void destroyObject(Poco::AutoPtr<C> pObject) { }
|
|
};
|
|
|
|
|
|
template <class C>
|
|
class PoolableObjectFactory<C, Poco::SharedPtr<C>>
|
|
{
|
|
public:
|
|
Poco::SharedPtr<C> createObject() { return new C; }
|
|
|
|
bool validateObject(Poco::SharedPtr<C> pObject) { return true; }
|
|
|
|
void activateObject(Poco::SharedPtr<C> pObject) { }
|
|
|
|
void deactivateObject(Poco::SharedPtr<C> pObject) { }
|
|
|
|
void destroyObject(Poco::SharedPtr<C> pObject) { }
|
|
};
|
|
|
|
|
|
template <class C, class P = C *, class F = PoolableObjectFactory<C, P>>
|
|
class ObjectPool
|
|
/// An ObjectPool manages a pool of objects of a certain class.
|
|
///
|
|
/// The number of objects managed by the pool can be restricted.
|
|
///
|
|
/// When an object is requested from the pool:
|
|
/// - If an object is available from the pool, an object from the pool is
|
|
/// removed from the pool, activated (using the factory) and returned.
|
|
/// - Otherwise, if the peak capacity of the pool has not yet been reached,
|
|
/// a new object is created and activated, using the object factory, and returned.
|
|
/// - If the peak capacity has already been reached, null is returned after timeout.
|
|
///
|
|
/// When an object is returned to the pool:
|
|
/// - If the object is valid (checked by calling validateObject()
|
|
/// from the object factory), the object is deactivated. If the
|
|
/// number of objects in the pool is below the capacity,
|
|
/// the object is added to the pool. Otherwise it is destroyed.
|
|
/// - If the object is not valid, it is destroyed immediately.
|
|
{
|
|
public:
|
|
ObjectPool(std::size_t capacity, std::size_t peakCapacity)
|
|
: /// Creates a new ObjectPool with the given capacity
|
|
/// and peak capacity.
|
|
///
|
|
/// The PoolableObjectFactory must have a public default constructor.
|
|
_capacity(capacity)
|
|
, _peakCapacity(peakCapacity)
|
|
, _size(0)
|
|
{
|
|
poco_assert(capacity <= peakCapacity);
|
|
}
|
|
|
|
ObjectPool(const F & factory, std::size_t capacity, std::size_t peakCapacity)
|
|
: /// Creates a new ObjectPool with the given PoolableObjectFactory,
|
|
/// capacity and peak capacity. The PoolableObjectFactory must have
|
|
/// a public copy constructor.
|
|
_factory(factory)
|
|
, _capacity(capacity)
|
|
, _peakCapacity(peakCapacity)
|
|
, _size(0)
|
|
{
|
|
poco_assert(capacity <= peakCapacity);
|
|
}
|
|
|
|
~ObjectPool()
|
|
/// Destroys the ObjectPool.
|
|
{
|
|
try
|
|
{
|
|
for (typename std::vector<P>::iterator it = _pool.begin(); it != _pool.end(); ++it)
|
|
{
|
|
_factory.destroyObject(*it);
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
poco_unexpected();
|
|
}
|
|
}
|
|
|
|
P borrowObject(long timeoutMilliseconds = 0)
|
|
/// Obtains an object from the pool, or creates a new object if
|
|
/// possible.
|
|
///
|
|
/// Returns null if no object is available after timeout.
|
|
///
|
|
/// If activating the object fails, the object is destroyed and
|
|
/// the exception is passed on to the caller.
|
|
{
|
|
Poco::FastMutex::ScopedLock lock(_mutex);
|
|
|
|
if (!_pool.empty())
|
|
{
|
|
P pObject = _pool.back();
|
|
_pool.pop_back();
|
|
return activateObject(pObject);
|
|
}
|
|
|
|
if (_size >= _peakCapacity)
|
|
{
|
|
if (timeoutMilliseconds == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
while (_size >= _peakCapacity)
|
|
{
|
|
if (!_availableCondition.tryWait(_mutex, timeoutMilliseconds))
|
|
{
|
|
// timeout
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// _size < _peakCapacity
|
|
P pObject = _factory.createObject();
|
|
activateObject(pObject);
|
|
_size++;
|
|
return pObject;
|
|
}
|
|
|
|
void returnObject(P pObject)
|
|
/// Returns an object to the pool.
|
|
{
|
|
Poco::FastMutex::ScopedLock lock(_mutex);
|
|
|
|
if (_factory.validateObject(pObject))
|
|
{
|
|
_factory.deactivateObject(pObject);
|
|
if (_pool.size() < _capacity)
|
|
{
|
|
try
|
|
{
|
|
_pool.push_back(pObject);
|
|
return;
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
_factory.destroyObject(pObject);
|
|
_size--;
|
|
_availableCondition.signal();
|
|
}
|
|
|
|
std::size_t capacity() const { return _capacity; }
|
|
|
|
std::size_t peakCapacity() const { return _peakCapacity; }
|
|
|
|
std::size_t size() const
|
|
{
|
|
Poco::FastMutex::ScopedLock lock(_mutex);
|
|
|
|
return _size;
|
|
}
|
|
|
|
std::size_t available() const
|
|
{
|
|
Poco::FastMutex::ScopedLock lock(_mutex);
|
|
|
|
return _pool.size() + _peakCapacity - _size;
|
|
}
|
|
|
|
protected:
|
|
P activateObject(P pObject)
|
|
{
|
|
try
|
|
{
|
|
_factory.activateObject(pObject);
|
|
}
|
|
catch (...)
|
|
{
|
|
_factory.destroyObject(pObject);
|
|
throw;
|
|
}
|
|
return pObject;
|
|
}
|
|
|
|
private:
|
|
ObjectPool();
|
|
ObjectPool(const ObjectPool &);
|
|
ObjectPool & operator=(const ObjectPool &);
|
|
|
|
F _factory;
|
|
std::size_t _capacity;
|
|
std::size_t _peakCapacity;
|
|
std::size_t _size;
|
|
std::vector<P> _pool;
|
|
mutable Poco::FastMutex _mutex;
|
|
Poco::Condition _availableCondition;
|
|
};
|
|
|
|
|
|
} // namespace Poco
|
|
|
|
|
|
#endif // Foundation_ObjectPool_INCLUDED
|