peri4
1c7fc39b6c
in almost all methods removed timeouts in milliseconds, replaced to PISystemTime PITimer rewrite, remove internal impl, now only thread implementation, API similar to PIThread PITimer API no longer pass void* PIPeer, PIConnection improved stability on reinit and exit PISystemTime new methods pisd now exit without hanging
84 lines
2.4 KiB
C++
84 lines
2.4 KiB
C++
/*
|
|
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 "piliterals_time.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(int corePoolSize): isShutdown_(false) {
|
|
for (int i = 0; i < corePoolSize; ++i) {
|
|
PIThread * thread = new PIThread([&, i]() {
|
|
auto runnable = taskQueue.poll(100_ms, std::function<void()>());
|
|
if (runnable) {
|
|
runnable();
|
|
}
|
|
if (isShutdown_ && taskQueue.size() == 0) threadPool[i]->stop();
|
|
});
|
|
threadPool.push_back(thread);
|
|
thread->start();
|
|
}
|
|
}
|
|
|
|
|
|
bool PIThreadPoolExecutor::awaitTermination(PISystemTime timeout) {
|
|
PITimeMeasurer measurer;
|
|
for (size_t i = 0; i < threadPool.size(); ++i) {
|
|
auto dif = timeout - measurer.elapsed();
|
|
if (dif.isNegative()) 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();
|
|
}
|
|
|
|
|
|
void PIThreadPoolExecutor::execute(const std::function<void()> & runnable) {
|
|
if (!isShutdown_) taskQueue.offer(runnable);
|
|
}
|
|
|
|
|
|
bool PIThreadPoolExecutor::isShutdown() const {
|
|
return isShutdown_;
|
|
}
|
|
|
|
|
|
void PIThreadPoolExecutor::shutdown() {
|
|
isShutdown_ = true;
|
|
}
|