merged concurrent to main library

removed PIConditionLock, use PIMutex instead

lib/main/thread/piblockingdequeue.h

@@ -0,0 +1,245 @@
+/*
+	PIP - Platform Independent Primitives
+	
+	Stephan Fomenko
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PIBLOCKINGDEQUEUE_H
+#define PIBLOCKINGDEQUEUE_H
+
+#include "pideque.h"
+#include "piconditionvar.h"
+
+/**
+ * @brief A Queue that supports operations that wait for the queue to become non-empty when retrieving an element, and
+ * wait for space to become available in the queue when storing an element.
+ */
+template <typename T>
+class PIBlockingDequeue: private PIDeque<T> {
+public:
+
+	/**
+	 * @brief Constructor
+	 */
+	explicit inline PIBlockingDequeue(size_t capacity = SIZE_MAX,
+									  PIConditionVariable* cond_var_add = new PIConditionVariable(),
+									  PIConditionVariable* cond_var_rem = new PIConditionVariable())
+		: cond_var_add(cond_var_add), cond_var_rem(cond_var_rem), max_size(capacity) { }
+
+	/**
+	 * @brief Copy constructor. Initialize queue with copy of other queue elements. Not thread-safe for other queue.
+	 */
+	explicit inline PIBlockingDequeue(const PIDeque<T>& other) : cond_var_add(new PIConditionVariable()), cond_var_rem(new PIConditionVariable()) {
+		mutex.lock();
+		max_size = SIZE_MAX;
+		PIDeque<T>::append(other);
+		mutex.unlock();
+	}
+
+	/**
+	 * @brief Thread-safe copy constructor. Initialize queue with copy of other queue elements.
+	 */
+	inline PIBlockingDequeue(PIBlockingDequeue<T> & other) : cond_var_add(new PIConditionVariable()), cond_var_rem(new PIConditionVariable()) {
+		other.mutex.lock();
+		mutex.lock();
+		max_size = other.max_size;
+		PIDeque<T>::append(static_cast<PIDeque<T>&>(other));
+		mutex.unlock();
+		other.mutex.unlock();
+	}
+
+	~PIBlockingDequeue() {
+		delete cond_var_add;
+		delete cond_var_rem;
+	}
+
+	/**
+	 * @brief Inserts the specified element into this queue, waiting if necessary for space to become available.
+	 *
+	 * @param v the element to add
+	 */
+	void put(const T & v) {
+		mutex.lock();
+		cond_var_rem->wait(mutex, [&]() { return PIDeque<T>::size() < max_size; });
+		PIDeque<T>::push_back(v);
+		mutex.unlock();
+		cond_var_add->notifyOne();
+	}
+
+	/**
+	 * @brief Inserts the specified element at the end of this queue if it is possible to do so immediately without
+	 * exceeding the queue's capacity, returning true upon success and false if this queue is full.
+	 *
+	 * @param v the element to add
+	 * @return true if the element was added to this queue, else false
+	 */
+	bool offer(const T & v) {
+		mutex.lock();
+		if (PIDeque<T>::size() >= max_size) {
+			mutex.unlock();
+			return false;
+		}
+		PIDeque<T>::push_back(v);
+		mutex.unlock();
+		cond_var_add->notifyOne();
+		return true;
+	}
+
+	/**
+	 * @brief Inserts the specified element into this queue, waiting up to the specified wait time if necessary for
+	 * space to become available.
+	 *
+	 * @param v the element to add
+	 * @param timeoutMs how long to wait before giving up, in milliseconds
+	 * @return true if successful, or false if the specified waiting time elapses before space is available
+	 */
+	bool offer(const T & v, int timeoutMs) {
+		mutex.lock();
+		bool isOk = cond_var_rem->waitFor(mutex, timeoutMs, [&]() { return PIDeque<T>::size() < max_size; } );
+		if (isOk) PIDeque<T>::push_back(v);
+		mutex.unlock();
+		if (isOk) cond_var_add->notifyOne();
+		return isOk;
+	}
+
+	/**
+	 * @brief Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.
+	 *
+	 * @return the head of this queue
+	 */
+	T take() {
+		T t;
+		mutex.lock();
+		cond_var_add->wait(mutex, [&]() { return !PIDeque<T>::isEmpty(); });
+		t = T(PIDeque<T>::take_front());
+		mutex.unlock();
+		cond_var_rem->notifyOne();
+		return t;
+	}
+
+	/**
+	 * @brief Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an
+	 * element to become available.
+	 *
+	 * @param timeoutMs how long to wait before giving up, in milliseconds
+	 * @param defaultVal value, which returns if the specified waiting time elapses before an element is available
+	 * @param isOk flag, which indicates result of method execution. It will be set to false if timeout, or true if
+	 * return value is retrieved value
+	 * @return the head of this queue, or defaultVal if the specified waiting time elapses before an element is available
+	 */
+	T poll(int timeoutMs, const T & defaultVal = T(), bool * isOk = nullptr) {
+		T t;
+		mutex.lock();
+		bool isNotEmpty = cond_var_add->waitFor(mutex, timeoutMs, [&]() { return !PIDeque<T>::isEmpty(); });
+		t = isNotEmpty ? T(PIDeque<T>::take_front()) : defaultVal;
+		mutex.unlock();
+		if (isNotEmpty) cond_var_rem->notifyOne();
+		if (isOk) *isOk = isNotEmpty;
+		return t;
+	}
+
+	/**
+	 * @brief Retrieves and removes the head of this queue and return it if queue not empty, otherwise return defaultVal.
+	 * Do it immediately without waiting.
+	 *
+	 * @param defaultVal value, which returns if the specified waiting time elapses before an element is available
+	 * @param isOk flag, which indicates result of method execution. It will be set to false if timeout, or true if
+	 * return value is retrieved value
+	 * @return the head of this queue, or defaultVal if the specified waiting time elapses before an element is available
+	 */
+	T poll(const T & defaultVal = T(), bool * isOk = nullptr) {
+		T t;
+		mutex.lock();
+		bool isNotEmpty = !PIDeque<T>::isEmpty();
+		t = isNotEmpty ? T(PIDeque<T>::take_front()) : defaultVal;
+		mutex.unlock();
+		if (isNotEmpty) cond_var_rem->notifyOne();
+		if (isOk) *isOk = isNotEmpty;
+		return t;
+	}
+
+	/**
+	 * @brief Returns the number of elements that this queue can ideally (in the absence of memory or resource
+	 * constraints) contains. This is always equal to the initial capacity of this queue less the current size of this queue.
+	 *
+	 * @return the capacity
+	 */
+	size_t capacity() {
+		size_t c;
+		mutex.lock();
+		c = max_size;
+		mutex.unlock();
+		return c;
+	}
+
+	/**
+	 * @brief Returns the number of additional elements that this queue can ideally (in the absence of memory or resource
+	 * constraints) accept. This is always equal to the initial capacity of this queue less the current size of this queue.
+	 *
+	 * @return the remaining capacity
+	 */
+	size_t remainingCapacity() {
+		mutex.lock();
+		size_t c = max_size - PIDeque<T>::size();
+		mutex.unlock();
+		return c;
+	}
+
+	/**
+	 * @brief Returns the number of elements in this collection.
+	 */
+	size_t size() {
+		mutex.lock();
+		size_t s = PIDeque<T>::size();
+		mutex.unlock();
+		return s;
+	}
+
+	/**
+	 * @brief Removes all available elements from this queue and adds them to other given queue.
+	 */
+	size_t drainTo(PIDeque<T>& other, size_t maxCount = SIZE_MAX) {
+		mutex.lock();
+		size_t count = ((maxCount > PIDeque<T>::size()) ? PIDeque<T>::size() : maxCount);
+		for (size_t i = 0; i < count; ++i) other.push_back(PIDeque<T>::take_front());
+		mutex.unlock();
+		return count;
+	}
+
+	/**
+	 * @brief Removes all available elements from this queue and adds them to other given queue.
+	 */
+	size_t drainTo(PIBlockingDequeue<T>& other, size_t maxCount = SIZE_MAX) {
+		mutex.lock();
+		other.mutex.lock();
+		size_t count = maxCount > PIDeque<T>::size() ? PIDeque<T>::size() : maxCount;
+		size_t otherRemainingCapacity = other.max_size - static_cast<PIDeque<T> >(other).size();
+		if (count > otherRemainingCapacity) count = otherRemainingCapacity;
+		for (size_t i = 0; i < count; ++i) other.push_back(PIDeque<T>::take_front());
+		other.mutex.unlock();
+		mutex.unlock();
+		return count;
+	}
+
+private:
+	PIMutex mutex;
+	PIConditionVariable * cond_var_add, * cond_var_rem;
+	size_t max_size;
+
+};
+
+
+#endif // PIBLOCKINGDEQUEUE_H

