Зависание потоков. Работа с файлами

    boost:: thread_group, делаю join_all();
    boost:: ptr_vector<boost::mutex> _readMutexArray;
    boost:: ptr_vector<boost::mutex> _writeMutexArray;
    boost:: ptr_vector<boost::condition_variable> _readConditionVarArray;
    boost:: ptr_vector<boost::condition_variable> _writeConditionVarArray;

void Decrypter::DecryptMultithreading(const std::string& sourceFilePath, const std::string& destinationFilePath, size_t threadId )
{
    while (_byteWrote != _fileSize)
    {
        WaitForEvent(threadId, _readMutexArray, _readConditionVarArray);
        _firstPart = false;
 
//       open file stream for sourceFilePath and read required bytes.
        
        _readConditionVarArray[threadId].notify_all();
 
//        smth decrypt logics here
 
        WaitForEvent(threadId, _writeMutexArray, _writeConditionVarArray);
 
//        open file stream for destinationFilePath and write required bytes.
//   _byteWrote += currentBlockSize;
 
        _writeConditionVarArray[threadId].notify_all();
    }
}
 
void Decrypter::WaitForEvent(int threadId, boost::ptr_vector<boost::mutex>& eventsArrayGuard, boost::ptr_vector<boost::condition_variable>& cond)
{
    size_t waitedThread = -1;
 
    if (0 == threadId && (_firstPart || 0 == _byteWrote))
    {
        return;
    }
    else
    {
        waitedThread = 0 == threadId ? _threadsCount: threadId;
    }
    --waitedThread;
 
    boost::unique_lock<boost::mutex> lock(eventsArrayGuard[waitedThread]);
    cond[waitedThread].wait(lock);
}
 
void Decrypter::CreateReadWriteEvents()
{
    for (size_t i = 0; i < _threadsCount; ++i)
    {
        _readMutexArray.push_back(new boost::mutex());
        _writeMutexArray.push_back(new boost::mutex());
 
        _readConditionVarArray.push_back(new boost::condition_variable());
        _writeConditionVarArray.push_back(new boost::condition_variable());
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <future>
#include <thread>
#include <chrono>
 
int main()
{
   using fut_t = std::future<int>;
   std::vector<fut_t> futures;
 
   auto is_future_valid = [](fut_t& fut)
   {
      return fut.valid();
   };
   auto is_future_ready = [&is_future_valid](fut_t& fut)
   {
      return is_future_valid(fut) && fut.wait_for(
               std::chrono::microseconds(100)) == std::future_status::ready;
   };
 
   futures.emplace_back(std::async(std::launch::async, []{
      std::this_thread::sleep_for(std::chrono::seconds(5));
      return 1;
   }));
 
   futures.emplace_back(std::async(std::launch::async, []{
      std::this_thread::sleep_for(std::chrono::seconds(15));
      return 2;
   }));
 
   futures.emplace_back(std::async(std::launch::async, []{
      std::this_thread::sleep_for(std::chrono::seconds(10));
      return 3;
   }));
 
   futures.emplace_back(std::async(std::launch::async, []{
      std::this_thread::sleep_for(std::chrono::seconds(3));
      return 42;
   }));
 
   while (std::any_of(futures.begin(), futures.end(), is_future_valid)) {
      auto next = std::find_if(futures.begin(), futures.end(), is_future_ready);
      if (next == futures.end())
      {
         continue;
      }
 
      std::cout << next->get() << std::endl;
   }
 
   return 0;
}