[Java] Un piccolo aiuto sull'utilizzo dei threads

[Player1]

Ciao a tutti.
Supponiamo di avere una classe chiamata miaclasse con 2 metodi (metodo1 e metodo2).

Quando viene eseguito metodo1 questo compie alcune operazioni, richiama metodo2 e poi restituisce un booleano.

Ora il problema è che vorrei che metodo1 restituisse il booleano senza attendere che metodo2 termini l'esecuzione ho quindi pensato di utilizzare i thread.

Per farlo ho aggiunto alla definizione di miaclasse "implements Runnable".

Poi all'interno di metodo1, nel punto in cui richiama metodo2 ho inserito

miaclasse r = new miaclasse();
Thread t = new Thread(r);

ed ora.. ?
Come faccio a richiamare "metodo2" sul thread t?
Nella guida ho visto che va inserito il metodo run ma io non voglio rinominare metodo2 con run perchè in realtà ci sono differenti metodi e voglio poter scegliere quale metodo fare eseguire al thread, come posso fare?
Grazie!

[banryu79]

Quando viene eseguito metodo1 questo compie alcune operazioni, richiama metodo2 e poi restituisce un booleano.

Ora il problema è che vorrei che metodo1 restituisse il booleano senza attendere che metodo2 termini l'esecuzione ho quindi pensato di utilizzare i thread.

Ciao.
Innanzitutto bisogna verificare se il primo thread che esegue metodo1 e il secondo thread che vorresti eseguisse metodo2 condividono dati mutabili o no.

Nel caso non li condividano, la questione si riduce al fatto di istanziare un Runnable la cui implementazione del metodo run altro non sia che l'esecuzione di una chiamata a metodo2 (oppure all'esecuzione delle istruzioni che si trovano nel corpo di metodo2)

Nel caso ci siano dati mutabili condivisi tra i due thread, bisogna sincronizzare l'accesso a tali dati onde evitare race-conditions e altre bizzarie.

Per il primo caso l'esempio sarebbe:

class MyClass
{
public boolean metodo1() {
... istruzioni varie...

Runnable invokeMethod = new Runnable() {
public void run() {
metodo2();
}
};
Thread t = new Thread(invokeMethod);
t.start();

...altrre istruzioni o meno...

// bFlag è un boolean
return bFlag
}
}

[Player1]

Grazie per l'aiuto, è più o meno quello che cercavo.. ma ho ancora un piccolo problema.
Vorrei anche inviare dei parametri ad invokeMethod come posso fare?
Non è necessaria una vera e propria sincronizzazione poiché metodo1 calcola i parametri PRIMA di avviare il nuovo thread t e non accede più questi dati. Il tread t accede ai dati solo in lettura, dunque non possono sorgere problemi di sincronizzazione.

Ecco l'esempio di ciò che vorrei fare.


class MyClass
{
public boolean metodo1() {
... istruzioni varie...
//CALCOLO int parametro1; ed int parametro2;
NB:D'ora in avanti non accederò più alle due variabili ne in lettura che in scrittura
Runnable invokeMethod = new Runnable() {
public void run() {
metodo2(parametro1,parametro2);
}
};
Thread t = new Thread(invokeMethod);
t.start();

...altrre istruzioni o meno...

// bFlag è un boolean
return bFlag
}
}

Come posso realizzarlo in pratica?

[banryu79]

...
Vorrei anche inviare dei parametri ad invokeMethod come posso fare?
Non è necessaria una vera e propria sincronizzazione poiché metodo1 calcola i parametri PRIMA di avviare il nuovo thread t e non accede più questi dati. Il tread t accede ai dati solo in lettura, dunque non possono sorgere problemi di sincronizzazione.
...

In questo caso è sufficiente che dichiari param1 e param2 come final e li passi alla chiamata a metodo2 eseguita nel run del Runnable, come nel codice che hai postato.

Di che tipo sono param1 e parm2? Sono tipi primitivi o sono reference?

[Player1]

Purtroppo il mio problema è proprio questo, non riesco a dichiararle final perchè se faccio così:


class MyClass
{
public boolean metodo1() {
... istruzioni varie...
final int parametro1;
final String parametro2;
if (..){
parametro1=100; //ERRORE: Non posso assegnare un valore ad una variabile final
parametro2="cento";
}
Runnable invokeMethod = new Runnable() {
public void run() {
metodo2(parametro1,parametro2);
}
};
Thread t = new Thread(invokeMethod);
t.start();

...altrre istruzioni o meno...

// bFlag è un boolean
return bFlag
}
}

Se invece faccio così:

class MyClass
{
public boolean metodo1() {
... istruzioni varie...
if (..){
final int parametro1=100;
final String parametro2="cento";
}
Runnable invokeMethod = new Runnable() {
public void run() {
metodo2(parametro1,parametro2); // ERRORE: i due parametri sono stati definiti all'interno dell'if quindi non posso vederli
}
};
Thread t = new Thread(invokeMethod);
t.start();

...altrre istruzioni o meno...

// bFlag è un boolean
return bFlag
}
}

I due parametri sono un int e una String.. ma può darsi che qualche metodo successivo ne richieda di tipo diverso..

Grazie per l'aiuto.

[banryu79]

Allora non devi istanziare Runnable come classe anonima, ma ne devi definire un'implementazione, magari come classe annidata della tua classe principale.
In questo modo puoi dotare l'implemetnazione di Runnable di due membri interni che puoi inizializzare tramite un costruttore, e che userai come argomenti nella chiamata a metodo2 che si trova nell'implemetazione del medoto run.

Esempio:

class MyClass
{
public boolean metodo1() {
//... istruzioni varie ...

//... calcolo param1 e param2 ...
String string = "abcd";
int param1 = 10;
int param2 = 20;

InvokeMethod2 invoker = new InvokeMethod2(string, param1, param2);
Thread t = new Thread(invoker);
t.start();

//...altrre istruzioni o meno...

// bFlag è un boolean
return bFlag;
}

public void metodo2(String s, int m, int n) {
// ...
}

private class InvokeMethod2 implements Runnable
{
private final String S;
private final int PARAM_1;
private final int PARAM_2;

InvokeMethod2(String s, int p1, int p2) {
S = s;
PARAM_1 = p1;
PARAM_2 = p2;
}

@Override public void run() {
metodo2(S, PARAM_1, PARAM_2);
}
}

}

Nota1: il fatto che i membri di InvokeMethod2 siano dichiarati come final non è insidpensabile.
java.lang.String è immutabile, e il passaggio dei parametri ai metodi in Java è SEMPRE per valore, dunque quando passi p1 e p2 al costruttore di InvokeMethod2 e poi, di nuovo, a metodo2, vengono create delle copie locali.
Ciò significa che anche se ne riassegni il valore in quei contesti, le variabili "originarie" param1 e param2 nel contesto di metodo1 non vengono mutate.

[Player1]

Ok, ho appena finito di provare seguendo il tuo esempio, funziona perfettamente!
Grazie infinite!