Многопоточность. Вывести сколько раз значения второго массива попадаются в первом массиве

#include "stdafx.h"
#include <iostream>
#include <algorithm>
#include <vector>
#include <thread> 
 
size_t CountValue(const int* array, const size_t size, const int value)
{
    const int* begin = array;
    const int* end = array + size;
 
    const int* low = std::lower_bound(begin, end, value);
    if ((low != end) && (*low == value))
    {
        auto up = std::upper_bound(low, end, value);
        return std::distance(low, up);
    }
    return 0;
}
 
int main()
{
    int arrayFirst[] = { 11, 5, 2, 8, 4, 5, 2, 5, 7, 9, 12, 16, 17, 18, 20 };
    int arraySecond[] = { 22, 5, 8, 3, 2, 9, 4, 3, 9, 10 };
    int size = sizeof(arraySecond) / sizeof(arraySecond[0]);
    std::sort(arraySecond, arraySecond + size);
    
    //const std::size_t maxThreadCount = std::thread::hardware_concurrency();
    //std::vector<std::thread> threads(maxThreadCount);
 
    std::vector<std::thread> threads1(size / 2);
    std::vector<std::thread> threads2(size / 2);
    for (int index = 0; index < size / 2; ++index) 
    {
        if (arraySecond[index] != arraySecond[index + 1])
            std::cout << "Value:" << arraySecond[index] << "-" << CountValue(arrayFirst, size, arraySecond[index]) << "\n";
        threads1[index].join();
    }
    for (int index = size / 2; index < size; ++index)
    {
        if (arraySecond[index] != arraySecond[index + 1])
            std::cout << "Value:" << arraySecond[index] << "-" << CountValue(arrayFirst, size, arraySecond[index]) << "\n";
        threads2[index].join();
    }
        
    return 0;
}

template <typename T>
void Foo(const std::unordered_map<T, size_t> &um, const T &val)
{
    const auto it = um.find(val);
    std::ostringstream buf;
    buf << std::this_thread::get_id() << '\t' << val << ": " << (it != um.cend() ? it->second : 0) << std::endl;
    std::cout << buf.str();
}

#include <cassert>
#include <iostream>
 
#include <vector>
#include <array>
#include <algorithm>
 
#include <atomic>
#include <mutex>
#include <thread>
#include <condition_variable>
 
size_t thread_num=4;
 
std::mutex m;
std::condition_variable cv;
 
std::atomic<size_t> sum = ATOMIC_VAR_INIT(0);
std::atomic<size_t> index = ATOMIC_VAR_INIT(0);
 
void worker(std::vector<int>& p,std::vector<int>& q){
    std::thread::id this_id = std::this_thread::get_id();
    std::cout<<this_id<<":new worker"<<std::endl;
    for(size_t ix=0;;){
        ix=index.fetch_add(1);
        std::cout<<this_id<<":index="<<ix<<std::endl;
        if (ix<q.size()){
            int test=q[ix];
            for_each(p.begin(),p.end(),[&test](int n){
                if (test==n) sum++;
            });
        }
        else
            break;
    }
    std::cout<<this_id<<":notify at exit"<<std::endl;
    std::unique_lock<std::mutex> lk(m);
    std::notify_all_at_thread_exit(cv, std::move(lk));
}
 
int main()
{
    std::vector<int> p = { 11, 5, 2, 8, 4, 5, 2, 5, 7, 9, 12, 16, 17, 18, 20 };
    std::vector<int> q = { 22, 5, 8, 3, 2, 9, 4, 3, 9, 10 };
    for(size_t i=0;i<thread_num;i++){
        std::thread x(worker,std::ref(p),std::ref(q));
        x.detach();
    }
    std::unique_lock<std::mutex> lk(m);
    while(index<q.size()+thread_num){
        std::cout<<"waiting after index="<<index<<std::endl;
        cv.wait(lk);
    }
    std::cout<<sum<<std::endl;
}

const int sizeFirst = 20;
    const int sizeSecond = 15;
    int arrayFirst[sizeFirst] = {11, 5, 2, 8, 4, 5, 2, 5, 7, 9, 12, 16, 17, 18, 20};
    int arraySecond[sizeSecond] = {22, 5, 8, 3, 2, 9, 4, 3, 9, 10};
 
    //count threads=count processors
    std::unordered_map<int, int> result;
    std::vector <std::thread> init;
    int step = std::ceil((float) sizeSecond / std::thread::hardware_concurrency());
    for (int start = 0; start < sizeSecond;) {
        int end = (start + step < sizeSecond) ? start + step : sizeSecond;
        init.emplace_back([start, end, sizeFirst, &arrayFirst, &arraySecond, &result]() {
            for (int c = start; c < end; c++)
                result[arraySecond[c]] = count(arrayFirst, arrayFirst + sizeFirst, arraySecond[c]);
        });
        start = end;
    }
 
    for (auto & th : init) th.join();
    for (std::pair<int, int> value : result)
        cout << value.first << "->" << value.second << endl;

#include <iostream>
#include <sstream>
#include <thread>
#include <unordered_map>
 
