Revision history [back]

The best approach in C++20 for transferring data from a thread that triggers an event to a continuously running thread in a non-obstructive manner while ensuring efficiency, elegance, and robustness is to use a multiple-producer, single-consumer queue like std::atomic<std::vector<t>>.

This approach uses two threads, one that pushes data onto the queue and another that pops the data off the queue. Because std::atomic<std::vector<t>> is lock-free, it ensures efficiency and non-obstructiveness. Additionally, it's elegant because the producer thread only needs to push data onto the queue, and the consumer thread only needs to pop data off the queue.

To ensure robustness, it's important to handle situations where the consumer thread is not keeping up with the producer thread. In these cases, the queue may fill up, causing the producer thread to block. One approach is to use a std::condition_variable to signal the producer thread when the queue has space available. Another approach is to use a bounded queue with a fixed size, so the producer thread will block if the queue is full.

In summary, using a multiple-producer, single-consumer queue like std::atomic<std::vector<t>> is the most efficient, elegant, and robust approach for transferring data between threads in C++20.