[Java] Thread , semplice domanda

[Gin&&Tonic]

Sto studiando i Thread (in Java) , e per capirli meglio sto provando su eclipse delle classi fornite dal mio prof.nelle esercitazioni.

Finora nessun problema , ma non capisco perché nel main , prima di inizializzare
oggetti Thread "da lui creati" , inserisce sempre un: while(true){...//istruzioni....}

Riporto sotto il codice per farvi capire meglio:

public class ContoCorrente1Test {
public static void main(String args[]) {
int depositoIniziale = 100000;
int numCorrentisti = 200;
int importo = 100; // prelevato o depositato ad ogni operazione
int numOperazioni = 5000; // numero di operazioni effettuate

//QUESTO WHILE (TRUE), A COSA SERVE?
while (true) {
ContoCorrente1 cc = new ContoCorrente1(depositoIniziale);
System.out.println("Deposito iniziale = " + depositoIniziale);
Correntista v[] = new Correntista[numCorrentisti];
for (int i = 0; i < numCorrentisti; i++) {
v[i] = new Correntista(i, cc, importo, numOperazioni);
}
for (int i = 0; i < numCorrentisti; i++) {
v[i].start();
}
try {
for (int i = 0; i < numCorrentisti; i++) {
v[i].join();
}
} catch (InterruptedException e) {
System.err.println(e);
}
int depositoFinale = cc.getDeposito();
System.out.print("\nDeposito finale = " + depositoFinale);
if (depositoFinale != depositoIniziale) {
System.out.println(" [***** ERRORE! *****]");
}
System.out.println();
}
}
}

Le classi e l'interfaccia create (prima di eseguire il main) sono queste:

public interface ContoCorrente {
public void deposita(int importo);
public void preleva(int importo);
public int getDeposito();
}
__________________

public class Correntista extends Thread {
private int id;
private ContoCorrente cc;
private int importo;
private int numOperazioni; // deve essere un numero pari
public Correntista(int id, ContoCorrente cc, int importo, int
numOperazioni) {
this.id = id;
this.cc = cc;
this.importo = importo;
this.numOperazioni = numOperazioni;
}
private void attesaCasuale() {
int attesa = (int) (Math.random() * 3); // tra 0 e 2msec
try {
sleep(attesa);
} catch (InterruptedException e) {
System.err.println(e);
}
}

public void run() {
for (int i = 0; i < numOperazioni; i++) {
attesaCasuale();
if (i % 2 == 0) {
cc.deposita(importo);
} else {
cc.preleva(importo);
}
}
System.out.println("Correntista " + id
+ " ha terminato le sue operazioni.");
}
}
_________________________

import java.util.concurrent.atomic.AtomicInteger;
public class ContoCorrente1 implements ContoCorrente {
private AtomicInteger deposito;
public ContoCorrente1(int depositoIniziale) {
deposito = new AtomicInteger(depositoIniziale);
}
public void deposita(int importo) {
deposito.addAndGet(importo);
}
public void preleva(int importo) {
deposito.addAndGet(-importo);
}
public int getDeposito() {
return deposito.get();
}
}


Quel : While(true) non provoca un ciclo infinito? A cosa serve?

[PGI-Bis]

L'effetto del while è esattamente quello che percepisci: esegue all'infinito quel test.

Ipotizzo che la ripetizione sia stata messa per evidenziare come un ordine pseudocasuale di esecuzione dei singoli compiti da parte dei molti thread non influisca sul risultato finale se il programma sia correttamente scritto.

Circa il fatto che il ciclo sia infinito, direi che sia stato messo per brevità: un abbozzo di programma da linea di comando avrebbe richiesto quantomeno una conferma della volontà dell'utente di ripetere il test ma nel contesto dell'esercizio probabilmente non avrebbe neanche avuto senso.

Come esercizio non è che sia esattamente il massimo perchè il suo funzionamento dipende da un certo numero di particolarità, tra cui una sincronizzazione implicita imposta da una specifica norma del modello di memoria del linguaggio di programmazione java di cui, e ci scommetto un baffo, nulla vi è stato detto. Ho perso il baffo?

[Gin&&Tonic]

No non lo hai perso ma ne hai guadagnato uno :D :D

comunque guardando meglio la classe ContoCorrente1 del prof , mi sono accorto che lui non usa variabili atomiche ,AtomicInteger in questo caso, ma usa int, ed in questo modo : depositoFinale è diverso da depositoIniziale.