Dividing a ThreadPool class into component classes to reduce/isolate complexity
There are way too many member variables:

unsigned int numberOfThreads;
std::vector&lt;std::thread&gt; workers;
unsigned int availableThreads;


Can you not find the number of threads with workers.size(). What's the difference between number of Threads and Available Threads and more importantly why do you need to know!

You have three mutex's and two condition variables! Why? Also why are you putting the unique_lock as a member of the class! That would make them hard to use in a shared context.

Normally I would expect to see:

//In class:
    std::mutex               lock;
    std::condition_variable  sync;

//Adding Stuff Function:
    std::lock_guard   guard(lock);
    queue.push(item);
    sync.notify();

//Taking stuff from Queue
    std::lock_guard   guard(lock);
    sync.wait(guard, [queue](){!queue.empty();});
    if (!queue.empty()) {
        result = queue.pop();
    }


The only method that should be public on that class is adding a new job. All other methods are private members.

This is what mine would look like this:

class WorkQueue
{
    private:
        std::vector&lt;std::thread&gt;            threads;
        std::deque&lt;std::function&lt;void()&gt;&gt;   queue;
        std::mutex                          lock;
        std::condition_variable             sync;
        bool                                finished;

        std::function&lt;void()&gt; getWork();
        void work();
    public:
        WorkQueue(int threadCount);
        ~WorkQueue();
        template&lt;typename F&gt;
        void addWork(F&amp;&amp; func);
};