Outputting while getting input

Question

I would like to be able to output information while inputting. For example: Printing a line every second, but also taking user input...

I tried:

#include <iostream>
#include <thread>
#include <string>
#include <unistd.h>
using namespace std;

void foo()
{
    while(1)
    {
        usleep(1000000);
        cout << "Cake\n";
    }
}

int main()
{
    thread t1(foo);
    t1.join();
    string x;
    while(1)
    {
        cin >> x;
        cout << x << "\n";
    }
    return 0;
}

Which outputs:

Cake
Cake
Cake

And then I start typing:

hiCake

When I would like it to be:

Cake
hi

Where the 'hi' is still in the input

If this isn't possible, is there at least a way for me to pause the outputting while there is text being inputted?

I'm using C++11 on Windows 7 using CygWin for the Unix libraries

MUTEX TESTS

Output loop locked:

#include <iostream>
#include <thread>
#include <string>
#include <unistd.h>
#include <mutex>
using namespace std;

mutex mtx;

void foo()
{
    mtx.lock();
    while(1)
    {
        usleep(1000000);
        cout << "Cake\n";
    }
    mtx.unlock();
}

int main()
{
    thread t1(foo);
    t1.join();
    string x;
    while(1)
    {
        cin >> x;
        cout << x << "\n";
    }
    return 0;
}

Input loop locked:

#include <iostream>
#include <thread>
#include <string>
#include <unistd.h>
#include <mutex>
using namespace std;

mutex mtx;

void foo()
{
    while(1)
    {
        usleep(1000000);
        cout << "Cake\n";
    }
}

int main()
{
    thread t1(foo);
    t1.join();
    string x;
    mtx.lock();
    while(1)
    {
        cin >> x;
        cout << x << "\n";
    }
    mtx.unlock();
    return 0;
}

Pure output locked:

#include <iostream>
#include <thread>
#include <string>
#include <unistd.h>
#include <mutex>
using namespace std;

mutex mtx;

void foo()
{
    while(1)
    {
        mtx.lock();
        usleep(1000000);
        cout << "Cake\n";
        mtx.unlock();
    }
}

int main()
{
    thread t1(foo);
    t1.join();
    string x;
    while(1)
    {
        cin >> x;
        cout << x << "\n";
    }
    return 0;
}

Pure input locked:

#include <iostream>
#include <thread>
#include <string>
#include <unistd.h>
#include <mutex>
using namespace std;

mutex mtx;

void foo()
{
    while(1)
    {
        usleep(1000000);
        cout << "Cake\n";
    }
}

int main()
{
    thread t1(foo);
    t1.join();
    string x;
    while(1)
    {
        mtx.lock();
        cin >> x;
        mtx.unlock();
        cout << x << "\n";
    }
    return 0;
}

To save space, I won't paste more code; I did other tests where I made a mutex mtx2 and tried to lock both input (mtx) and output(mtx2) (both pure and the loops). I did also try locking both with mtx (again, both pure and loops)

Answer 1

Use a mutex to protect your critical sections of code - see http://www.cplusplus.com/reference/mutex/mutex/

Answer 2

Your code with pure output locked is almost right solution. What needs to be done is to guard both "cout" statements with mutexes and move std::thread::join behind while loop in main or it will never get executed:

using namespace std;

mutex mtx;

void foo()
{
    while(1)
    {
        usleep(1000000);
        mtx.lock(); // we want mutex to be held only for time of cout, not time of wait
        cout << "Cake\n";
        mtx.unlock();
    }
}

int main()
{
    thread t1(foo);
    string x;
    while(1)
    {
        mtx.lock(); // we lock second occurence of cout and cin not to get interrupted by foo
        cin >> x;
        cout << x << "\n";
        mtx.unlock(); 
    }
    t1.join(); // thread join stops the calling thread until called thread is finished
    // so we join the thread just before our program finishes
    return 0;
}

This way you will get output like:

Cake
Hi
Hi

Why we don't lock the foo() for the time of usleep? Because it would lock mutex for longer than necessary.

Why I opt to not locking mtx before cin? Because time of cin is highly undefined. And if foo() was performing any important action it could be paused for pretty long time.

Personally I recommend you reading on the book C++ Concurrency in Action by Anthony Williams. Great reading in my opinion.

Answer 3

Use a "printing" object that synchronizes access to cout:

struct SyncCOUT{
  SyncCOUT(): m_mutex() {}
  std::mutex m_mutex;
  std::ostream & operator<<(const char * _str)
  {
    m_mutex.lock();
    cout << _str;
    m_mutex.unlock();
    return cout;
  }
};

SyncCOUT g_scout;

// and then in both threads use this global synchronized "cout" wrapper like this:
// g_scout << "Hello, world!\n";

Answer 4

For this to work, you will need to do few things:

1. Create two threads, one will write text on standard output, another will read the text from the standard input.

2. Make the output thread lock a mutex before writing, and unlock it after writing. This writing operation will be your "critical section".

3. Inside the read thread, read the data character by character directly from the terminal. On Unix you would use the curses library for this task (probably the getch() function), on Windows you would probably use ReadFile on the handle acquired from GetStdHandle(STD_INPUT_HANDLE).

4. Then you could create a simple state machine: if the user presses the key that is not enter, try to lock the mutex. If the user presses the enter key, unlock the mutex.

This way it will be possible for the write thread to output text only after the user will press the enter key. When the user will be in the middle of inputting text (that is, before pressing enter key), the mutex will block writing operation until the user presses the enter key.

This approach would probably need to be expanded to also handle pressing the backspace key.

Answer 5

You likely need to explicitly synchronize std::cout by calling std::cout.flush().

This appears to be an issue with the implementation of the console you are running under. Some consoles, such as cmd.exe and powershell have an implicit flush() synchronization performed after each insertion (<<) operation on std::cout. I was concerned about the thread code I was testing having a concurrency problem until I discovered it worked as expected under cmd.exe and powershell, but not under MINGW64/MSYS2 (Git for Windows deployment).

without the flush call my two threads were not interleaving characters as expected, and in fact were not outputting characters at all until the worker thread was .join()ed until I added the explicit std::cout.flush(). After that was added all three consoles had the same behavior.