Открытие нескольких потоков с объектом и возврат результата

Многопоточность вашего кода

Начнем с написания многопоточной countWords функции. Это даст нам общее представление о том, что должен делать код, а затем мы заполним недостающие части.

Пишу countWords

countWords подсчитывает частоты слов в каждом файле в векторе имен файлов. Делает это параллельно.

Обзор шагов:

• Создайте вектор потоков
• Укажите место для хранения конечного результата (это переменная finalWordCount)
• Сделайте функцию обратного вызова для вызова WordCounter, когда это будет сделано
• Начните новый поток для каждого файла с объектом WordCounter.
• Дождитесь окончания рекламы
• вернуться finalWordCount

Объект WordCounter принимает имя файла в качестве входных данных при запуске потока.

Отсутствующие детали:

• Нам все еще нужно написать функцию makeWordCounter

Реализация:

using std::unordered_map;
using std::string; 
using std::vector; 

unordered_map<string, int> countWords(vector<string> const& filenames) {
    // Create vector of threads
    vector<std::thread> threads;
    threads.reserve(filenames.size());

    // We have to have a lock because maps aren't thread safe
    std::mutex map_lock;

    // The final result goes here
    unordered_map<std::string, int> totalWordCount; 

    // Define the callback function
    // This operation is basically free
    // Internally, it just copies a reference to the mutex and a reference
    // to the totalWordCount
    auto callback = [&](unordered_map<string, int> const& partial_count) {
        // Lock the mutex so only we have access to the map
        map_lock.lock(); 
        // Update the map
        for(auto count : partial_count) {
            totalWordCount[count.first] += count.second; 
        }
        // Unlock the mutex
        map_lock.unlock(); 
    };

    // Create a new thread for each file
    for(auto& file : filenames) {
        auto word_counter = makeWordCounter(callback); 
        threads.push_back(std::thread(word_counter, file)); 
    }

    // Wait until all threads have finished
    for(auto& thread : threads) {
        thread.join(); 
    }

    return totalWordCount; 
}

Пишу makeWordCounter

Наша функция makeWordCounter очень проста: она просто создает функцию WordCounter по шаблону обратного вызова.

template<class Callback>
WordCounter<Callback> makeWordCounter(Callback const& func) {
    return WordCounter<Callback>{func}; 
}

Написание класса WordCounter

Переменные-члены:

• Функция обратного вызова (нам больше ничего не нужно)

Функции

• operator() вызывает countWordsFromFilename с именем файла
• countWordsFromFilename открывает файл, убеждается, что все в порядке, и вызывает countWords с файловым потоком
• countWords читает все слова в файловом потоке и подсчитывает количество, а затем вызывает обратный вызов с окончательным подсчетом.

Поскольку WordCounter очень прост, я просто сделал его структурой. Ему нужно только сохранить функцию Callback, и, сделав функцию callback общедоступной, нам не нужно писать конструктор (компилятор обрабатывает его автоматически, используя агрегатную инициализацию).

template<class Callback>
struct WordCounter {
    Callback callback;

    void operator()(std::string filename) {
        countWordsFromFilename(filename); 
    }
    void countWordsFromFilename(std::string const& filename) {
        std::ifstream myFile(filename);
        if (myFile) {
            countWords(myFile); 
        }
        else {
            std::cerr << "Unable to open " + filename << '\n'; 
        }
    }
    void countWords(std::ifstream& filestream) {
        std::unordered_map<std::string, int> wordCount; 
        std::string word; 
        while (!filestream.eof() && !filestream.fail()) {
            filestream >> word; 
            wordCount[word] += 1;
        }
        callback(wordCount); 
    }
};

Полный код

Вы можете увидеть полный код для countWords здесь: https://pastebin.com/WjFTkNYF

Единственное, что я добавил, это #includes.

Обратные вызовы и шаблоны 101 (по запросу Original Poster)

Шаблоны — это простой и полезный инструмент для написания кода. Их можно использовать для устранения взаимных зависимостей; сделать алгоритмы универсальными (чтобы их можно было использовать с любыми типами, которые вам нравятся); и они даже могут сделать код быстрее и эффективнее, позволяя избежать вызовов виртуальных функций-членов или указателей на функции.

