C++ Multithreading, Mutex - c++

Question

Back in days I was working on an option that would speed up my function by multithreading. The base function finished around 15seconds, and I would like to reducing it, but I cannot logicing out how to create a good and working multithreading function.
Base function, before touches:
void FirstCall()
{
MainFunction1();
MainFunction2();
}
void MainFunction1()
{
//Call another functions, MainFunction3-10 for example
}
void MainFunction2()
{
//Cann another, different functions, in a for loop
}
In this case, the time that needed to finishing the function is around 15 seconds.
That I found to speeding up this function was the multithreading idea.
Let me show how it is right now, and what is my problem with it.
//Way 1 of multithreading
void FirstCall()
{
std::vector<std::thread> threads;
threads.push_back(std::thread(&MainFunction1, this));
threads.push_back(std::thread(&MainFunction2, this));
for (auto& th : threads)
{
if (th.joinable())
{
th.join();
}
}
}
The other functions are exactly same, so that shouldnt be related to the runtime. The runtime with the function that I showed up above is around 8-10seconds, so seems it is working fine, but sometimes the application simply closing when this function is called.
//Way 2 of multithreading
void FirstCall()
{
static std::mutex s_mutex;
static std::atomic<int> thread_number = 0;
auto MainFunctions = [&](int index)
{
SwitchMainFunctions(index);
}
auto ThreadFunction = [&]()
{
std::lock_guard<std::mutex> lGuard (s_mutex);
MainFunctions(thread_number++);
}
int thread_count = std::thread::hardware_concurrency(); //8
//thread count > function count (2 functions)
std::vector<std::thread> threads;
for (int i = 0; i < 2; i++)
{
threads.push_back(std::thread(ThreadFunction));
}
for (auto& th : threads)
{
if (th.joinable())
{
th.join();
}
}
threads.clear();
}
void SwitchMainFunctions(int index)
{
switch(index)
{
case 0:
{
MainFuunction1();
}
break;
case 1:
{
MainFuunction2();
}
break;
default:
{
return;
}
break;
}
}
The function that is presented as way 2 of multithreading is working fine, my application is do not crashing anymore, but the run time is same like the untouched function time is ~15 seconds.
I think the mutex lock is forceto wait until one thread is finishing, so it is exactly same if I'd just using the default code, but I would like really speeding up the function.
I tried to speed up my function with multithreading option, but the 2 way I tried to do have different problems.
The first idea is sometimes force my application crashing when the function is called.
The second way that I created have the same run time than the default function has without multithreading.

Answer 1

Your second option is far more complicated first option. Here is simple
FirstCall():
void FirstCall()
{
std::vector<std::thread> threads;
threads.push_back(std::thread(MainFunction1));//this removed since MainFunction1 is void
threads.push_back(std::thread(MainFunction2));
for (auto& th : threads)
{
if (th.joinable())
{
th.join();
}
}
}
In this simple scenario main thread will block till both threads finish and join. In your first option you used this as argument for MainFunction1 in thread constructor. That implies FirstCall() to be member function of this.
In such case you should add whole class definition to your question and at least scope of MainFunction1/2. This will help to understand why application simply closing.
Your second option is worse then single threaded since lGuard will unlock only when thread finished executing all functions.
auto ThreadFunction = [&]()
{
std::lock_guard<std::mutex> lGuard (s_mutex);
MainFunctions(thread_number++);
//MainFunctions calls SwitchMainFunctions
//SwitchMainFunctions calls MainFunction
//when done lGuard unlocks on destruction
}
Another problem with second option is why do you need mutex at all. If you insist to map std::atomic thread_number to specific function simply pass result of atomic fetch_add to SwitchMainFunctions in thread constructor.
void FirstCall()
{
std::atomic<int> thread_number = 0;
std::vector<std::thread> threads;
for (int i = 0; i < 2; i++)
{
threads.push_back(std::thread(SwitchMainFunctions, thread_number++));
}
for (auto& th : threads)
{
if (th.joinable())
{
th.join();
}
}
}