lib/main/thread/piconditionvar.cpp

@@ -0,0 +1,141 @@
+/*
+	PIP - Platform Independent Primitives
+
+	Stephan Fomenko
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "piconditionvar.h"
+#include "pithread.h"
+#include "pitime.h"
+
+#ifdef WINDOWS
+#  undef _WIN32_WINNT
+#  define _WIN32_WINNT 0x0600
+#  include <synchapi.h>
+#  include <windef.h>
+#  include <winbase.h>
+#endif
+
+
+PRIVATE_DEFINITION_START(PIConditionVariable)
+#ifdef WINDOWS
+	CONDITION_VARIABLE nativeHandle;
+#else
+	pthread_cond_t nativeHandle;
+	PIMutex * currentLock;
+#endif
+	bool isDestroying;
+PRIVATE_DEFINITION_END(PIConditionVariable)
+
+
+PIConditionVariable::PIConditionVariable() {
+#ifdef WINDOWS
+	InitializeConditionVariable(&PRIVATE->nativeHandle);
+#else
+	PRIVATE->isDestroying = false;
+	PRIVATE->currentLock = nullptr;
+	memset(&(PRIVATE->nativeHandle), 0, sizeof(PRIVATE->nativeHandle));
+	pthread_cond_init(&PRIVATE->nativeHandle, NULL);
+#endif
+}
+
+
+PIConditionVariable::~PIConditionVariable() {
+#ifdef WINDOWS
+#else
+	pthread_cond_destroy(&PRIVATE->nativeHandle);
+#endif
+}
+
+
+void PIConditionVariable::wait(PIMutex& lk) {
+#ifdef WINDOWS
+	SleepConditionVariableCS(&PRIVATE->nativeHandle, (PCRITICAL_SECTION)lk.handle(), INFINITE);
+#else
+	pthread_cond_wait(&PRIVATE->nativeHandle, (pthread_mutex_t*)lk.handle());
+#endif
+}
+
+
+void PIConditionVariable::wait(PIMutex& lk, const std::function<bool()>& condition) {
+	bool isCondition;
+	while (true) {
+		isCondition = condition();
+		if (isCondition) break;
+#ifdef WINDOWS
+		SleepConditionVariableCS(&PRIVATE->nativeHandle, (PCRITICAL_SECTION)lk.handle(), INFINITE);
+#else
+		pthread_cond_wait(&PRIVATE->nativeHandle, (pthread_mutex_t*)lk.handle());
+#endif
+		if (PRIVATE->isDestroying) return;
+	}
+}
+
+
+bool PIConditionVariable::waitFor(PIMutex &lk, int timeoutMs) {
+	bool isNotTimeout;
+#ifdef WINDOWS
+	isNotTimeout = SleepConditionVariableCS(&PRIVATE->nativeHandle, (PCRITICAL_SECTION)lk.handle(), timeoutMs) != 0;
+#else
+	timespec abstime = {.tv_sec = timeoutMs / 1000, .tv_nsec = timeoutMs * 1000 * 1000};
+	isNotTimeout = pthread_cond_timedwait(&PRIVATE->nativeHandle, (pthread_mutex_t*)lk.handle(), &abstime) == 0;
+#endif
+	if (PRIVATE->isDestroying) return false;
+	return isNotTimeout;
+}
+
+
+bool PIConditionVariable::waitFor(PIMutex& lk, int timeoutMs, const std::function<bool()> &condition) {
+	bool isCondition;
+	PITimeMeasurer measurer;
+	while (true) {
+		isCondition = condition();
+		if (isCondition) break;
+#ifdef WINDOWS
+		WINBOOL isTimeout = SleepConditionVariableCS(
+					&PRIVATE->nativeHandle,
+					(PCRITICAL_SECTION)lk.handle(),
+					timeoutMs - (int)measurer.elapsed_m());
+		if (isTimeout == 0) return false;
+#else
+		int timeoutCurr = timeoutMs - (int)measurer.elapsed_m();
+		timespec abstime = {.tv_sec = timeoutCurr / 1000, .tv_nsec = timeoutCurr * 1000 * 1000};
+		bool isTimeout = pthread_cond_timedwait(&PRIVATE->nativeHandle, (pthread_mutex_t*)lk.handle(), &abstime) == 0;
+		if (isTimeout) return false;
+#endif
+		if (PRIVATE->isDestroying) return false;
+	}
+	return true;
+}
+
+
+void PIConditionVariable::notifyOne() {
+#ifdef WINDOWS
+	WakeConditionVariable(&PRIVATE->nativeHandle);
+#else
+	pthread_cond_signal(&PRIVATE->nativeHandle);
+#endif
+}
+
+
+void PIConditionVariable::notifyAll() {
+#ifdef WINDOWS
+	WakeAllConditionVariable(&PRIVATE->nativeHandle);
+#else
+	pthread_cond_broadcast(&PRIVATE->nativeHandle);
+#endif
+}
+

lib/main/thread/piconditionvar.h

@@ -0,0 +1,118 @@
+/*
+	PIP - Platform Independent Primitives
+	
+	Stephan Fomenko
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PICONDITIONVAR_H
+#define PICONDITIONVAR_H
+
+#include "pithread.h"
+
+
+/**
+ * @brief A condition variable is an object able to block the calling thread until notified to resume.
+ *
+ * It uses a PIMutex to lock the thread when one of its wait functions is called. The thread remains
+ * blocked until woken up by another thread that calls a notification function on the same PIConditionVariable object.
+ */
+class PIP_EXPORT PIConditionVariable {
+public:
+	NO_COPY_CLASS(PIConditionVariable)
+	explicit PIConditionVariable();
+	virtual ~PIConditionVariable();
+
+	/**
+	 * @brief Unblocks one of the threads currently waiting for this condition. If no threads are waiting, the function
+	 * does nothing. If more than one, it is unspecified which of the threads is selected.
+	 */
+	void notifyOne();
+
+	/**
+	 * @brief Unblocks all threads currently waiting for this condition. If no threads are waiting, the function does
+	 * nothing.
+	 */
+	void notifyAll();
+
+	/**
+	 * @brief see wait(PIMutex &, const std::function<bool()>&)
+	 */
+	virtual void wait(PIMutex & lk);
+
+	/**
+	 * @brief Wait until notified
+	 *
+	 * The execution of the current thread (which shall have locked with lk method PIMutex::lock()) is blocked
+	 * until notified.
+	 *
+	 * At the moment of blocking the thread, the function automatically calls lk.unlock() (PIMutex::unlock()),
+	 * allowing other locked threads to continue.
+	 *
+	 * Once notified (explicitly, by some other thread), the function unblocks and calls lk.lock() (PIMutex::lock()),
+	 * leaving lk in the same state as when the function was called. Then the function returns (notice that this last mutex
+	 * locking may block again the thread before returning).
+	 *
+	 * Generally, the function is notified to wake up by a call in another thread either to member notifyOne() or to
+	 * member notifyAll(). But certain implementations may produce spurious wake-up calls without any of these functions
+	 * being called. Therefore, users of this function shall ensure their condition for resumption is met.
+	 *
+	 * If condition is specified, the function only blocks if condition returns false, and notifications can only unblock
+	 * the thread when it becomes true (which is specially useful to check against spurious wake-up calls).
+	 *
+	 * @param lk lock object used by method wait for data protection
+	 * @param condition A callable object or function that takes no arguments and returns a value that can be evaluated
+	 * as a bool. This is called repeatedly until it evaluates to true.
+	 */
+	virtual void wait(PIMutex& lk, const std::function<bool()>& condition);
+
+	/**
+	 * @brief see waitFor(PIMutex &, int, const std::function<bool()>&)
+	 */
+	virtual bool waitFor(PIMutex & lk, int timeoutMs);
+
+	/**
+	 * @brief Wait for timeout or until notified
+	 *
+	 * The execution of the current thread (which shall have locked with lk method PIMutex::lock()) is blocked
+	 * during timeoutMs, or until notified (if the latter happens first).
+	 *
+	 * At the moment of blocking the thread, the function automatically calls lk.lock() (PIMutex::lock()), allowing
+	 * other locked threads to continue.
+	 *
+	 * Once notified or once timeoutMs has passed, the function unblocks and calls lk.unlock() (PIMutex::unlock()),
+	 * leaving lk in the same state as when the function was called. Then the function returns (notice that this last
+	 * mutex locking may block again the thread before returning).
+	 *
+	 * Generally, the function is notified to wake up by a call in another thread either to member notifyOne() or to
+	 * member notifyAll(). But certain implementations may produce spurious wake-up calls without any of these functions
+	 * being called. Therefore, users of this function shall ensure their condition for resumption is met.
+	 *
+	 * If condition is specified, the function only blocks if condition returns false, and notifications can only unblock
+	 * the thread when it becomes true (which is especially useful to check against spurious wake-up calls).
+	 *
+	 * @param lk lock object used by method wait for data protection
+	 * @param condition A callable object or function that takes no arguments and returns a value that can be evaluated
+	 * as a bool. This is called repeatedly until it evaluates to true.
+	 * @return false if timeout reached or true if wakeup condition is true
+	 */
+	virtual bool waitFor(PIMutex& lk, int timeoutMs, const std::function<bool()>& condition);
+
+private:
+	PRIVATE_DECLARATION
+};
+
+
+#endif // PICONDITIONVAR_H

