Newsgroup: it.comp.lang.c++
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
)

Ciao,
Questo newsgroup si occupa del linguaggio C++ in quanto tale, e non di
aspetti specifici di particolari implementazioni. Per questo non e' il
posto piu' adatto per porre domande specifiche come la tua.
Potresti avere piu' fortuna su uno dei seguenti gruppi:
Per Win32 (95, 98, NT): it.comp.programmare.win32
Per Dos/Win 3.x: it.comp.os.dos
Per Linux:      it.comp.os.linux.development
Per C++Builder: i gruppi borland.public.cppbuilder.*, disponibili sul
                server 
newsgroups.borland.com
 (prevalentemente in 
                inglese, ma si puo' postare anche in italiano)
Grazie,
Nicola Musatti


Prova a dare un occhio alla implementazione c++ del Mutex e della Guard
di ACE.
http://doc.ece.uci.edu/Doxygen/Stable/html/ace/hierarchy.html
In sintesi Mutex e' una classe che aquisisce un semaforo (ha il metodo
lock).
La mutex-guard ha un costruttore che prende un *Mutex e chiama il metodo
lock del mutex.
Nel distruttore chiama il metodo unlock del mutex.
Quindi puoi proteggere la sezione critica che inizia dalla chiamata a
MutexGuard guard(&mutex_);
fino alla fine della funzione.
La classe Mutex e' sistema-operativo-dipendente te la devi scrivere tu.
Nota: spesso bisogna proteggere un metodo di una classe, a me e'
capitato di proteggere il metodo instance di un singleton. Per fare
questo devi dichiarare uno
static Mutex mutex_;
nella classe (singleton).
Mi spiego:
--- h
class Singleton
{
// le solite cose del singleton
static Mutex mutex_;
};
--- cpp
Singleton* Singleton::instance()
{
    if (instance_==NULL)
    {
        MutexGuard  guard(&mutex_);
        //Double Check
        if (instance_==NULL)
            instance_= new Singleton();
    }
    return instance_;
}
Quidi potresti proteggere l'accesso al tuo array con una classe (magari
singleton con un mutex statico)
;)
(occhio a non farti sviare dal mio esempio: non tutti i singleton hanno
bisogno di un mutex nel metodo instance, io ho dovuto metterlo perche'
ho ridefinito la new. Il tuo mutex serve a proteggere il tuo array).
Home-page di ACE: 
http://www.cs.wustl.edu/~schmidt/ACE.html
Ciao
Cesare