Thread exercise

[frek]

Ex: Write a program with two treads: one that writes hello every second and one that writes world! every second.

Is the following piece of code a right answer for the exercise above, please?

#include <iostream>
#include <thread>

using namespace std::literals::chrono_literals;

void helloThread() {

    while (true) {
        std::cout << "First thread: hello\n";
        std::this_thread::sleep_for(1s);
    }
}

void worldThread() {

    while (true) {
        std::cout << "Second thread: world!\n";
        std::this_thread::sleep_for(1s);
    }
}

int main()
{
    std::thread hello(helloThread);
    std::thread world(worldThread);

    hello.join();
    world.join();

    system("pause");
    return 0;
}

[salem c]

Yeah, seems about right.

But it's basically the same code in both, so perhaps the message itself could be a parameter.
https://www.cplusplus.com/reference/thread/thread/

[frek]

Yes, we could specify the message as a parameter to the functions. But one more important matter, won't data races occur? Both threads use same objects (std::cout, sleep_for()).

[salem c]

https://en.cppreference.com/w/cpp/io/cout

Unless sync_with_stdio(false) has been issued, it is safe to concurrently access these objects from multiple threads for both formatted and unformatted output.

Where 'safe' means you're not going to hose the machine by using it.

I'm not sure whether 'safe' would go as far as making sure every composite expression would always result in a whole line.

std::cout << position << " thread: " << message << "\n";

If the unit of interleaving is every <<, then you're in for a surprise at some point.
If you care about that, then build a string and output the result using a single <<.



For sleep_for, it's in this_thread

[seeplus]

Or use std:osyncstream with C++20
https://en.cppreference.com/w/cpp/header/syncstream
https://en.cppreference.com/w/cpp/io/basic_osyncstream