Ambiguous output in multi threading

Question

The output generated by my code is ambiguous.

int main()
{

    cout << "THIS IS AN THREADING EXAMPLE IN C++" << endl;
    cout<<"MAIN , reverse and forward are executed"<<endl;
    thread rev_thread(print_reverse,1);
    thread for_thread(print_forwward,1);
    rev_thread.join();
    for_thread.join();
    cout << "AIN , reverse and forward are DONE" << endl;
    return 0;
}
    void print_reverse(int wait_sec)
    {
       for(int rev=5000;rev>=1;rev--)
    {
    //std::this_thread::sleep_for (std::chrono::seconds(wait_sec));
     cout<<"The rev ::" << rev<<endl;

    }
    }
void print_forwward(int wait_sec)
{
    for(int forw=1;forw<=5000;forw++)
    {
    //std::this_thread::sleep_for (std::chrono::seconds(wait_sec));
    cout<<"The forward ::" << forw<<endl;

    }
}

I am expecting a mix of print_forwward and print_reverse in any random manner **

But here is what i am getting :-
The rev ::4997

The rev ::4996
The rev ::4995
The rev ::4994
The rev ::4993
The rev ::4992
The rev ::4991
The rev ::4990
The rev ::4989
The rev ::4988
The rev ::4987
The rev ::4986

The forward ::2
The forward ::3
The forward ::4
The forward ::5
The forward ::6
The forward ::7
The forward ::8
The rev ::4985
The rev ::4984
The rev ::4983
The rev ::4982
The rev ::4981
The forward ::The rev ::4980
The rev ::4979
9The rev ::4978
The rev ::4977
The rev ::4976

The forward ::10
The forward ::11
The forward ::12
The forward ::13
The forward ::14
The rev ::The forward ::15
The forward ::16
4975The forward ::17
The forward ::18
The forward ::19
The forward ::20
The forward ::21
The forward ::22

The rev ::The forward ::234974
The forward ::24
The forward ::25

what is 234974 all about?? and moreover the print rev and forward in one line??!!
Please notice the gaps are also printed in the same way as output!
Here I have commented out the wait for testing
Please note I am new to this concept.
Any help will be highly appreciated

Answer 1

C++ operator << for streams is not "thread safe"; with that I mean that nothing prevents the control to switch between threads in the middle of an expression like std::cout << x << y; between the output of x and the output of y.

What you are seeing is a 23 immediately follower by a 4974.

Unfortunately because of the sad interface defined by the operator it's also not trivial to make it "thread safe" (not impossible, but annoyingly hard).

Actually a string format approach à la printf works much better (also) for this.

Answer 2

what is 234974 all about?? and moreover the print rev and forward in one line??!! Please notice the gaps are also printed in the same way as output! Here I have commented out the wait for testing Please note I am new to this concept. Any help will be highly appreciated

---

It is clear to me that your 'mix' of outputs did occur, just somewhat more interstingly or differently than you expected. I have found this kind of 'interrupted' / 'interleaved' output (on serial devices) even in real time OS's.

I am expecting a mix of print_forwward and print_reverse in any random manner **

Reasonable. But you have not identified the OS you are running on, nor how many cores might be active, both can contribute to or change your results.

I think it is fine to tolerate the issue (of cout's lack-of-thread-safety) by using a mutex so that only 1 thread can cout at a time.

The easiest refactor might be a mutex lock() in front and an unlock() after each cout (in the for loops).

---

You might consider replacing the cout-of-a-value, with a push-of-a-value into a large vector. Yes, the vectors required mutex access also, but because memory based, the push should be much faster than a cout. (sorry, I've not yet measured.)

In my experiment, 10 (default) threads (on a 2 core hw) push values into a vector (init with reserve of 50 million) for a duration of 10 seconds. After the 'race' to fill the vector was complete, a single thread cout'd the vector contents to a file for later analysis (latest test content about 37 million chars. a brief report says the code spent about 3 seconds to write the vector contents to a text file.)

writing ID sequence of 31,862,791 values to ./Q6.txt
complete: 2,968,610 us

The (arbitrary) 10 second duration was measured by thread-main doing mostly nothing while the 10 threads ran. The following snippet is used between the launch and join of the threads, and also produces a 'progress cout' (as the other threads are not using cout)

// threads start

// progress indicator to user
for (size_t i = 0; i < MaxSecs; ++i) // let threads switch for 10 seconds
{
    sleepToWallClockStartOfSec();    // 'main()' sync's to wall clock
    cout << (MaxSecs-i-1) << ' ' << flush; // "9 8 7 6 5 4 3 2 1 0"
}
m_done = true;  // command threads to exit - all threads can see m_done

// threads joins

Linux surprised me ... by how few context switches were completed.