producator_consumator.cpp

生产者－消费者模式的OpenMP下的实现。已经调试通过

// problema producator consumator




#include "stdafx.h"
#include <omp.h>
#include <stdio.h>
#include <windows.h> 

#define Nr      5


// varianta in care un singur producator acceseaza la un mom dat si mai multi cititori pot fii activi concomitent
int main(){
	int data,nrP,nrC,nthreads;
	// data este variabila partajata care se va modifica/ citi de catre thread-uri
	int tid,i,tip;
	int first;
	omp_lock_t lockP;

	omp_init_lock(&lockP);
	omp_set_num_threads(4);
			nrP=1;
			nrC=0;
			data=0;
			first=1;
	//omp_in_parallel();
	//omp_set_dynamic(20);
	

#pragma omp parallel  shared(data,nrP,nrC) private(tid,i,tip) firstprivate(first) 
  // regiunea paralela accesata de toate thread-urile
  // variabila first ne spune daca threadul acceseaza pt prima data zona si afiseaza un mesaj ca thread-ul isi incepe executia
	
		if(first==1){
					tid=omp_get_thread_num();
					first=0;
										
						nthreads = omp_get_num_threads();
						printf("Number of threads = %d\n", nthreads);
						
					  printf("Thread %d starting...\n", tid);
					  		
					  tip= tid % 2;
		}
		  //if(tid==0) Sleep(2000);
		  //else 
		for(i=0;i<=Nr;i++){
				if(tip==0){   // producator
							omp_set_lock(&lockP);
							// un singur thread la un moment dat 
					
							printf("Thread %d producator  . \n",tid);
							
							while(nrC>0){
								nrP=1;
								Sleep(1000);
								printf("thread producator astept %d",tid);
							}
							data= data + i;
							printf("Data dupa ce a scris %d= %d \n",tid,data);
							Sleep(1000);
							nrP=0;
							omp_unset_lock(&lockP);
				}
			   else{  // consumator
					printf("Thread %d consumator . \n",tid);
					while(nrP>0){
						// daca sunt producatori astept
						Sleep(1000);
						printf("Thread %d consumator astept. \n",tid);
					}
					nrC++;
					// pot fii mai multi producatori la un moment dat 
					printf("Thread %d citeste %d. \n",tid, data);
					Sleep(1000);
					nrC--;
					}
					}
}
}


Varianta 2

/*
int main ()  {

int nthreads, tid;
float datele[50];
int c,p;
omp_lock_t lockP, lockC;


omp_init_lock(&lockP);
omp_init_lock(&lockC);
 omp_set_num_threads(10 );

#pragma omp parallel shared(c,p, datele, nthreads, locka, lockb) private(tid)
  {

 
  tid = omp_get_thread_num();
  #pragma omp master
    {
    nthreads = omp_get_num_threads();
    printf("Number of threads = %d\n", nthreads);
	p=0;
	c=0;
    }
  printf("Thread %d starting...\n", tid);
  #pragma omp barrier

  #pragma omp sections nowait
    {
    #pragma omp section
      {
      printf("Thread %d producator. \n",tid);
      omp_set_lock(&lockP);
   
     // omp_unset_lock(&lockP);
     // omp_set_lock(&lockC);
      p= p+1;
	  
	  while (p==c){
		  //omp_unset_lock(&lockC);
		  //omp_set_lock(&lockP);
		  Sleep(1);
		  // astepata eliberarea unui loc 
		  
	  }
	  
	  if (p > N)
		  p=1;
		// buffer circular pentru date 
	  omp_unset_lock(&lockP);
      omp_set_lock(&lockC);
	  datele[p]=(float) tid ;
	  printf("Thread %d scriu %d la pozitie %d \n",tid,datele[p],p);
	  
      omp_unset_lock(&lockC);
      }

    #pragma omp section
      {
      printf("Thread %d consumator. \n",tid);
	  printf("Thread %d producator. \n",tid);
      omp_set_lock(&lockP);
   
     // omp_unset_lock(&lockP);
     // omp_set_lock(&lockC);
      p= p+1;
	  
	  while (p==c){
		  //omp_unset_lock(&lockC);
		  //omp_set_lock(&lockP);
		  Sleep(1);
		  // astepata eliberarea unui loc 
		  
	  }
	  
	  if (p > N)
		  p=1;
		// buffer circular pentru date 
	  omp_unset_lock(&lockP);
      omp_set_lock(&lockC);
	  datele[p]=(float) tid ;
	  printf("Thread %d scriu %d la pozitie %d \n",tid,datele[p],p);
	  
      omp_unset_lock(&lockC);
      omp_set_lock(&lockC);
      
      omp_unset_lock(&lockC);
      omp_set_lock(&lockP);
      c=c+1;
	  while(c==p){
		  omp_unset_lock(&lockP);
		  omp_set_lock(&lockC);
	  }
      
	  if (c>N)
		  c=1;
	  printf("THread %d citesc val= %d de la poz %d \n",tid,datele[c],c);

      omp_unset_lock(&lockP);
      }
    }  
  }  

  return 0;
}