knowrob::ThreadPool Class Reference

#include <ThreadPool.h>

Inheritance diagram for knowrob::ThreadPool:

Classes
class	LambdaRunner
class	Runner
class	Worker

Public Types
using	ExceptionHandler = std::function< void(const std::exception &)>
using	ExceptionHandler = std::function< void(const std::exception &)>

Public Member Functions
	ThreadPool (uint32_t maxNumThreads)
virtual	~ThreadPool ()
	ThreadPool (const ThreadPool &)=delete
void	shutdown ()
void	pushWork (const std::shared_ptr< ThreadPool::Runner > &goal, ThreadPool::ExceptionHandler exceptionHandler)
	ThreadPool (uint32_t maxNumThreads)
virtual	~ThreadPool ()
	ThreadPool (const ThreadPool &)=delete
void	shutdown ()
void	pushWork (const std::shared_ptr< ThreadPool::Runner > &goal, ThreadPool::ExceptionHandler exceptionHandler)

Protected Attributes
std::function< void()>	finalizeWorker_

Detailed Description

A pool of worker threads waiting on tasks to be pushed into a work queue.

Definition at line 27 of file ThreadPool.h.

Member Typedef Documentation

ExceptionHandler [1/2]

using knowrob::ThreadPool::ExceptionHandler = std::function<void(const std::exception &)>

Definition at line 32 of file ThreadPool.h.

ExceptionHandler [2/2]

using knowrob::ThreadPool::ExceptionHandler = std::function<void(const std::exception &)>

Definition at line 32 of file ThreadPool.h.

Constructor & Destructor Documentation

ThreadPool() [1/4]

ThreadPool::ThreadPool ( uint32_t  maxNumThreads )

explicit

Parameters

maxNumThreads

the maximum number of worker threads

Definition at line 26 of file ThreadPool.cpp.

        : maxNumThreads_(maxNumThreads),
          numFinishedThreads_(0),
          numActiveWorker_(0) {
    // NOTE: do not add worker threads in the constructor.
    //  The problem is the virtual initializeWorker function that could be called
    //  in this case before a subclass of ThreadPool overrides it.
    //  i.e. if the thread starts before construction is complete.
    KB_DEBUG("Maximum number of threads: {}.", maxNumThreads);
}

~ThreadPool() [1/2]

ThreadPool::~ThreadPool ( )

virtual

Definition at line 37 of file ThreadPool.cpp.

                        {
    shutdown();
}

ThreadPool() [2/4]

knowrob::ThreadPool::ThreadPool ( const ThreadPool &  )

delete

Cannot be copy-assigned.

ThreadPool() [3/4]

knowrob::ThreadPool::ThreadPool ( uint32_t  maxNumThreads )

explicit

Parameters

maxNumThreads

the maximum number of worker threads

~ThreadPool() [2/2]

virtual knowrob::ThreadPool::~ThreadPool ( )

virtual

ThreadPool() [4/4]

knowrob::ThreadPool::ThreadPool ( const ThreadPool &  )

delete

Cannot be copy-assigned.

Member Function Documentation

pushWork() [1/2]

void ThreadPool::pushWork	(	const std::shared_ptr< ThreadPool::Runner > &	goal,
		ThreadPool::ExceptionHandler	exceptionHandler
	)

Pushes a goal for a worker. The goal is assigned to a worker thread when one is available.

Parameters

goal	the work goal
exceptionHandler	an exception handler

Definition at line 70 of file ThreadPool.cpp.

                                                                                                        {
    {
        std::lock_guard<std::mutex> scoped_lock(workMutex_);
        goal->setExceptionHandler(std::move(exceptionHandler));
        workQueue_.push(goal);
 
        uint32_t numAliveThreads = workerThreads_.size() - numFinishedThreads_;
        uint32_t numAvailableThreads = numAliveThreads - numActiveWorker_;
        if (numAvailableThreads == 0) {
            // add another thread if max num not reached yet
            if (workerThreads_.size() < (maxNumThreads_ + numFinishedThreads_)) {
                workerThreads_.push_back(new Worker(this));
            }
        }
    }
    // wake up a worker if any is sleeping
    workCV_.notify_one();
}

pushWork() [2/2]

void knowrob::ThreadPool::pushWork	(	const std::shared_ptr< ThreadPool::Runner > &	goal,
		ThreadPool::ExceptionHandler	exceptionHandler
	)

Pushes a goal for a worker. The goal is assigned to a worker thread when one is available.

Parameters

goal	the work goal
exceptionHandler	an exception handler

shutdown() [1/2]

void ThreadPool::shutdown

(

)

Shutdown the thread pool. Joining all the worker threads. If one of them is busy, this call will block until the worker has finished its work, and can gracefully exit.

Definition at line 41 of file ThreadPool.cpp.

                          {
    for (Worker *t: workerThreads_) {
        t->hasTerminateRequest_ = true;
    }
    workCV_.notify_all();
#ifdef KNOWROB_THREADING_DETACH_ON_EXIT
    auto start = std::chrono::steady_clock::now();
#endif
    for (Worker *t: workerThreads_) {
#ifdef KNOWROB_THREADING_DETACH_ON_EXIT
        while (!t->isTerminated_) {
            auto now = std::chrono::steady_clock::now();
            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start).count();
            if (elapsed >= MAX_WORKER_TERMINATE_TIME_MS) {
                KB_WARN("Worker thread does not seem to exit, it will be detached!");
                // Note: the most reliable way I found to forcefully terminate a thread without causing
                //       a SIGABRT exit of KnowRob is detaching the worker threads that do not want to exit.
                t->thread_.detach();
                break;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
#endif
        // note: worker destructor joins the thread
        delete t;
    }
    workerThreads_.clear();
}

shutdown() [2/2]

void knowrob::ThreadPool::shutdown

(

)

Shutdown the thread pool. Joining all the worker threads. If one of them is busy, this call will block until the worker has finished its work, and can gracefully exit.

Member Data Documentation

finalizeWorker_

std::function< void()> knowrob::ThreadPool::finalizeWorker_

protected

Definition at line 168 of file ThreadPool.h.

---

The documentation for this class was generated from the following files:

• build/_CPack_Packages/Linux/DEB/knowrob-2.1.0-Linux/usr/include/knowrob/ThreadPool.h
• src/ThreadPool.cpp