Public Member Functions
	ThreadPool (size_t n, size_t max_queue=4096)
	~ThreadPool ()
void	enqueue (std::function< void()> fn)

Private Member Functions
void	worker_thread ()

Private Attributes
std::vector< std::thread >	workers
std::queue< std::function< void()> >	tasks
std::mutex	mtx
std::condition_variable	cv
std::condition_variable	cv_space
bool	stop
size_t	max_queue

Detailed Description

Definition at line 65 of file BastionGuard-ransomware-scanner.cpp.

Constructor & Destructor Documentation

◆ ThreadPool()

ThreadPool::ThreadPool	(	size_t	n,
		size_t	max_queue = 4096 )

inlineexplicit

Definition at line 67 of file BastionGuard-ransomware-scanner.cpp.

        : stop(false), max_queue(max_queue)
    {
        for (size_t i = 0; i < n; ++i)
            workers.emplace_back([this]{ worker_thread(); });
    }

References max_queue, stop, worker_thread(), and workers.

◆ ~ThreadPool()

ThreadPool::~ThreadPool ( )

inline

Definition at line 74 of file BastionGuard-ransomware-scanner.cpp.

                  {
        {
            std::unique_lock<std::mutex> lk(mtx);
            stop = true;
        }
        cv.notify_all();
        cv_space.notify_all();
        for (auto &t : workers)
            if (t.joinable()) t.join();
    }

References cv, cv_space, mtx, stop, and workers.

Member Function Documentation

◆ enqueue()

void ThreadPool::enqueue ( std::function< void()> fn )

inline

Definition at line 85 of file BastionGuard-ransomware-scanner.cpp.

                                         {
        std::unique_lock<std::mutex> lk(mtx);
        cv_space.wait(lk, [this]{ return stop || tasks.size() < max_queue; });
        if (stop) return;
        tasks.push(std::move(fn));
        cv.notify_one();
    }

References cv, cv_space, max_queue, mtx, stop, and tasks.

Referenced by main().

◆ worker_thread()

void ThreadPool::worker_thread ( )

inlineprivate

Definition at line 94 of file BastionGuard-ransomware-scanner.cpp.

                         {
        for (;;) {
            std::function<void()> fn;
            {
                std::unique_lock<std::mutex> lk(mtx);
                cv.wait(lk, [this]{ return stop || !tasks.empty(); });
                if (stop && tasks.empty())
                    return;
                fn = std::move(tasks.front());
                tasks.pop();
                cv_space.notify_one();
            }
            fn();
        }
    }