Sto cercando di familiarizzare con la programmazione concorrente e ho acquisito un esercizio per utilizzare un numero fisso di thread che eseguono ricerche in una struttura di directory.
Questo è più o meno il modo in cui dovrebbe funzionare:
(Midispiace,sonoorribileneldisegnarediagrammidiflusso,masperochespieghilamiaidea)
Perora,hoquestocodice:
void ThreadManager::iAmRunning( )
{
pthread_mutex_lock( &this->thread_mutex );
if( this->waitingthreads > 0 )
this->waitingthreads--;
this->runningthreads++;
this->all_work_done = false;
pthread_mutex_unlock( &this->thread_mutex );
}
void ThreadManager::iAmWaiting( )
{
pthread_mutex_lock( &this->thread_mutex );
if( this->runningthreads > 0 )
this->runningthreads--;
this->waitingthreads++;
if( this->waitingthreads >= NUM_THREADS )
{
this->all_work_done = true;
pthread_cond_broadcast( &this->work_done_cond );
}
else
this->all_work_done = false;
pthread_mutex_unlock(&this->thread_mutex);
}
Directory* ThreadManager::GetWorkItem()
{
this->iAmWaiting( );
pthread_mutex_lock( &this->directory_mutex );
while( this->workqueue.size() == 0 )
{
if (this->all_work_done)
{
pthread_mutex_unlock(&this->directory_mutex);
return NULL;
}
pthread_cond_wait( &this->work_done_cond, &this->directory_mutex );
}
this->iAmRunning( );
Directory* ret = this->workqueue.back();
this->workqueue.pop_back();
pthread_mutex_unlock( &this->directory_mutex );
return ret;
}
Conosco il modello produttore / consumatore e sembra che sia vicino a ciò di cui ho bisogno, ma in questo caso, ogni thread produce e consuma allo stesso tempo.
Non voglio reinventare la ruota, ma voglio capire cosa sta succedendo sotto la cappa, quindi non sto cercando una libreria per risolvere il mio problema, ma sono interessato a uno schema risolvere questo problema. Se necessario, posso fornire più codice, ma spero che il disegno sopra spieghi la mia domanda nel modo migliore.
Naturalmente, se mi sto avvicinando a questo in modo totalmente sbagliato, per favore fatemelo sapere, sono molto curioso delle vostre opinioni.