scheduler.hpp

Go to the documentation of this file.

/*
 * Copyright 2015, alex at staticlibs.net
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// ---------------------------------------------------------------------
// pion:  a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc.  (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//

#ifndef STATICLIB_PION_SCHEDULER_HPP
#define STATICLIB_PION_SCHEDULER_HPP

#include <cstdint>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>

#include "asio.hpp"

#include "staticlib/config.hpp"

namespace staticlib { 
namespace pion {

class scheduler {
    std::mutex mutex;

    std::condition_variable no_more_active_users;

    std::condition_variable scheduler_has_stopped;

    uint32_t num_threads;

    uint32_t active_users;

    bool running;

    std::vector<std::unique_ptr<std::thread>> thread_pool;

    asio::io_service asio_service;

    asio::steady_timer timer;

    std::function<void() /* noexcept */> thread_stop_hook;

public:

    scheduler(uint32_t number_of_threads) :
    num_threads(number_of_threads),
    active_users(0),
    running(false),
    asio_service(),
    timer(asio_service),
    thread_stop_hook([]() STATICLIB_NOEXCEPT {}) { }

    scheduler(const scheduler&) = delete;

    scheduler& operator=(const scheduler&) = delete;

    ~scheduler() {
        shutdown();
    }

    void startup();

    void shutdown();

    void join();

    void add_active_user();

    void remove_active_user();

    bool is_running() const {
        return running;
    }

    asio::io_service& get_io_service() {
        return asio_service;
    }

    void post(std::function<void()> work_func) {
        get_io_service().post(work_func);
    }

    void keep_running(asio::io_service& my_service, asio::steady_timer& my_timer);

    void process_service_work(asio::io_service& service);

    void set_thread_stop_hook(std::function<void() /* noexcept */> hook) {
        std::lock_guard<std::mutex> scheduler_lock{mutex};
        this->thread_stop_hook = hook;
    }

private:

    void stop_threads();

};

} // namespace
}

#endif // STATICLIB_PION_SCHEDULER_HPP