Collaboration of the two functions through multithreading
Your consumer thread locks out the producer for extended periods of time.

void ConsumeData()
 {
   while (true)
   {
    std::unique_lock&lt;std::mutex&gt; uniqueLock(mutex);
    conditionVariable.wait(uniqueLock, [] {return !queue.empty(); });
    while (!queue.empty())
    {
        // DO WORK
        queue.pop();
    }
    uniqueLock.unlock();
   }
}


I would rather see the consumer grab a single item from the queue then release the queue (so the producer can continue to add work while the consumer is processing a single job.

void ConsumeData()
{
    while (true)
    {
      {
        std::unique_lock&lt;std::mutex&gt; uniqueLock(mutex);
        conditionVariable.wait(uniqueLock, [] {return !queue.empty(); });

        // Note: Don't need to test queue.empty()
        //       If it is empty then the thread is re-queued on the
        //       condition variable it is only released when the test
        //       above is true.
        work = queue.front();
        queue.pop();
      }
      // You have the work item so you don't need the lock.
      // So out here you work on the item you just retrieved from
      // queue. When done you loop back around to get more work.

      // DO WORK
    }
  }
}


Your producer adds lots of items to the queue. But only signals once. You should signal once for every item added to the queue.

  for (std::uint8_t count = 0; (count &lt; maxWordCount) || (count != '\0'); ++count) {
    queue.push(word);
    conditionVariable.notify_one();
  }


As a side note:

An indent of 2 is a bit on the low side (acceptable by some). But in my opinion makes the code too cluttered.