CUThreadPool.h

//
//  CUThreadPool.h
//  Cornell University Game Library (CUGL)
//
//  Module for a pool of threads capable of executing asynchronous tasks.  Each
//  task is specified by a void function.  There are no guarantees about thread
//  safety; that is responsibility of the author of each task.
//
//  This code is largely inspired from the Cocos2d file AudioEngine.cpp, from
//  the code for asynchronous asset loading. We generalized that class added
//  some notable safety changes.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 11/29/16
//
#ifndef __CU_THREAD_POOL_H__
#define __CU_THREAD_POOL_H__
#include <cugl/base/CUBase.h>
#include <SDL/SDL.h>
#include <condition_variable>
#include <stdio.h>
#include <queue>
#include <vector>
#include <thread>

// std::thread is not safe on Android and Windows platforms
#if defined (__WINDOWS__) || defined (__ANDROID__)
    #define CU_SDL_THREADS 1
#endif

namespace cugl {

#pragma mark -
#pragma mark Thread Pool

class ThreadPool {
private:
#ifdef CU_SDL_THREADS
    std::vector<SDL_Thread*> _workers;
#else
    std::vector<std::thread> _workers;
#endif
    
    std::queue< std::function<void()> > _taskQueue;
    
    std::mutex _queueMutex;
    std::condition_variable _taskCondition;
    
    bool _stop;
    int _complete;
    
    void threadFunc();

    static int sdlThreadFunc(void* ptr);
    

#pragma mark Constructors
public:
    ThreadPool() :_stop(false), _complete(0) { }
    
    ~ThreadPool() { dispose(); }
    
    void dispose();
    
    virtual bool init(int threads = 4);

    
#pragma mark Static Constructors

    static std::shared_ptr<ThreadPool> alloc(int threads = 4) {
        std::shared_ptr<ThreadPool> result = std::make_shared<ThreadPool>();
        return (result->init(threads) ? result : nullptr);
    }
    
    
#pragma mark Task Management

    void addTask(const std::function<void()> &task);
    
    void stop();
    
    bool isStopped() const { return _stop; }
    
    bool isShutdown() const { return _workers.size() == _complete; }
    
    // Copying is only allowed via shared pointer.
    CU_DISALLOW_COPY_AND_ASSIGN(ThreadPool);
};

}

#endif /* __CU_THREAD_POOL_H__ */