### A simple approach to generate Fibonacci series via multi-threading

This is a very simple approach taken to generate the Fibonacci series through multithreading. Here instead of a function, used a function object. The code is very simple and self-explanatory.

#include <iostream>
#include <mutex>

class Fib {
public:
Fib() : _num0(1), _num1(1) {}
unsigned long operator()();

private:
unsigned long _num0, _num1;
std::mutex mu;
};

unsigned long Fib::operator()() {
mu.lock(); // critical section, exclusive access to the below code by locking the mutex
unsigned long  temp = _num0;
_num0 = _num1;
_num1 = temp + _num0;
mu.unlock();
return temp;
}

int main()
{
Fib f;

int i = 0;
unsigned long res = 0, res2= 0, res3 = 0;
std::cout << "Fibonacci series: ";

while (i <= 15) {
std::thread t1([&] { res = f(); }); // Capturing result to respective variable via lambda
std::thread t2([&] { res2 = f(); });
std::thread t3([&] { res3 = f(); });

t1.join();
t2.join();
t3.join();

// Arranging in order, since threads execution can be random,
// So the result may not be in order to display

if (res > res3) std::swap(res, res3);
if (res > res2) std::swap(res, res2);
if (res2 > res3) std::swap(res2, res3);

std::cout << res << " " << res2 << " " << res3 << " ";
i += 3;
}
}

We can use std::lock_guard like below to give RAII style mechanism for owning the mutex during the scoped block.

unsigned long Fib::operator()()
{
// critical section, exclusive access to the below code by locking a mutex by lock_guard
std::lock_guard<std::mutex> lock(mu);
unsigned long  temp = _num0;
_num0 = _num1;
_num1 = temp + _num0;
return temp;
}