jThread | Simple way to use multi

You can close stdin in your signal handler. fgets will then return immediately (and presumably, return NULL).

The good news is that close is on the list of functions that are safe to call from a signal handler (it's a pretty restrictive list). Happy days.

There's an alternative based around EINTR, but it looks messy since you don't know for certain that fgets will actually return when it gets it.

Also, closing stdin should still work should you switch to using cin and getline, which would definitely improve your code (*). That probably returns and sets badbit when you close stdin, although the code can be made more robust than by checking for that alone. Perhaps just set a (volatile) flag in your signal handler and test that.

(*) Because getline can read into a std::string, which means it can read arbitrary long lines without worrying about allocating a fixed-size buffer that is 'big enough'.

Looks like it's a bug in gcc (the one I mentioned in the comments). When wait_for() is used and another thread tries to lock the same mutex then it triggers "double lock" warning. A simplified example:

The jthread constructor accepts a function that takes a std::stop_token as its first argument, which will be passed in by the jthread from its internal stop_source.

Here is an example:

You can use std::bind_front to bind this to &test::member and pass it to jthread:

Does it lock some mutex?

Yes, indirectly. The std::basic_osyncstream class, of which osyncstream is a specialization of the form basic_osyncstream, is derived from std::basic_ostream and will typically have just one 'extra' member, of the std::basic_syncbuf class. From cppreference:

Typical implementation of std::basic_osyncstream holds only one member: the wrapped std::basic_syncbuf.

It is that basic_syncbuf object that implements the output synchronization, preventing data races. Again, from cppreference (bolding mine):

Typical implementation of std::basic_syncbuf holds a pointer to the wrapped std::basic_streambuf, a boolean flag indicating whether the buffer will transmit its contents to the wrapped buffer on sync (flush), a boolean flag indicating a pending flush when the policy is to not emit on sync, an internal buffer that uses Allocator (such as std::string), and a pointer to a mutex used to synchronize emit between multiple threads accessing the same wrapped stream buffer (these mutexes may be in a hash map with pointers to basic_streambuf objects used as keys).

Your std::jthread code can be simplified to:

That's not how osyncstream is supposed to be used. Every thread needs to construct its own osyncstream; there is no synchronization on access to the osyncstream itself. Only the transfer performed by emit is synchronized, and then only with respect to the streambuf it wraps.

Having a global osyncstream is therefore entirely pointless.

Your runner is configured to use shell executor (as you can see line 3 of your printscreen) but to run Docker image, you have to use docker or docker-windows executor (depending of if container you want to run is Linux or Windows based).

I don't think you can use SQL Server integrated authentication from Linux machine.

In order to be able to use the approach with the Microsoft JDBC Driver and integrated authentication you need to run your builds on a Windows Runner

In case you have to use Linu you can work it around using JTDS JDBC Driver and connection string like: