Newsgroup: it.comp.os.linux.development
Titolo: sincronizzazione di thread in condizioni di carico pesante della CPU

Ciao,
devo sincronizzare due thread (T1 e T2) in questo modo: T1 fa alcune
operazioni e nel frattempo T2 aspetta, poi T2 fa alcune operazioni e T1
aspetta ... e cosě via.
Ho implementato il codice con pthread_mutex_lock + pthread_cond_wait +
pthread_cond_signal + pthread_mutex_unlock.
T1 incrementa un contatore e fa alcune operazioni pesanti per la CPU, mentre
T2 č bloccato. T2 fa lo stesso.
Bene: se dopo le rispettive operazioni entrambi i thread aspettano un tempo
maggiore o uguale ad 1 secondo ( usleep(1000000) nel codice) il tutto
funziona.
Se invece l'usleep č di 1000 usecondi ad esempio (o se č assente), il
sincronismo funziona male e il valore restituito da pthread_cond_wait
risulta errato.
Devo aggiungere estensioni real time al codice per risolvere il problema?
grazie per ogni eventuale aiuto,
Luca
---------------------------------------------------------------------------------------------------------------
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <iostream>
#include <pthread.h>
pthread_mutex_t my_mutex;
pthread_cond_t my_condition;
bool condizione=false;
int shared_counter = 0;
void* routineT1(void* obj)
{
	while(1)
 	{
		int a = pthread_mutex_lock(&my_mutex);
		int b = 145; //dummy default
		while(condizione) b = pthread_cond_wait(&my_condition, &my_mutex);
		if(shared_counter < 10) shared_counter ++;
		else shared_counter = 1;
		std::cerr<< "\n T1: I do my job ( I increment the counter:
"<<shared_counter<<" ) and T2 waits";
		//some dummy and HEAVY work
		for(int q = 0; q< 10000000; q++)
		{
			q = q + 1;
			q--;
			int f = q-2;
			f++;
		}
		usleep(1000000);
		condizione = true;
		int c = pthread_cond_signal(&my_condition);
		int d = pthread_mutex_unlock(&my_mutex);
		std::cerr<<"\n T1: mutex_lock ,cond_wait ,cond_signal , mutex_unlock:
"<<a<<","<<b<<","<<c<<","<<d;
	}
};
void* routineT2(void* obj)
{
	while(1)
	{
		int a = pthread_mutex_lock(&my_mutex);
		int b = 146; //dummy default
		while(!condizione) b = pthread_cond_wait(&my_condition, &my_mutex);
		std::cerr<< "\n T2: I do my job ( I read the counter: "<<shared_counter<<" )
and T1 waits ";
		//some dummy and HEAVY work
		for(int q = 0; q< 10000000; q++)
		{
			q = q + 1;
			q--;
			int f = q-2;
			f++;
		}
		usleep(1000000);
		condizione = false;
		int c = pthread_cond_signal(&my_condition);
		int d = pthread_mutex_unlock(&my_mutex);
		std::cerr<<"\n T2: mutex_lock ,cond_wait ,cond_signal , mutex_unlock:
"<<a<<","<<b<<","<<c<<","<<d;
		std::cerr<<"\n *";
		std::cerr<<"\n *";
	}
};
int main(int argc, char *argv[])
{
  pthread_t* tt1 = new pthread_t;
  pthread_t* tt2 = new pthread_t;
  pthread_mutex_init(&my_mutex,NULL);
  pthread_cond_init(&my_condition,NULL);
  pthread_create(tt1,NULL,routineT1,NULL);
  sleep(1);
  pthread_create(tt2,NULL,routineT2,NULL);
  while(1);
}
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 };
Devi usare due pthread_cont_t, una per segnalare la necessità di fare
girare il thread 1 ed una per il thread 2 (o magari riesci ad ingegnarti
con 1 sola, ma con 2 distinte è IHMO più chiaro).
Luca
-- 
"Fare l'amore con dieci donne e` fantastico, soprattutto perche` ti
 presentano un sacco di amiche." -- Fabio Di Iorio

 risulta errato.
Una delle possibili soluzioni č dotare anche my_condition di un mutex 
separato da quello che utilizzi per il thread.
In questo modo la variabile condizionale dovrebbe restituire sempre il 
valore corretto.