Serial Port conflicts with threads in c++ - c++

Question

This is my simplified class which is used to detect problem in my full program:
SimpleThread.h
class SimpleThread {
public:
SimpleThread();
~SimpleThread();
void startThread();
void threadFn();
private:
SerialPort mySerial;
std::thread myThread;
int count;
std::mutex myMutex;
};
SimpleThread.cpp
SimpleThread::SimpleThread(): mySerial("/dev/ttyACM0") {
count = 0;
mySerial.Open(//Here correct params//);
}
SimpleThread::~SimpleThread() {}
void SimpleThread::threadFn() {
char cp;
while (true) {
cp = mySerial.ReadByte(0);
std::cout << count++ << " " << cp << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
void SimpleThread::startThread() {
myThread = std::thread(&SimpleThread::threadFn, this);
myThread.detach();
}
main.cpp
int main() {
SimpleThread thr;
thr.startThread();
while (true) {
std::cout << "Waiting 5 seconds" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(5));
}
}
The main idea of my example: I am using class member function as thread function to read data from opened serial port. There are no problems in using this class without reading from serial: main loop prints message every 5 seconds while thread loop (function inside class) prints 5 numbers.
Now I want to implement reading from serial port while my main loop is going to do something else. To read/write in serial I took this not so up-to-date serial library.
In this case class starts to work unexpected for me: main loop (which should show message every 5 seconds) shows its message faster then thread loop (about 40 times while 1 second). This code works wrong cause main loop prints message 40 times at 1 second (after read byte) despite sleep function.
So my question is: where is the root of my problem? Should I use another serial library or there are some features connected with interruptions which I dont know about?
Edit: If I use next loop for reading with checking if data is available, the main loop prints after every read byte. Looks like reading byte in thread loop interrupts main loop and cancels sleeping.
if ( mySerial.IsDataAvailable() ) {
cp = mySerial.ReadByte(0);
std::cout << count++ << " " << cp << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
}
Edit 2: Moreover, I tested just opening the Serial but without reading from Serial in loop (with changed pause in thread loop on two seconds)
if ( mySerial.IsDataAvailable() ) {
std::cout << count++ << " " << cp << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(2));
}
In this case main loop prints every one second. There is no problem only if Serial port is not opened.

Answer 1

libserial uses asynchronous I/O which is based on signals (SIGIO to be precise) and there was a bug in GCC 5 (#66803) in which std::this_thread::sleep_for was interrupted by signals. It has been fixed in GCC 6.
The possible solutions are:
Upgrade your compiler to GCC 6+ or clang/LLVM.
Use a workaround like the one mentioned in the bug 66803 or try sleep_until:
auto wakeup_time = std::chrono::steady_clock::now() + std::chrono::seconds(1);
std::this_thread::sleep_until(wakeup_time);
Use blocking I/O (I believe you can simply open the serial device as a file and read from it).