Audio threading - c++

Question

I have a seperate thread for audio in my application because it sounded like a good idea at the time but now I am conserned at how other threads will comunicate with the audio thread.
audioThread() {
while(!isCloseRequested) {
If(audio.dogSoundRequested) {
audio.playDogSound();
}
}
}
otherThread() {
Audio.dogSoundRequested();
}
Would this be an efficient way to thread audio or do you see issues with this setup?

Answer 1

The issue at stake here seems to be
1: how to make audio.dogSoundRequested and isCloseRequested thread-safe.
2: audioThread is busy-waiting (e.g. spinning infinitely until audio.dogSoundRequested becomes true.
As others have suggested, you could use a mutex to protect both variables, but this is overkill - additionally, it's generally good form in audio code not to use blocking sychronisation in order to avoid issues with priority inversion.
Instead, assuming you're using C++11 or C++14, you could use an atomic variable, whcih are lightweight and don't (in most implementations) block:
#include <atomic>
...
std::atomic<bool> dogSoundRequested{false};
std::atomic<bool> isCloseRequested{false};
Reads and writes to the std::atomic have the same contract as for built-in types, but will generate code that ensures the read and write are atomic with respect to other threads, and that the results are synchronised with other CPUs.
In the case of audio.dogSoundRequested you want both of these effects, and in the case of isCloseRequested, that the result is immediately visible on other CPU.
To solve the busy-waiting issue, use a condition variable to awake audioThread when there's something to do:
#include <condition_variable>
std::mutex m;
std::condition_variable cv;
audioThread()
{
while(!isCloseRequested)
{
m.lock();
cv.wait(m);
// wait() returns with the mutex still held.
m.unlock();
if(audio.dogSoundRequested)
{
audio.playDogSound();
}
}
}
void dogSoundRequested()
{
dogSoundRequested = true;
cv.notify_one();
}

Answer 2

In addition to the use of mutex, here is a simple setup for multiple threads
// g++ -o multi_threading -pthread -std=c++11 multi_threading.cpp
#include <iostream>
#include <thread>
#include <exception>
#include <mutex>
#include <climits> // min max of short int
void launch_consumer() {
std::cout << "launch_consumer" << std::endl;
} // launch_consumer
void launch_producer(std::string chosen_file) {
std::cout << "launch_producer " << chosen_file << std::endl;
} // launch_producer
// -----------
int main(int argc, char** argv) {
std::string chosen_file = "audio_file.wav";
std::thread t1(launch_producer, chosen_file);
std::this_thread::sleep_for (std::chrono::milliseconds( 100));
std::thread t2(launch_consumer);
// -------------------------
t1.join();
t2.join();
return 0;
}

Answer 3

Rather than complicate the code with mutexes and condition variables, consider making a thread-safe FIFO. In this case, one that could have multiple writers and one consumer. Other threads of the application are the writers to this FIFO, the audioThread() is the consumer.
// NOP = no operation
enum AudioTask {NOP, QUIT, PLAY_DOG, ...};
class Fifo
{
public:
bool can_push() const; // is it full?
void push(AudioTask t); // safely writes to the FIFO
AudioTask pop(); // safely reads from the FIFO, if empty NOP
};
Now the audioThread() is a bit cleaner, assuming fifo and audio are application class members:
void audioThread()
{
bool running = true;
while(running)
{
auto task = fifo.pop();
switch(task)
{
case NOP: std::this_thread::yield(); break;
case QUIT: running = false; break;
case PLAY_DOG: audio.playDogSound(); break;
}
}
}
Finally, the calling code only needs to push tasks into the FIFO:
void request_dog_sound()
{
fifo.push(PLAY_DOG);
}
void stop_audio_thread()
{
fifo.push(QUIT);
audio_thread.join();
}
This puts the details of the thread-safe synchronization inside the Fifo class, keeping the rest of the application cleaner.

Answer 4

If you want to be sure that no other thread touches the playDogSound() function, use a mutex lock to lock the resource.
std::mutex mtx;
audioThread() {
while(!isCloseRequested) {
if (audio.dogSoundRequested) {
mtx.lock();
audio.playDogSound();
mtx.unlock();
}
}
}