Mutex_A.lock(); //don't continue until A is finished
Mutex_B.lock(); //don't continue until B is finished
Mutex_C.lock(); //don't continue until C is finished

//TODO: Finish with Update A, B & C resources

Mutex_A.unlock(); //free A for next loop
Mutex_B.unlock(); //free B for next loop
Mutex_C.unlock(); //free C for next loop
};

will this constant creation and destruction of threads cause too much overhead?

how would I run something along the lines of
while (Mutex_A is unlocked) { }
[/quote]
Don't do that. You probably want to use condition variables or maybe a boost::barrier. Practicing with those will also help with the creation of producer/consumer queues

Quick example in pseudo C++:


void other_thread(bool &stuff_done, mutex &m, condvar &cv)
{
{
lock_guard lk(m);
// do some stuff
// ...
stuff_done = true;
}

// tell the other thread we're done
cv.notify(); // or maybe notify_all() if multiple threads are waiting
}

void main_thread()
{
mutex m;
condvar cv;
bool stuff_done = false;

// Create other thread.
thread other(other_thread, ref(stuff_done), ref(m), ref(cv));

// Wait for other thread to do "the stuff"
lock_guard lk(m);
while (!stuff_done)
cv.wait(lk);

// other thread did "the stuff"
}



__declspec(dllexport) Indigo::Worker::~Worker()
{
lock_t Lock(mutex);


I've been realizing just how much stuff will go into this library.