Newsgroup: it.comp.os.linux.development
Titolo: Richiesta di aiuto su semafori e thread!!!

Avrei bisogno di aiuto su come implementare i semafori e le condizioni di
mutex in un processo che chiama più thread: sto svolgendo un esercizio in
cui si "simulano" delle operazioni bancarie su dei conti correnti. I conti
correnti sono visti come un array di interi, nel quale nell'elemento i
dell'array (cioè il conto corrente numero i) è indicata la somma disponibile
per quell'elemento (cioè quel conto corrente).
Le operazioni di prelievo, versamento e trasferimento di una certa somma da
un conto all'altro sono implementate attraverso i pthread, ma bisogna anche
fare in modo che le operazioni siano effettuate in mutua esclusione. Questo
dovrebbe venir fatto grazie all'uso di semafori sem_t, di mutex
pthread_mutex_t e di variabili di condizione pthread_cond_t.
Avendo già in qualche modo realizzato la parte riguardante i thread, avrei
bisogno di aiuto per quanto riguarda invece la parte sulla mutua eslcusione.
Eventualmente sarei disposto anche a fornire il codice su cui sto lavorando
e alcune documentazioni...
Grazie in anticipo.
Enrico (
enri...@libero.it
)

 pthread_mutex_t e di variabili di condizione pthread_cond_t.
Cosa c'e' che non va in pthread_mutex_lock(&mutex) e 
pthread_mutex_unlock(&mutex) ?
consiglio 
http://www.humanfactor.com/pthreads/
http://www.faqs.org/faqs/unix-faq/programmer/faq/
http://www.tldp.org/
HappyCactus perplesso.
-- 
HappyCactus - Linux User #209744 - LFS User #6046 - >>> SMSPM950 <<<
 
Ci sono 10 categorie di persone al mondo: quelle che capiscono
il sistema binario e quelle che non lo capiscono.

 eslcusione.
Semplificando al massimo potrebbe bastare una singola mutex:
pthread_mutex_t account_lock = PTHREAD_MUTEX_INITIALIZER;
void *thread(void *arg) {
        ....
        pthread_mutex_lock(&account_lock);
        modifica_conto(i);
        pthread_mutex_unlock(&account_lock);
        ....
}
Il  problema e`  che  il  lock unico  impone  una serializzazione  degli
accessi  non solo  sul  singolo conto,  ma su  tutti  i conti. In  altre
parole, se  stai modificando il conto  1, non puoi accedere  al conto 2.
Per migliorare la situazione puoi utilizzare un lock per ogni conto:
#define N_ACCOUNT 100
int conti[N_ACCOUNT];
pthread_mutex_t account_lock[N_ACCOUNT];
void *thread(void *arg) {
        ....
        pthread_mutex_lock(&account_lock[i]);
        modifica_conto(i);
        pthread_mutex_unlock(&account_lock[i]);
        ....
}
In  questo modo  puoi  agire  su piu`  conti  diversi in  contemporanea.
Volendo migliorare (o complicare)  ancora puoi utilizzare un rwlock. Con
questi  puoi, ad  esempio,  permettere letture  simultanee dello  stesso
conto. I rwlock sono presenti nei pthread, ma non sono documentati:
pthread_rwlock_t lock;
int pthread_rwlock_init (pthread_rwlock_t *restrict rwlock,
                  const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy (pthread_rwlock_t *rwlock);
int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock (pthread_rwlock_t *rwlock);
I nomi sono  abbastanza intuitivi, ma se hai  bisogno chiarimenti chiedi
pure.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"L'ottimista pensa che questo sia il migliore dei mondi possibili. 
 Il pessimista sa che e` vero" -- J. Robert Oppenheimer