[JAVA]Aiuto per programmino sul multithreading!

[neosephiroth86]

Salve! Stò realizzando un programmino che mi permetta di mostrare l'utilità del multithreading in java.
Sostanzialmente viene passato in input una stringa che rappresenta una serie di operazioni algebriche del tipo:
(1+2)-(3+4) o anche (1+2)+(3+4)*(10/5)+(3+2)

Ho creato quattro classi,che rappresentano le 4 operazioni ammesse,cioè somma,sottrazione,divisione e moltiplicazione,ognunca col proprio metodo run(). Dalla classe principale,algoritmo, da cui i vari token vengono estratti viene gestito il lancio dei thread.
Prendiamo per esempio il primo esempio di sopra,nella mia visione avviene sostanzialmente questo:
Alla prima iterazione vengono lanciati due thread,uno della somma di 1 e 2,uno della somma di 3 e 4.Entrambi i thread saranno istanze della classe Somma. Alla iterazione successiva viene effettuata la sottrazione tra il risultato di 1+2 e 3-4. Nell'altro esempio alla prima iterazioni ci saranno 4 thread creati,nell'iterazione successiva due e alla fine verrà restituito il risultato.
Il problema adesso è che nella mia realizzazione non riesco a far comunicare il contenuto del metodo run() dei thread con la classe Algoritmo da cui li richiamo.Per la precisione ogni classe che rappresenta le operazioni ha come attributo il suo risultato,solo che da Algoritmo non riesco ad usare il metodo .getSomma() (nel caso della somma) perchè non ho instanziato la classe Somma ma ho avviato semplicemente il suo thread con le istruzioni

Thread somma=new Thread(new Somma(primo,secondo));
somma.start();


Come posso fare? Vi allego il codice su cui stò lavorando..

import java.util.*;

public class Algoritmo {

private Vector vettore;

public void calcola(Vector vettore){

Vector v= new Vector();

for(int i=0;i<=vettore.size()-1;i=i+4){

int primo=Integer.parseInt((String)vettore.elementAt(i));
int secondo=Integer.parseInt((String)vettore.elementAt(i+2));
String operando=new String((String)vettore.elementAt(i+1));

if(operando.equals("+")){

Thread somma=new Thread(new Somma(primo,secondo));
somma.start();

v.addElement(somma.somma()+"");
}

if(operando.equals("-")){

Thread sottrazione=new Thread(new Sottrazione(primo,secondo));
sottrazione.start();




//Sottrazione sottrazione=new Sottrazione(primo,secondo);
//sottrazione.run();

// v.addElement(sottrazione.getSottrazione()+"");
}

if(operando.equals("*")){



Moltiplicazione moltiplicazione=new Moltiplicazione(primo,secondo);
moltiplicazione.run();

// v.addElement(moltiplicazione.getMoltiplicazione()+"");
}

if(operando.equals("/")){




Divisione divisione=new Divisione(primo,secondo);
divisione.run();

//v.addElement(divisione.getDivisione()+"");
}


if(vettore.size()>i+3){
String operando_fra_parentesi=new String((String)vettore.elementAt(i+3));
v.addElement(operando_fra_parentesi);


}

}



if(v.size()>2){calcola(v);}
else{System.out.println(v.elementAt(0));}


}

}



public class Somma implements Runnable{
private int numero1;
private int numero2;
static int somma;

public int getSomma() {
return somma;
}

public void setSomma(int somma) {
this.somma = somma;
}

public Somma(int primo,int secondo){
numero1=primo;
numero2=secondo;
}

public void run(){
somma=numero1+numero2;
try {
System.out.println("Aspetto");
Thread.sleep(50000);
System.out.println("riparto");

} catch (InterruptedException e) {
System.out.println("Thread somma bloccato.");
}


}

}


public class Sottrazione implements Runnable{
private int numero1;
private int numero2;
private int sottrazione;

public int getSottrazione() {
return sottrazione;
}

public void setSottrazione(int sottrazione) {
this.sottrazione = sottrazione;
}

public Sottrazione(int primo,int secondo){
numero1=primo;
numero2=secondo;
}

public void run(){
sottrazione=numero1-numero2;

try {
System.out.println("Aspetto");
Thread.sleep(5000);

} catch (InterruptedException e) {
System.out.println("Thread somma bloccato.");
}





}

}

Le altre due(moltiplicazione e divisione) sono uguali a parte l'operazione effettuata.

UPDATE: Per ora l'unica soluzione è quella di dichiarami un campo statico in Algoritmo,del tipo
static int risultato;

e impostarne il valore da dentro il corpo run() del thread con
Algoritmo.risultato=somma; (nel caso della somma).


C'è qualche altro modo?Non vorrei usare campi statici...

[yorkeiser]

Scusa, ma perchè scrivi 4 classi praticamente identiche per le 4 operazioni?
Non ti conviene scriverne una sola, passargli il tipo di operazione da compiere nel costruttore (ad esempio, un intero da 1 a 4) e in base a quello mettero uno switch per fare l'operazione?

[neosephiroth86]

si ma il professore m'ha detto che a lui piacerebbe cosi..anche perchè poi ci devo cacciare un diagramma unl delle classe ed esteticamente sarebbe + attraente,poi il fatto di avere 4 classi con 4 thread ha un valore didattico,cioè nel prosieguo del progetto devo mettere i Thread.currentThread per far vedere i thread in esecuzione,i thread.sleep() e poi devo fare una realizzazione del progetto anche senza thread ma completamente sequenziale,in modo da far vedere le differenze.

Comunque il nocciolo del problema è questo:
Come posso accedere ad un attibuto della classe di un thread se questo è definito cosi dalla classe da cui lo devo riprendere

Thread somma=new Thread(new Somma(primo,secondo));
somma.start();


somma.somma (ipotizzando l'attributo public) o somma.getSomma() non funzionano...facendo somma. in eclispe escono tutti metodi di Thread,non di somma!

[banryu79]

somma.somma (ipotizzando l'attributo public) o somma.getSomma() non funzionano...facendo somma. in eclispe escono tutti metodi di Thread,non di somma!

Questo perchè 'somma' è un'istanza di Thread, e la definizione della classe Thread non comprende nessun metodo getSomma.

Il metodo getSomma l'hai definito nella classe Somma, che implementa Runnable.
Una possibilità è quella di definire le tue classi Somma, Sottrazione etc.. non come implementazioni di Runnable ma come estensioni di Thread.

Tipo così:

class Somma extends Thread
{
...
public int getSomma() {...}
public void run() {...}
...
}


P.S.: belli comunque questi prof...

[neosephiroth86]

Ciao!
Sono arrivato anche io ad una soluzione usando Runnable..
cosa ne pensate?

if(operando.equals("+")){
Somma test=new Somma(primo,secondo);
Thread somma=new Thread(test);
somma.start();
test.getSomma();
//v.addElement(somma.somma()+"");
}

[nuovoUtente86]

prima di chiamare il getSomma(), devi invocare somma.join(), in modo da avere la garanzia che l' operazione sia stata conclusa quando il dato viene restituito.

[neosephiroth86]

ok grazie del suggerimento!