Многопоточный поиск в массиве и вывод результата в консоль и файл

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <utility>
#include <algorithm>
#include <iterator>
#include <atomic>
#include <fstream>
#include <string>
 
typedef std::vector<int>::iterator iterator;
 
std::vector<std::pair<iterator, iterator>> splitByRanges(std::vector<int> &v, size_t blockSize)
{
    std::vector<std::pair<iterator, iterator>> ranges;
 
    iterator begin = v.begin();
    iterator end = v.begin();
 
    size_t count = v.size() / blockSize;
    for (size_t i = 0; i < count; ++i) {
        iterator biesBlock = end;
        begin = biesBlock;
        std::advance(biesBlock, blockSize);
        end = biesBlock;
 
        ranges.push_back(std::make_pair(begin, end));
    }
 
    if (end != v.end())
    {
        begin = end;
        end = v.end();
        ranges.push_back(std::make_pair(begin, end));
    }
 
    return ranges;
}
 
std::mutex mutex_print_console;
std::mutex mutex_print_counter;
 
class Task {
public:
    Task(iterator begin, iterator end,
        int needleValue,
        std::ofstream &ofile,
        std::atomic<unsigned long long> &countValues) :
        begin_(begin),
        end_(end),
        needleValue_(needleValue),
        ofile_(ofile),
        aCountValues(countValues)
    {}
 
    std::vector<int> find(int needleValue)
    {
        auto isNeedleValue = [&](int value)->bool {
            mutex_print_counter.lock();
            std::cout << "find countValues = " << aCountValues << std::endl;
            mutex_print_counter.unlock();
            --aCountValues;
            return value == needleValue;
        };
 
        std::vector<int> foundValues;
        auto currentPos = begin_;
        auto nextPos = begin_;
        while ((currentPos = std::find_if(nextPos, end_, isNeedleValue)) != end_) {
            nextPos = currentPos + 1;
            foundValues.push_back(*currentPos);
        }
        return foundValues;
    }
 
    void printConsole(const std::vector<int>& c, std::ostream &out) const
    {
        print(c, out);
    }
 
    void printFile(const std::vector<int>& c, std::ostream &out) const
    {
        print(c, out);
    }
 
    void print(const std::vector<int>& c, std::ostream &out) const
    {
        mutex_print_console.lock();
        if (!c.empty()) {
            out << "found: ";
            std::copy(c.begin(), c.end(),
                std::ostream_iterator<int>(out, " "));
            out << "\n" << std::endl;
        }
        else
        {
            /*std::cout << "\ndidn't found\n";
            std::copy(begin_, end_,
                std::ostream_iterator<int>(out, " "));
            out << std::endl;*/
        }
 
        mutex_print_console.unlock();
    }
 
    void operator() () {
        auto foundValue = find(needleValue_);
        printConsole(foundValue, std::cout);
        printFile(foundValue, ofile_);
    }
 
private:
    iterator begin_;
    iterator end_;
    int needleValue_;
    std::ofstream &ofile_;
    std::atomic<unsigned long long> &aCountValues;
};
 
 
int main()
{
    std::atomic<unsigned long long> countValues(0);
 
    constexpr size_t N = 20;
    std::vector<int> v;
    v.reserve(N);
    for (size_t i = 0; i < N; ++i)
    {
        v.push_back(i);
        ++countValues;
 
        mutex_print_counter.lock();
        std::cout << "init countValues = " << countValues << std::endl;
        mutex_print_counter.unlock();
    }
 
    // 1. выяснить макс кол-во допустимых потоков
    size_t minPerThread = 8;
    size_t maxThreads = (v.size() + minPerThread - 1) / minPerThread;
    const size_t hardwareThreads = std::thread::hardware_concurrency();
    size_t numThreads = std::min(hardwareThreads != 0 ? hardwareThreads : 2, maxThreads);
    std::cout << numThreads << " concurrent threads are supported.\n";
 
    // 2. Разбить контейнер на части
    size_t blockSize = v.size() / numThreads;
    //std::cout << blockSize << " blockSize.\n";
    auto ranges = splitByRanges(v, blockSize);
    //for (auto range : ranges)
    //{
    //  std::copy(range.first, range.second,
    //      std::ostream_iterator<int>(std::cout, " "));
    //  std::cout << std::endl;
    //}
 
 
    // 3. Создать потоки скормив ему таску
    // task: 
    // 1. ищет 
    // 2. выводит на консоль найденное
 
    //std::cout << "\n\nEnter needle value for find: ";
    int needleValue = 9;
    //std::cin >> needleValue;
 
    std::string filename = "file.txt";
    std::ofstream ofile(filename, std::ofstream::out);
    if (!ofile)
    {
        std::cerr << "Can't write file " << filename << std::endl;
        return EXIT_FAILURE;
    }
 
    std::cout << "main countValues = " << countValues << std::endl;
 
    std::vector<std::thread> workers;
    for (auto &range : ranges)
    {
        Task task(
            range.first, range.second,
            needleValue,
            ofile,
            std::ref(countValues));
 
        workers.push_back(std::thread(task));
    }
 
    for (auto &worker : workers)
    {
        worker.join();
    }
 
    ofile.close();
 
    std::cout << "main countValues = " << countValues << std::endl;
 
 
    //system("pause");
 
    return EXIT_SUCCESS;
}