template <typename T>
void Foo(const std::unordered_map<T, size_t> &um, const T &val)
{
    const auto it = um.find(val);
    std::ostringstream buf;
    buf << val << ": " << (it != um.cend() ? it->second : 0) << std::endl;
    std::cout << buf.str();
}
 
int main()
{
    constexpr int arrayFirst[] = { 11, 5, 2, 8, 4, 5, 2, 5, 7, 9, 12, 16, 17, 18, 20 };
    constexpr int arraySecond[] = { 22, 5, 8, 3, 2, 9, 4, 3, 9, 10 };
    // строим ассоциативный массив для соответствия элемент => сколько раз он встречается в массиве
    std::unordered_map<int, size_t> um;
    for (const auto &x : arrayFirst)
        ++um[x];
    for (const auto &x : arraySecond)
        std::thread(&Foo<int>, um, x).join();
}

#include "stdafx.h"
#include <iostream>
#include <algorithm>
#include <vector>
#include <thread> 
#include <unordered_map>
 
size_t CountValue(const int* array, const size_t size, const int value)
{
    const int* begin = array;
    const int* end = array + size;
 
    const int* low = std::lower_bound(begin, end, value);
    if ((low != end) && (*low == value))
    {
        auto up = std::upper_bound(low, end, value);
        return std::distance(low, up);
    }
    return 0;
}
 
std::vector<std::pair<size_t, size_t>> GenerateProcessingIntervals(std::size_t maxThreadCount, std::size_t numberCount)
{
    const std::size_t minLength = numberCount / maxThreadCount;
    const std::size_t numLeftNumbers = numberCount % maxThreadCount;
 
    std::vector<std::size_t> intervalLength;
    intervalLength.reserve(maxThreadCount);
 
    for (std::size_t i = 0; i < numLeftNumbers; ++i)
        intervalLength.emplace_back(minLength + 1);
 
    if (minLength > 0)
    {
        for (std::size_t i = numLeftNumbers; i < maxThreadCount; ++i)
            intervalLength.emplace_back(minLength);
    }
 
    std::vector<std::pair<size_t, size_t>> intervals;
    intervals.reserve(intervalLength.size());
 
    intervals.emplace_back(0, intervalLength[0]);
    for (std::size_t index = 1; index < intervalLength.size(); ++index)
        intervals.emplace_back(intervals[index - 1].first + intervals[index - 1].second, intervalLength[index]);
 
    return intervals;
}
 
 
 
int main() 
{
    int array1[] = { 11, 5, 2, 8, 4, 5, 2, 5, 7, 9, 12, 16, 17, 18, 20 };
    int array2[] = { 22, 5, 8, 3, 2, 9, 4, 3, 9, 9 };
    int size1 = sizeof(array1) / sizeof(array1[0]);
    int size2 = sizeof(array2) / sizeof(array2[0]);
    std::sort(array1, array1 + size1);
 
    std::vector<std::pair<size_t, size_t>> intervals = GenerateProcessingIntervals(*array2, size2);
    const auto usedThreadCount = intervals.size();
    std::vector<std::thread> threads;
    threads.reserve(usedThreadCount);
    std::vector<std::vector<std::uint64_t>> foundPrimesPerThread(usedThreadCount);
 
 
    for (const std::pair<size_t, size_t>& interval : intervals) 
        threads.emplace_back(intervals);
    
    for (std::size_t index = 0; index < size2; ++index)
    {
        std::cout << "Value:" << array2[index] << "-" << CountValue(array1, size2, array2[index]) << "\n";
        std::cout << "-------\n";
    }
 
    for (std::size_t index = 0; index < usedThreadCount; ++index)
        threads[index].join();
      return 0;
}

threads.emplace_back(intervals);

#include <iostream>
#include <sstream>
#include <thread>
#include <unordered_map>
#include <vector>
 
template <typename T>
void Foo(const std::unordered_map<T, size_t> &um, const T &val)
{
    const auto it = um.find(val);
    std::ostringstream buf;
    buf << val << ": " << (it != um.cend() ? it->second : 0) << std::endl;
    std::cout << buf.str();
}
 
int main()
{
    constexpr int arrayFirst[] = { 11, 5, 2, 8, 4, 5, 2, 5, 7, 9, 12, 16, 17, 18, 20 };
    constexpr int arraySecond[] = { 22, 5, 8, 3, 2, 9, 4, 3, 9, 10 };
    // строим ассоциативный массив для соответствия элемент => сколько раз он встречается в массиве
    std::unordered_map<int, size_t> um;
    for (const auto &x : arrayFirst)
        ++um[x];
 
    // создаём вектор с набором задач (потоков)
    std::vector<std::thread> tasks;
    for (const auto &x : arraySecond)
        tasks.emplace_back(&Foo<int>, um, x);
 
    // присоединяем потоки к текущему
    for (auto &th : tasks)
        th.join();
}

std::vector<std::pair<size_t, size_t>> intervals = GenerateProcessingIntervals(*array2, size2);

 threads.emplace_back(// что сюда передвать? я  думала intervals , но я ошибалась );