Шаблон класса

Давайте посмотрим на действительно простой шаблон класса, представляющий пару:

template<class First, class Second>
struct pair {
    First first;
    Second second; 
};

Здесь мы объявили pair как struct, потому что мы хотим, чтобы все члены были общедоступными.

Обратите внимание, что нет ни типа First, ни типа Second. Когда мы используем имена First и Second, на самом деле мы говорим, что «в контексте класса pair имя First будет представлять First аргумент парного класса, а имя Second будет представлять второй элемент класса парный класс.

Мы могли бы просто написать это так:

// This is completely valid too
template<class A, class B>
struct pair {
    A first;
    B second; 
};

Использовать pair довольно просто:

int main() {
    // Create pair with an int and a string
    pair<int, std::string> myPair{14, "Hello, world!"}; 

    // Print out the first value, which is 14
    std::cout << "int value:    " << myPair.first << '\n';
    // Print out the second value, which is "Hello, world!"
    std::cout << "string value: " << myPair.second << '\n';
}

Как и обычный класс, pair может иметь функции-члены, конструктор, деструктор... что угодно. Поскольку pair такой простой класс, компилятор автоматически генерирует для нас конструктор и деструктор, и нам не нужно о них беспокоиться.

Шаблонные функции

Шаблонные функции похожи на обычные функции. Единственная разница в том, что они имеют объявление template перед остальным объявлением функции.

Давайте напишем простую функцию для печати пары:

template<class A, class B>
std::ostream& operator<<(std::ostream& stream, pair<A, B> pair) 
{
    stream << '(' << pair.first << ", " << pair.second << ')'; 
    return stream; 
}

Мы можем дать ему любое pair, какое захотим, если оно знает, как напечатать оба элемента пары:

int main() {
    // Create pair with an int and a string
    pair<int, std::string> myPair{14, "Hello, world!"}; 

    std::cout << myPair << '\n'; 
}

Это выводит (14, Hello, world).

Обратные вызовы

В C++ нет типа Callback. Нам он не нужен. Обратный вызов — это просто то, что вы используете, чтобы указать, что что-то произошло.

Давайте рассмотрим простой пример. Эта функция ищет прогрессивно увеличивающиеся числа, и каждый раз, когда она их находит, она вызывает output, который является параметром, который мы предоставили. В данном случае output — это обратный вызов, и мы используем его, чтобы указать, что найдено новое наибольшее число.

template<class Func>
void getIncreasingNumbers(std::vector<double> const& nums, Func output) 
{
    // Exit if there are no numbers
    if (nums.size() == 0) 
        return; 

    double biggest = nums[0]; 
    // We always output the first one
    output(biggest); 
    for(double num : nums) 
    {
        if (num > biggest) 
        {
            biggest = num; 
            output(num); 
        }
    }
}

Мы можем использовать getIncreasingNumbers по-разному. Например, мы можем отфильтровать числа, которые не были больше предыдущего:

std::vector<double> filterNonIncreasing(std::vector<double> const& nums) 
{
    std::vector<double> newNums; 
    // Here, we use an & inside the square brackets
    // This is so we can use newNums by reference
    auto my_callback = [&](double val) { 
        newNums.push_back(val); 
    };
    getIncreasingNumbers(nums, my_callback); 
    return newNums; 
}

Или мы можем распечатать их:

void printNonIncreasing(std::vector<double> const& nums) 
{
    // Here, we don't put anything in the square brackts
    // Since we don't access any local variables
    auto my_callback = [](double val) {
        std::cout << "New biggest number: " << val << '\n'; 
    };
    getIncreasingNums(nums, my_callback); 
}

Или мы можем найти самый большой разрыв между ними:

double findBiggestJumpBetweenIncreasing(std::vector<double> const& nums)
{
    double previous; 
    double biggest_gap = 0.0; 
    bool assigned_previous = false;
    auto my_callback = [&](double val) {
        if (not assigned_previous) {
            previous = val; 
            assigned_previous = true;
        }
        else 
        {
            double new_gap = val - previous; 
            if (biggest_gap < new_gap) {
                biggest_gap = new_gap; 
            }
        }
    };
    getIncreasingNums(nums, my_callback); 
    return biggest_gap;
}