lib/main/thread/pimutex.cpp

@@ -0,0 +1,122 @@
+/*
+	PIP - Platform Independent Primitives
+	Mutex
+	Ivan Pelipenko peri4ko@yandex.ru, Stephan Fomenko, Andrey Bychkov work.a.b@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/** \class PIMutex
+ * \brief Mutex
+ * \details
+ * \section PIMutex_sec0 Synopsis
+ * %PIMutex provides synchronization blocks between several threads.
+ * Using mutex guarantees execution of some code only one of threads.
+ * Mutex contains logic state and functions to change it: \a lock(),
+ * \a unlock() and \a tryLock().
+ *
+ * \section PIMutex_sec1 Usage
+ * Block of code that should to be executed only one thread simultaniously
+ * should to be started with \a lock() and ended with \a unlock().
+ * \snippet pimutex.cpp main
+ * "mutex" in this example is one for all threads.
+ *
+ * */
+
+#include "pimutex.h"
+#include "piincludes_p.h"
+#ifdef WINDOWS
+#  include <synchapi.h>
+#else
+#  include <pthread.h>
+#endif
+
+
+
+PRIVATE_DEFINITION_START(PIMutex)
+#ifdef WINDOWS
+	CRITICAL_SECTION
+#else
+	pthread_mutex_t
+#endif
+					mutex;
+PRIVATE_DEFINITION_END(PIMutex)
+
+
+PIMutex::PIMutex() {
+	init();
+}
+
+
+PIMutex::~PIMutex() {
+	destroy();
+}
+
+
+void PIMutex::lock() {
+#ifdef WINDOWS
+	EnterCriticalSection(&(PRIVATE->mutex));
+#else
+	pthread_mutex_lock(&(PRIVATE->mutex));
+#endif
+}
+
+
+void PIMutex::unlock() {
+#ifdef WINDOWS
+	LeaveCriticalSection(&(PRIVATE->mutex));
+#else
+	pthread_mutex_unlock(&(PRIVATE->mutex));
+#endif
+}
+
+
+bool PIMutex::tryLock() {
+	bool ret =
+#ifdef WINDOWS
+			(TryEnterCriticalSection(&(PRIVATE->mutex)) != 0);
+#else
+			(pthread_mutex_trylock(&(PRIVATE->mutex)) == 0);
+#endif
+	return ret;
+}
+
+
+void *  PIMutex::handle() {
+	return (void*)&(PRIVATE->mutex);
+}
+
+
+void PIMutex::init() {
+#ifdef WINDOWS
+	InitializeCriticalSection(&(PRIVATE->mutex));
+#else
+	pthread_mutexattr_t attr;
+	memset(&attr, 0, sizeof(attr));
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+	memset(&(PRIVATE->mutex), 0, sizeof(PRIVATE->mutex));
+	pthread_mutex_init(&(PRIVATE->mutex), &attr);
+	pthread_mutexattr_destroy(&attr);
+#endif
+}
+
+
+void PIMutex::destroy() {
+#ifdef WINDOWS
+	DeleteCriticalSection(&(PRIVATE->mutex));
+#else
+	pthread_mutex_destroy(&(PRIVATE->mutex));
+#endif
+}

