喚醒個人線程，而不是忙於在pthreads中等待

Question

我不確定標題是否反映了我在這裏問的問題，但這是最好的，我可以在沒有非常冗長的標題的情況下完成。我試圖在pthreads中實施worker thread型號。我想從main函數中產生一組線程，之後main線程將作業委託給worker，並等待所有線程完成，然後再爲他們分配下一個任務（實際上，要求是將線程安排在一個塊內如CUDA編程模型，但在CPU上，儘管它與當前問題無關）。 job數組用於指示每個線程的作業類型。目前，我已經實施了這種使用信號量來強制等待。我正在尋找方法，以便線程能夠在需要時進入睡眠狀態並喚醒，而不是連續輪詢。

每個線程執行的功能

volatile int jobs[MAX_THREADS]; // global job indicator array 
sem_t semaphore;    // semaphore to indicate completion 
thread_execute(void *args) 
{ 
    tid = get_id(args); 
    while(jobs[tid] != -1) 
    { 
    if(jobs[tid] == 0) continue; // no job 
    if(jobs[tid] == JOBS_1) 
    { 
     jobs1(); 
     jobs[tid] = 0; // go back to idle state 
     sem_post(&semapahore); 
    } 
    if(jobs[tid] == JOBS_2) 
    { 
     jobs2(); 
     jobs[tid] = 0; // go back to idle state 
     sem_post(&semapahore); 
    } 
    } 

    pthread_exit(NULL); 
} 

主要功能如下

int main() 
{ 
    sem_init(&semaphore, 0, 0); 
    jobs[0...MAX_THREADS] = 0; 
    spawn_threads(); 

    // Dispatch first job 
    jobs[0...MAX_THREADS] = JOBS_1; 
    int semvalue = 0; 
    while (semvalue < MAX_THREADS) // Wait till all threads increment the semaphore 
    sem_getvalue(&sempaphore, &semvalue); 

    sem_init(&semaphore, 0, 0); // Init semaphore back to 0 for the next job 
           // I'm actually using diff. semaphores for diff. jobs 
    jobs[0...MAX_THREADS] = JOBS_2; 
    while (semvalue < MAX_THREADS) 
    sem_getvalue(&sempaphore, &semvalue); 

    jobs[0...MAX_THREADS] = -1; // No more jobs 
    pthread_join(); 
} 

這種實現的問題是，main線程繁忙等待所有工作線程完成和工作線程也不斷地輪詢作業數組以檢查新作業。當線程進入睡眠狀態並在需要的時候喚醒時，是否有更好的方法來處理信號處理程序的線路，並使用pthread_kill()，但是對於單獨的信號處理程序來說這是一種混亂。

Answer 1

您可以使用conditional variable使線程進入休眠狀態，直至發出信號。

volatile int jobs[MAX_THREADS]; // global job indicator array 
pthread_cond_t th_cond;  // threads wait on this 
pthread_mutex_t th_mutex; // mutex to protect the signal 
int busyThreads = MAX_THREADS; 

pthread_cond_t m_cond;  // main thread waits on this 
pthread_mutex_t m_mutex; // mutex to protect main signal 

thread_execute(void *args) 
{ 
    tid = get_id(args); 
    while(jobs[tid] != -1) 
    { 
    if(jobs[tid] == 0) continue; // no job 
    if(jobs[tid] == JOBS_1) 
    { 
     jobs1(); 
     jobs[tid] = 0; // go back to idle state 
     pthread_mutex_lock(&th_mutex);  
      pthread_mutex_lock(&m_mutex); 
      --busyThreads;      // one less worker 
      pthread_cond_signal(&m_cond);  // signal main to check progress 
      pthread_mutex_unlock(&m_mutex); 
     pthread_cond_wait(&th_cond, &th_mutex); // wait for next job 
     pthread_mutex_unlock(&th_mutex);  
    } 
    if(jobs[tid] == JOBS_2) 
    { 
     jobs2(); 
     jobs[tid] = 0; // go back to idle state 
     pthread_mutex_lock(&th_mutex); 
     --busyThreads; 
     pthread_cond_wait(&th_cond, &th_mutex); 
     pthread_mutex_unlock(&th_mutex); 
    } 
    } 

    pthread_exit(NULL); 
} 

然後在主：

int main() 
{ 
    sem_init(&semaphore, 0, 0); 
    jobs[0...MAX_THREADS] = 0; 
    spawn_threads(); 

    // Dispatch first job 
    jobs[0...MAX_THREADS] = JOBS_1; 
    int semvalue = 0; 

    pthread_mutex_lock(&m_mutex); 
    while(busyThreads > 0)  // check number of active workers 
     pthread_cond_wait(&m_cond, &m_mutex); 
    pthread_mutex_unlock(&m_mutex); 

    busyThreads = MAX_THREADS; 
    pthread_mutex_lock(&th_mutex); 
    pthread_cond_broadcast(&th_cond); // signal all workers to resume 
    pthread_mutex_unlock(&th_mutex); 

    // same for JOBS_2; 

    jobs[0...MAX_THREADS] = -1; // No more jobs 
    pthread_join(); 
}