동기화 할 다른 방법이 있습니까

Question

스레드가 브로드 캐스트 신호를 수신 할 준비가되었는지 확인하는 다른 방법이 있습니까? 나는 main에서 Sleep (1) 함수를 대체하고 싶다.

#include <iostream> 
#include <pthread.h> 

#define NUM 4 


using namespace std; 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 
pthread_t tid[NUM]; 


void *threads(void *arg){ 
    int tid = (int)arg; 
    while(true){ 
     pthread_mutex_lock(&mutex); 
     pthread_cond_wait(&cond,&mutex); 
     //do some work 
     cout<<"Thread: "<<tid<<endl;; 
     pthread_mutex_unlock(&mutex); 
    } 
} 

int main(){ 

    for(int i=0;i<NUM;i++){ 
     pthread_create(&tid[i],NULL,threads,(void*)i); 
    } 

    Sleep(1); 
    pthread_cond_broadcast(&cond); 

    Sleep(1); 
    pthread_cond_broadcast(&cond); 

    Sleep(1); 
    pthread_cond_broadcast(&cond); 

    return 0; 
} 

내가는 pthread_cond_wait 전에 메모리 장벽을 시도하고 나는 카운터를 사용하여 생각,하지만 아무것도 아직 나를 위해 일하지 않는다.

Answer 1

조건 변수는 일반적으로 술어에 연결됩니다. 다른 스레드에서는 술어가 이미 충족되었는지 (술어를 보호하는 mutex를 보유하는 동안 점검하십시오.) 점검하고, 그렇다면 조건 변수를 기다리지 마십시오. main에서 뮤텍스를 얻고 뮤텍스를 잡고 술어를 변경하십시오. 그런 다음 뮤텍스와 신호 또는 방송을 해제하십시오. 여기 Synchronisation before pthread_cond_broadcast

몇 가지 예제 코드입니다 :

#include <iostream> 
#include <pthread.h> 
#include <unistd.h> 

#include <cassert> 

#define NUM 4 
#define SIZE 256 


using std::cout; 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 
pthread_t tid[NUM]; 

int work_available; 

void *threads(void *arg) 
{ 
    int tid = *((int*)arg); 
    while (1) { 
     pthread_mutex_lock(&mutex); 
     while (work_available == 0) { 
      // While loop since cond_wait can have spurious wakeups.                                                                               
      pthread_cond_wait(&cond, &mutex); 
      cout << "Worker " << tid << " woke up...\n"; 
      cout << "Work available: " << work_available << '\n'; 
     } 
     if (work_available == -1) { 
      cout << "Worker " << tid << " quitting\n"; 
      pthread_mutex_unlock(&mutex); // Easy to forget, better to use C++11 RAII mutexes.                                                                        
      break; 
     } 
     assert(work_available > 0); 
     work_available--; 
     cout << "Worker " << tid << " took one item of work\n"; 
     pthread_mutex_unlock(&mutex); 

     //do some work                                                                                          
     sleep(2); // simulated work                                                                                       
     pthread_mutex_lock(&mutex); 
     cout << "Worker " << tid << " done with one item of work.\n"; 
     pthread_mutex_unlock(&mutex); 
    } 
} 


int main() 
{ 
    work_available = 0; 

    int args[NUM]; 
    for (int i=0; i<NUM; i++) { 
     args[i] = i; 
     pthread_create(&tid[i], NULL, threads, (void*)&args[i]); 
    } 

    const int MAX_TIME = 10; 
    for (int i = 0; i < MAX_TIME; i++) 
    { 
     pthread_mutex_lock(&mutex); 
     work_available++; 
     cout << "Main thread, work available: " << work_available << '\n'; 
     pthread_mutex_unlock(&mutex); 
     pthread_cond_broadcast(&cond); 
     sleep(1); 
    } 

    pthread_mutex_lock(&mutex); 
    cout << "Main signalling threads to quit\n"; 
    work_available = -1; 
    pthread_mutex_unlock(&mutex); 
    pthread_cond_broadcast(&cond); 

    for (int i = 0; i < NUM; i++) 
    { 
     pthread_join(tid[i], NULL); 

    } 
    return 0; 
}