I’m working on a project that makes heavy use of multithreading; I think it’s been years since I wrote code that didn’t at least use std::thread or std::async to some extent.
I started programming in C for bare-metal AVR microcontrollers (no threading needed in that case), and I didn’t really move into C++ until just after C++11 was already established; that is to say, I have always had access to concurrency tools that are built into the standard library.
I’m curious how threads were implemented prior to C++11; I know that 3rd-party libraries exist for this, but how did the libraries themselves handle it? I’m assuming the only option was to use calls to the OS with a lot of preprocessor macros depending on the target OS. Writing loops with a stored state would work, but not only did coroutines not exist in the STL until much later, but this wouldn’t take advantage of multi-core CPUs, which were already commonplace before C++11.
There are certainly some times I take modern language features for granted. So, for the experienced programmers out there: How did it used to be done?
I’m curious how threads were implemented prior to C++11;
People used platform-specific libraries and frameworks to handle threading. For example, Windows provides APIs to create processes and threads in it’s processthreadsapi.h.
https://learn.microsoft.com/en-us/windows/win32/procthread/creating-threads
I know that 3rd-party libraries exist for this, but how did the libraries themselves handle it?
The underlying OS provides these features.
On POSIX systems there is the pthread library. Pretty easy to use. At least on Linux I think std::thread is just a wrapper for pthread.
Most multi-threaded software was OS-specific, so they just used the OS threading utilities directly. Most serious multi-platform software writes their own abstraction on top of threads anyway.