lib/main/thread/pimutex.h

@@ -4,7 +4,7 @@
 /*
 	PIP - Platform Independent Primitives
 	PIMutexLocker
-	Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
+	Ivan Pelipenko peri4ko@yandex.ru, Stephan Fomenko, Andrey Bychkov work.a.b@yandex.ru
 
 	This program is free software: you can redistribute it and/or modify
 	it under the terms of the GNU Lesser General Public License as published by
@@ -24,6 +24,45 @@
 #define PIMUTEX_H
 
 #include "piinit.h"
+#include <mutex>
+
+
+class PIP_EXPORT PIMutex
+{
+public:
+	NO_COPY_CLASS(PIMutex)
+
+	//! Constructs unlocked mutex
+	explicit PIMutex();
+
+	//! Destroy mutex
+	~PIMutex();
+
+
+	//! \brief Lock mutex
+	//! \details If mutex is unlocked it set to locked state and returns immediate.
+	//! If mutex is already locked function blocks until mutex will be unlocked
+	void lock();
+
+	//! \brief Unlock mutex
+	//! \details In any case this function returns immediate
+	void unlock() ;
+
+	//! \brief Try to lock mutex
+	//! \details If mutex is unlocked it set to locked state and returns "true" immediate.
+	//! If mutex is already locked function returns immediate an returns "false"
+	bool tryLock();
+
+	void * handle();
+
+private:
+	void init();
+	void destroy();
+
+	PRIVATE_DECLARATION
+
+};
+
 
 //! \brief PIMutexLocker
 //! \details Same as std::lock_guard<std::mutex>.
@@ -40,7 +79,7 @@ public:
 	~PIMutexLocker() {if (cond) mutex.unlock();}
 private:
 	PIMutex & mutex;
-	std::atomic_bool cond;
+	bool cond;
 };
 
 #endif // PIMUTEX_H

lib/main/thread/pithreadmodule.h

@@ -25,5 +25,7 @@
 #include "pitimer.h"
 #include "pipipelinethread.h"
 #include "pigrabberbase.h"
+#include "pithreadpoolexecutor.h"
+#include "piconditionvar.h"
 
 #endif // PITHREADMODULE_H

lib/main/thread/pithreadpoolexecutor.cpp

@@ -0,0 +1,89 @@
+/*
+	PIP - Platform Independent Primitives
+
+	Stephan Fomenko
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "pithreadpoolexecutor.h"
+#include "pisysteminfo.h"
+
+/*! \class PIThreadPoolExecutor
+ * @brief Thread pools address two different problems: they usually provide improved performance when executing large
+ * numbers of asynchronous tasks, due to reduced per-task invocation overhead, and they provide a means of bounding and
+ * managing the resources, including threads, consumed when executing a collection of tasks.
+ */
+
+
+PIThreadPoolExecutor::PIThreadPoolExecutor(size_t corePoolSize, PIBlockingDequeue<std::function<void()> > * taskQueue_) : isShutdown_(false) {
+	queue_own = false;
+	if (corePoolSize <= 0)
+		corePoolSize = PISystemInfo::instance()->processorsCount;
+	if (!taskQueue_) {
+		taskQueue = new PIBlockingDequeue<std::function<void()> >();
+		queue_own = true;
+	}
+	for (size_t i = 0; i < corePoolSize; ++i) {
+		PIThread * thread = new PIThread([&, i](){
+			auto runnable = taskQueue->poll(100, std::function<void()>());
+			if (runnable) {
+				runnable();
+			}
+			if (isShutdown_ && taskQueue->size() == 0) threadPool[i]->stop();
+		});
+		threadPool.push_back(thread);
+		thread->start();
+	}
+}
+
+
+bool PIThreadPoolExecutor::awaitTermination(int timeoutMs) {
+	PITimeMeasurer measurer;
+	for (size_t i = 0; i < threadPool.size(); ++i) {
+		int dif = timeoutMs - (int)measurer.elapsed_m();
+		if (dif < 0) return false;
+		if (!threadPool[i]->waitForFinish(dif)) return false;
+	}
+	return true;
+}
+
+
+void PIThreadPoolExecutor::shutdownNow() {
+	isShutdown_ = true;
+	for (size_t i = 0; i < threadPool.size(); ++i) threadPool[i]->stop();
+}
+
+
+PIThreadPoolExecutor::~PIThreadPoolExecutor() {
+	shutdownNow();
+	while (threadPool.size() > 0) delete threadPool.take_back();
+	if (queue_own)
+		delete taskQueue;
+}
+
+
+void PIThreadPoolExecutor::execute(const std::function<void()> & runnable) {
+	if (!isShutdown_) taskQueue->offer(runnable);
+}
+
+
+bool PIThreadPoolExecutor::isShutdown() const {
+	return isShutdown_;
+}
+
+
+void PIThreadPoolExecutor::shutdown() {
+	isShutdown_ = true;
+}

