Interrupt a getLine() while loop in C++ - c++

Question

I made a console applications that accepts commands from two sources:
The actual console -> this is a while(getLine()) loop in a seperate thread.
A websocket server -> this also runs on a seperate thread
If there is a command entered, the command is stored in a vector until another while loop (that runs every 20ms) loops trough all the commands entered in the time passed. If he reads a command, he executes it.
Now, there is a Stop command who stops the application. When entered, the application shuts down as expected. But the problem is: this takes some time, and you can still enter text from the first command source (getline()). Once you type something, the shutdown sequence stops, and waits until you pressed enter.
I terminate the first thread (that contains the getline loop) once the shutdown sequence starts. But that doesn't work...
Any ideas?
Thanks in advance!

Answer 1

getline() is a blocking call, you'll probably have to use something different, if you want to receive messages (i.e. a shut down command) from other threads. You did not mention which library you use for multithreading and how you terminate the console reading thread (it's possible, that your way of stopping the thread still does not force it to exit from getline)
This question seems to have some relevant answers: Peek stdin using pthreads
By the way, you mentioned a vector, which is (if I understood it correctly) accessed from multiple threads. You'll have to take care about proper synchronization (e.g. using a mutex when accessing the vector).
Also, the fact that you have some kind of loop, which "polls" the vector every 20 ms is indicating that you may have some flaws in overall design of your application. Try to get rid of it by using more appropriate means for passing events between threads, such as condition variables.

Answer 2

The problem is that getline is a blocking call and will return just after you press ENTER in case of stdin.
I had a similar problem and solved it as shown below.
I used two file descriptors: one to monitor the stdin and an other to monitor a "self-pipe". The latter acts as a trigger to unlock the select in case some event happens. The former ensures getline is called just once it can read a full line.
#include <future>
#include <string>
#include <iostream>
#include <thread>
#include <unistd.h>
#include <stdio.h>
#include <sys/select.h>
int pipe_fd[2];
auto p = pipe(pipe_fd);
auto stdin_fd = fileno(stdin); // 0
fd_set check_fd;
int main(int argc, char const *argv[])
{
FD_ZERO(&check_fd);
FD_SET(stdin_fd, &check_fd);
FD_SET(pipe_fd[0], &check_fd);
auto t1 = std::async(std::launch::async, [] {
std::this_thread::sleep_for(std::chrono::seconds(10));
uint32_t dummy = 43;
// this will stop the data input
write(pipe_fd[1], &dummy, sizeof(dummy));
});
auto maxfd = pipe_fd[0] > pipe_fd[1] ? pipe_fd[0] : pipe_fd[1];
select(maxfd + 1, &check_fd, nullptr, nullptr, nullptr);
if (FD_ISSET(stdin_fd, &check_fd))
{
std::string input;
std::getline(std::cin, input);
std::cout << "You enterd:" << input << std::endl;
}
if (FD_ISSET(pipe_fd[0], &check_fd))
std::cout << "Event" << std::endl;
return 0;
}