One of the many things included in C++20 is the support for synchronizing output streams for operations that may have race conditions. To understand the problem let’s begin with the following example:<\/p>\n\n\n\n
int main()\n{\n std::vector<std::jthread> threads;\n for (int i = 1; i <= 10; ++i)\n {\n threads.push_back(\n std::jthread([](const int id)\n {\n std::cout << \"I am thread [\" << id << \"]\" << '\\n';\n }, i));\n }\n}<\/pre>\n\n\n\nWe are starting a bunch of threads and what they do is printing a text to the console and then terminate. So you would expect an output like this:<\/p>\n\n\n\n
I am thread [4]\nI am thread [3]\nI am thread [8]\nI am thread [5]\nI am thread [9]\nI am thread [6]\nI am thread [10]\nI am thread [7]\nI am thread [2]\nI am thread [1]<\/pre>\n\n\n\nYou cannot expect the threads to execute in the order they were started but the intention is to have an output like the one above. However, it turns out that what you get is rather scrambled text like the following:<\/p>\n\n\n\n
I am thread [I am thread [4I am thread [2I am thread [7]I am thread [9]\nI am thread [3]\n\nI am thread [5]\nI am thread [10]I am thread [8]\nI am thread [6]\n]\n]\n1]<\/pre>\n\n\n\nThe following example does not exhibit this problem. Let’s take a look:<\/p>\n\n\n\n
int main()\n{\n std::vector<std::jthread> threads;\n\n auto worker = [](std::string text) { std::cout << text; };\n auto names = { \"Alpha\", \"Beta\", \"Gamma\", \"Delta\", \"Epsilon\" };\n\n using namespace std::string_literals;\n for (auto const& name : names)\n threads.push_back(std::jthread(worker, \"Hello, \"s + name + \"!\\n\"));\n}<\/pre>\n\n\n\nNo matter how many times you run this code it always shows the output in the following form:<\/p>\n\n\n\n
Hello, Alpha!\nHello, Delta!\nHello, Gamma!\nHello, Beta!\nHello, Epsilon!<\/pre>\n\n\n\nIn both these examples I used std::cout<\/code> to print to the output console. Obviously, there are data races that occur in the first example but not in the second. However, std::cout<\/code> is guaranteed to be thread-safe (unless sync_with_stdio(false)<\/code> has been called). The use of the operator<<<\/code> is fine, as we can see in the second example. But multiple calls to this operator<<<\/code> are not atomic and they can be interrupted and resumed after the thread resumes its execution. So if we take the line std::cout << \"I am thread [\" << id << \"]\" << '\\n';<\/code> there are four calls to operator<<<\/code>. So the execution can stop between any of these and other thread will write to the output. So the output can have any of these forms:<\/p>\n\n\n\nI am thread [1]\\nI am thread [2]\\n<\/code><\/li>I am thread[I am thread[2]\\n1]\\n<\/code><\/li>I am thread[1I am thread]\\n[2]\\n<\/code><\/li>- etc. etc.<\/li><\/ul>\n\n\n\n
This means that you can solve this problem by writing to an output string stream and after having all the text that should be atomically written to the console using the std::cout<\/code> object. This is shown in the following example:<\/p>\n\n\n\nint main()\n{\n std::vector<std::jthread> threads;\n for (int i = 1; i <= 10; ++i)\n {\n threads.push_back(\n std::jthread([](const int id)\n {\n std::stringstream s;\n s << \"I am thread [\" << id << \"]\" << '\\n';\n std::cout << s.str();\n }, i));\n }\n}<\/pre>\n\n\n\n