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

#include "stdafx.h"
#include <iostream>
#include <thread>
#include <algorithm>
#include <vector>
#include <mutex>
#include <Windows.h>
using namespace std;
const int COUNT = 110;
const int MAX_NTHREAD = 4;
mutex Mutex;
void init_array(int arr[])
{
    srand(GetTickCount());
    for (int i = 0; i < COUNT; i++)
    {
        arr[i] = rand() % 100;
        cout << arr[i] << endl;
    }
 
 
}
 
void search(int arr[], int start, int finish, int& result)
{
    int local_result = 0;
    int max = arr[0];
    for (int i = start; i < finish; i++)
    {
        if (arr[i] % 2 != 0)
        {
            if (arr[i] > max)
            {
                local_result = arr[i];
            }
        }
    }
    lock_guard<std::mutex> lock(Mutex);
    result = local_result;
    cout << this_thread::get_id() << ": " << result <<
        endl;
 
 
}
int search_threads(int arr[])
{
    unsigned int const min_block_size = 25;
    unsigned int const max_threads =
        (COUNT + min_block_size - 1) / min_block_size;
    unsigned int const hardware_threads =
        thread::hardware_concurrency();
    unsigned int const count_threads =
        min(hardware_threads != 0 ?
            hardware_threads : 2, max_threads);
    int block_size = COUNT / count_threads;
    vector <int> h;
    int result = 0;
    vector<thread> threads(count_threads - 1);
    for (unsigned int i = 0; i < count_threads - 1; i++)
    {
        threads[i] = thread(search, arr, block_size*i,
            block_size*(i + 1), ref(result));
        h.push_back(result);
    }
    search(arr, block_size*(count_threads - 1), COUNT, result);
    h.push_back(result);
    for (unsigned int i = 0; i < count_threads - 1; i++)
    {
        threads[i].join();
    }
    for (int i = 0; i < h.size(); i++)
    {
        cout << "res:" << h[i] << endl;
    }
    return result;
}
int main()
{
    int a[COUNT];
    init_array(a);
    cout << "Result = " << search_threads(a) << endl;
    cin.ignore();
    return 0;
}

for (unsigned int i = 0; i < count_threads - 1; i++)
    {
h.push_back(0);
        threads[i] = thread(search, arr, block_size*i,
            block_size*(i + 1), ref(h.back()));
        
    }

vector <int> h;
 
h.reserve(count_threads)
    int result = 0;
    vector<thread> threads(count_threads - 1);

#include <iostream>
#include <vector>
#include <thread>
 
int sum[10];
 
void foo(std::vector<int>& v, int i)
{   int a  = v.size() / 10;
    int b  = a * i;
    sum[i] = 0;
    for(int j = b; j < a*(i+1); ++j)
    {   if(v[j]%2) sum[i] += v[j];
    }
}
 
int main()
{
    std::vector<int> v(1000, 1); /// TODO: Заполните так, как вам нравится ...
    
    std::vector<std::thread> f;
    
    for(int i = 0; i < 10; ++i)
    {   f.push_back(std::thread(foo, std::ref(v), i));
    }
    
    int total = 0;
    for(int i = 0; i < 10; ++i)
    {   f[i].join();
        total += sum[i];
    }
 
    std::cout << "total: " << total << '\n';
}

int max = INT_MIN;

#include <iostream>
#include <vector>
#include <thread>
 
int sum[10];
 
void init(std::vector<int>& v)
{   for (int i = 0; i < v.size(); i++)
    {   v[i] = rand() % 500;
    }
}
 
void foo(std::vector<int>& v, int i)
{   int a  = v.size() / 10;
    int b  = a * i;
    sum[i] = 0;
    for(int j = b; j < a*(i+1); ++j)
    {   if(v[j]%2 && sum[i] < v[j]) sum[i] = v[j];
    }
}
 
int main()
{
    std::vector<std::thread> f;
    std::vector<int> v(1000, 1);
    init(v); 
         v[777] = 2021; ///<--- яйцо!
    
    for(int i = 0; i < 10; ++i)
    {   f.push_back(std::thread(foo, std::ref(v), i));
    }
    
    int total = 0;
    for(int i = 0; i < 10; ++i)
    {   f[i].join();
        if(total < sum[i]) total = sum[i];
    }
 
    std::cout << "find: " << total << '\n';
}