C++ Play - Multithreading

class TestMTLocalStorage {
	int i = 0;
public:

    // called only once
	TestMTLocalStorage(int _i) : i(_i) { cout << "Constructor" << endl; } 

    // not called
	TestMTLocalStorage(const TestMTLocalStorage& t) {
		cout << "Copy " << endl;
	}

    // not called
	TestMTLocalStorage() { cout << "default" << endl; } // not called

    // not called
	TestMTLocalStorage(TestMTLocalStorage&& mv) noexcept { cout << "move" << endl; }

	operator int&() { return i; }

    // called after exit from main, similar to static variables, only once
	~TestMTLocalStorage() noexcept { 
		cout << "Destructor" << endl;  
	}
};

int compute_i() {
	cout << "Compute i called" << endl;
	return 0;
}

void test_multithreading_thread_local() {

	thread_local TestMTLocalStorage i = compute_i(); // can be initialized dinamically;

	mutex m;
	condition_variable cv;

	cout << "Address of i is: 0x" << hex << &i << endl;

	auto fn = [&m, &cv]() {
		{
			unique_lock<std::mutex> ul(m);
			cv.wait(ul);
		}

		for (int j = 0; j < 100000; j++)
			i++; // some computation;

		{
			lock_guard<mutex> lck(m);
			cout << "Thread local variable i is: " << dec << i 
                    << ". Address of i is: 0x" << hex << &i << endl; 
                    // different addresses of i;
		}

	};

	thread t1(fn);	
	thread t2(fn);

	cv.notify_all();

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

}

int main()
{	
	test_multithreading_thread_local();

    return 0;
}

{
	unique_lock<std::mutex> ul(m);
	cv.wait(ul);
}

{
    lock_guard<mutex> lck(m);
    cout << "Thread local variable i is: " << dec << i 
         << ". Address of i is: 0x" << hex << &i << endl; 
        // different addresses of i;
}

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

void test_create_threads() {
	using namespace std;

// use a windows_handle -> unique wrapper around handle. 
// can be passed around but not owned by several objects at the same time; 
// only move operations allowed
// function create_thread wraps CreateThread function so that 
// it accepts lambdas and various parameters; not just a void*

	try {
        // create thread should receive a lambda, with a set of type-safe transmitted parameters.
        // RAII, so that, in case of exception, everyhing is cleaned up nicely.
		windows_handle wh = create_thread([](auto a, auto b, auto c) -> DWORD {

			cout << "Hello from windows threads: " << a << " " << b << " " << c << endl;

			return EXIT_SUCCESS;

		}, 5, 7, "Hello World");

		wait_for_all(true, INFINITE, wh);

		cout << "Done. " << endl;

	}
	catch (const win_exception& ex) {
		cout << ex.what() << endl;
	}
}

void test_mutexes() {
	using namespace std;

    // can be shared across processes if name != NULL
	mutex_handle mtx = ::CreateMutex(NULL, FALSE, NULL); 

	auto fn = [&mtx]() -> DWORD {
		try{
			auto lock = mtx.acquire(); // RAII
			cout << "Hello World from Mutexes" << endl;
			::Sleep(1000);			
		}
		catch (const win_exception& ex) {
			cout << ex.what() << endl;
		}
		return 0;
	};

	windows_handle th1 = create_thread(fn);
	windows_handle th2 = create_thread(fn);
	windows_handle th3 = create_thread(fn);
	windows_handle th4 = create_thread(fn);

	wait_for_all(true, INFINITE, th1, th2, th3, th4);
}

template<typename Fn, typename... Params>windows_handle create_thread(const Fn& f, const Params& ...p) {

	auto ts = new __internal_thread_struct<Fn, Params...>(f, p...);
	return ::CreateThread(nullptr, 0, __internal_thread_struct<Fn, Params...>::ThreadFunc, ts, 0, 0);
}

static DWORD __stdcall ThreadFunc(void* ptr) {
    auto ts = reinterpret_cast<__internal_thread_struct*>(ptr);
    DWORD ret = ts->fn();
    ptr = nullptr;
    delete ts;
    return ret;
	}

std::function<DWORD()> fn = nullptr;

__internal_thread_struct(const Fn& f, const Params&... p) {
    // this is required so that parameters of type char o[12] like 
    // constants "Hello World" are transformed in const char*
	transform_from_arrays_to_ptrs(f, fwd(p)...);		 
}

template<typename... ParamsWashed> void transform_from_arrays_to_ptrs(const Fn& f, 
            const ParamsWashed&... p) {
    // here is a trick. in order to be able to keep params... for later, 
    // we wrap them in a closure in a std::function

	fn = [f, p...]()->DWORD{ 
		return f(p...);
	};
}
template<typename T> const T& fwd(const T& t) { return t; }

const char* fwd(const char ptr[]) { 
    // for stack allocated variables copy is needed. except for char[] which are pooled, so it works.
	return ptr;
} // for the rest of stack allocated arrays -> error

fn = [f, p...]()->DWORD{ 
		return f(p...);
	};

template<typename... WindowsHandles> void pack(HANDLE* arr){} // recursion end

template<typename... WindowsHandles> void pack(HANDLE* arr, const windows_handle& wh, 
            const WindowsHandles&... rest) { // bind to windows_handle type only

	*arr = wh;
	pack(++arr, rest...);
}

template<typename... WindowsHandles> DWORD wait_for_all(bool wait_all, int millis, 
        const WindowsHandles&... handles) {

	HANDLE arr[sizeof...(handles)];
	pack(arr, handles...);
	DWORD ret = ::WaitForMultipleObjects(sizeof...(handles), arr , wait_all, millis);

	if (ret == WAIT_FAILED)
		throw win_exception("Wait failed");

	return ret;
}

class windows_handle {

protected:
	HANDLE _h = nullptr; 
public:
	windows_handle(HANDLE h) : _h(h) {}
	windows_handle(windows_handle&& other) noexcept{
		_h = other._h; other._h = nullptr;
	}

	virtual ~windows_handle() noexcept {
		if (_h != nullptr)
			CloseHandle(_h);
		_h = nullptr;
	}

	windows_handle& operator=(windows_handle&& other) {
		_h = other._h; other._h = nullptr;
		return *this;
	}

	windows_handle(const windows_handle& uwh) = delete; // no copy constructor
	windows_handle operator=(const windows_handle& uwh) & = delete; // no assignment operator

	operator HANDLE() const {
		return _h;
	}

	auto wait(DWORD millis = INFINITE) {
		return WaitForSingleObject(_h, millis);
	}
};

class mutex_handle : public windows_handle {
public:

	using windows_handle::windows_handle;

	auto acquire(DWORD millis = INFINITE)  {

		if (windows_handle::wait(millis) != WAIT_OBJECT_0)
			throw win_exception("could not acquire mutex");

		return scoped_obj([this]() {
			::ReleaseMutex(_h);
		});
	}

	auto wait(DWORD millis) = delete;
};

class scoped_obj {
private:
	std::function<void()> fn;
public:
	scoped_obj(const std::function<void()> & _fn) : fn(_fn) {}

	~scoped_obj() {
		if(fn != nullptr)
			fn();
	}

	scoped_obj(scoped_obj&& other) {
		fn = other.fn; other.fn = nullptr;
	}

	scoped_obj& operator=(scoped_obj&& other) {
		fn = other.fn; other.fn = nullptr;
		return *this;
	}

    // no copy constructor
	scoped_obj (const scoped_obj& uwh) = delete; 

    // no assignment operator
	scoped_obj& operator=(const scoped_obj& uwh) & = delete; 

};