[C++/Thread] Równoległe obliczenia a problem synchronizacji

int independent1(void* data)
{
	while(1)
	{
		SDL_Delay(rand()%1500 + 500);		// Bardzo długie obliczenia ;)
		printf("Thread 1: Wykonano obliczenia.\n");
	}
}

int independent2(void* data)
{
	while(1)
	{
		SDL_Delay(rand()%1500 + 500);
		printf("Thread 2: Wykonano obliczenia.\n");
	}
}

int main(int argc, char *argv[])
	{
	...
	/* Mniej wazne sprawy, tj. tworzenie watkow itp. */
	...

	while(!jakis_warunek)
	{
		OdrysowanieWynikowObliczen();
	}
}

Thread 1: Wykonano obliczenia.
Thread 2: Wykonano obliczenia.
Odrysowano ekran!
Thread 1: Wykonano obliczenia.
Thread 2: Wykonano obliczenia.
Odrysowano ekran!
Thread 2: Wykonano obliczenia.
Thread 1: Wykonano obliczenia.
Odrysowano ekran!
Thread 1: Wykonano obliczenia.
Thread 2: Wykonano obliczenia.
Odrysowano ekran!

struct THREAD_COMMANDSET
{
	int status;        // opcjonalnie
	HANDLE hThread;
	HANDLE hQuitEvent;
	HANDLE hCalculateEvent;
	HANDLE hIdleEvent;
	// tutaj rozkazy do wykonania i wynik
}

DWORD ThreadProc(THREAD_COMMANDSET *data)
{
	// zgłoś gotowość
	data->status = STATUS_IDLE;
	SetEvent(data->hIdleEvent);

	HANDLE array[2] = {data->hQuitEvent, data->hCalculateEvent;};
	while (1)
	{
		DWORD index = WaitForMultipleObjects(2, array, FALSE, INFINITE);

		if (index == 0) // hQuitEvent
		{
			// zakończ wątek
			break;
		}
		else if (index == 1) // hCalculateEvent
		{
			// 1. oblicz dane
			data->status = STATUS_BUSY;
			// 2. zgłoś gotowość
			data->status = STATUS_WYNIK;
			SetEvent(data->hIdleEvent);
		}
	}
	return 0;
}

THREAD_COMMANDSET *watki = new THREAD_COMMANDSET[ilosc_rdzeni];
// eventy
for (int a=0; a<ilosc_rdzeni; a++)
{
	watki[a].hQuitEvent = CreateEvent(0,0,0,0);
	watki[a].hCalculateEvent = CreateEvent(0,0,0,0);
	watki[a].hIdleEvent = CreateEvent(0,0,0,0);
}
// uruchom wątki
for (int a=0; a<ilosc_rdzeni; a++)
{
	watki[a].hThread = CreateThread(0,0,(LPTHREAD_START_ROUTINE)ThreadProc, &watki[a], 0, &id);
}

// dodatkowa tablica do oczekiwania na gotowość dowolnego wątku
HANDLE *hIdleArray = new HANDLE[ilosc_rdzeni];
for (int a=0; a<ilosc_rdzeni; a++)
{
	hIdleArray[a] = watki[a].hIdleEvent;
}

// gówna pętla
while (JestCosDoZrobienia())
{
	// czekaj na dowolny wątek
	int nThreadIndex = WaitForMultipleObjects(ilosc_rdzeni, hIdleArray, FALSE, INFINITE);
	if (MoznaTerazCosPoliczyc())
	{
		// skopiuj mu rozkazy
		watki[nThreadIndex].xx = yy;
		// każ mu obliczyć
		SetEvent(watki[nThreadIndex].hCalculateEvent);
	}
	else
	{
		// czekamy na wynik z wątku x, y, z
		#define IsIdle(index) (!WaitForSingleObject(watki[index].hIdleEvent, 0))
		// IsIdle powinno dodatkowo sprawdzić czy jest wynik, by nie zwrócić
		// TRUE gdy wątek poraz pierwszy zgłosi gotowość bez wykonania pracy: np. (watki[index].status == STATUS_WYNIK)
		if (IsIdle(x) && IsIdle(y) && IsIdle(z))
		{
			// przetwórz wyniki (w wątku?)
		}
	}
}
// zakończ wątki
for (int a=0; a<ilosc_rdzeni; a++)
{
	SetEvent(watki[a].hQuitEvent);
	hIdleArray[a] = watki[a].hThread;
}

// czekaj aż wszystkie zakończą
WaitForMultipleObjects(ilosc_rdzeni, hIdleArray, TRUE, INFINITE);

for (int a=0; a<ilosc_rdzeni; a++)
{
	CloseHandle(watki[a].hQuitEvent);
	CloseHandle(watki[a].hCalculateEvent);
	CloseHandle(watki[a].hIdleEvent);
	CloseHandle(watki[a].hThread);
}
delete hIdleArray;
delete watki;