[Java] programmazione distribuita e concorrenza

[nazkul]

Ciao! sto realizzando un progetto con algoritmi distribuiti, e mi sono sorti dei dubbi per quanto concerne i concetti di concorrenza locale.
Il progetto riguarda l'implementazione di una memoria distribuita, dove per esempio possiamo avere 3 nodi, ognuno con la copia esatta dell'intera memoria non appena siamo in uno stato di quiete, cioè senza operazioni di inserimento e cancellazione o altre che siano in corso.

Un algoritmo distribuito mi serve per acquisire il permesso di accedere alla memoria (il ruolo di mutex), e poi un secondo algoritmo per lavorare sulla memoria e segnalare quando è finita l'operazione per poter far accedere alla memoria altri nodi rilasciando il mutex.

Il mio progetto a grandi linee è strutturato così:

La classe con il main lancia un certo numero di thread che sarà pari al numero dei componenti che voglio nel sistema.

La classe a cui appartengono questi thread è la classe che crea tutto il sistema invocando costruttori di vari oggetti, è fatta di oggetti come:
la memoria, gli algoritmi distribuiti, il gestore della comunicazione con gli altri nodi, il nodo ecc...

La classe dei nodi mette a disposizione tutte le funzioni per lavorare sulla memoria, cerca valore, inserisci, cancella ecc..

La mia difficoltà sta nel capire se nelle classi che rappresentano il cuore del progetto, cioè la memoria, i nodi, gli algoritmi distribuiti, la classe dei thread, devo utilizzare comunque i costrutti della programmazione concorrente oppure no.
All'origine infatti abbiamo dei thread, che innescano un meccanismo di continui scambi di messaggi invocando metodi di oggetti dei quali tali classi hanno dei riferimenti, mi viene quindi da pensare che se si devono applicare principi di concorrenza, questi va a finire che si tramandano di classe in classe essendo tutte collegate dai riferimenti che l'una ha delle altre e quindi di dover usare semafori un po da tutte le parti.
Non a caso nelle specifiche del progetto è detto chiaramente che le operazioni sulla memoria devono essere thread-safe.
Allo stesso tempo però mi viene da pensare che gli algoritmi distribuiti dovrebbero diciamo sequenzializzare già di suo quelle operazioni che porterebbero a inconsistenza, presumendo ovviamente che tali algoritmi siano stati scritti correttamente.

Si tratta di un concetto un po' ampio, che coinvolge tutto il progetto e che quindi mi rendo conto che non è facile rendere l'idea della situazione, spero di aver dato una spiegazione sufficientemente esauriente a chi mi vuole
gentilmente dare qualche consiglio.

Grazie