lib/main/thread/pithreadpoolexecutor.h

@@ -0,0 +1,63 @@
+/*
+	PIP - Platform Independent Primitives
+	
+	Stephan Fomenko
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PITHREADPOOLEXECUTOR_H
+#define PITHREADPOOLEXECUTOR_H
+
+#include "piblockingdequeue.h"
+#include <atomic>
+
+
+class PIThreadPoolExecutor {
+public:
+	explicit PIThreadPoolExecutor(size_t corePoolSize = -1, PIBlockingDequeue<std::function<void()> > * taskQueue_ = 0);
+
+	virtual ~PIThreadPoolExecutor();
+
+	/**
+	 * @brief Executes the given task sometime in the future. The task execute in an existing pooled thread. If the task
+	 * cannot be submitted for execution, either because this executor has been shutdown or because its capacity has been
+	 * reached.
+	 *
+	 * @param runnable not empty function for thread pool execution
+	 */
+	void execute(const std::function<void()> & runnable);
+
+	void shutdownNow();
+
+	/**
+	 * @brief Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be
+	 * accepted. Invocation has no additional effect if already shut down. This method does not wait for previously
+	 * submitted tasks to complete execution. Use awaitTermination to do that.
+	 */
+	void shutdown();
+
+	bool isShutdown() const;
+
+	bool awaitTermination(int timeoutMs);
+
+private:
+	std::atomic_bool isShutdown_;
+	PIBlockingDequeue<std::function<void()> > * taskQueue;
+	PIVector<PIThread*> threadPool;
+	bool queue_own;
+
+};
+
+#endif // PITHREADPOOLEXECUTOR_H