[java] Thread

[filipss]

Ciao a tutti,
ho un bel problema....vorrei scrivere un metodo che una volta invocato restituisca il suo risultato dopo un certo tempo t senza però fermare l'esecuzione (del main) del programma per il tempo t.
Ho provato con sleep(t) ma il programma si ferma completamente e trascroso t riprende l'esecuzione...

Grazie
Ciao;)

[banryu79]

Ciao,
c'è anche un'interfaccia grafica, oppure il tuo programma non ne ha nessuna e gira sotto consolle?

[filipss]

ciao, grazie per avermi risposto:)

il programma gira sotto console

[pernacentus]

Ciao, forse non ho capito bene il tuo problema. Per restituisca il risultato intendi che lo stampi a video o lo ritorni attraverso una return?

[filipss]

Ciao :) ,
il metodo fa delle operazioni e alla fine stampa.

Ciao

[banryu79]

Arieccomi.

Ecco un esempio un po' farlocco (però con sintax highlighting :D ):

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureExample
{
public static void main(String... args) {
FutureExample application = new FutureExample();
application.start();
}

private void start() {
System.out.println("MainThread> application started.");

ExecutorService executor = Executors.newSingleThreadExecutor();
MyProcess myProcess = new MyProcess();
System.out.println("MainThread> myProcess created.");

System.out.println("MainThread> launching myProcess.");
FutureTask<String> future = new FutureTask<String>(myProcess);
executor.execute(future);

// MainThread attende il risultato e nel frattempo può fare altro...
while (! future.isDone()) {
System.out.println("MainThread> waiting for myProcess termination...");
try {
Thread.sleep(500);
} catch (InterruptedException ignored) {}
}
executor.shutdown();

try {
System.out.println("MainThread> retrive myProcess result.");
String result = future.get();
System.out.println("MainThread> myProcess say: \"" + result + "\"");
} catch (InterruptedException ex) {
System.out.println("MainThread> Ops... we have got an InterruptedException.");
} catch (ExecutionException ex) {
System.out.println("MainThread> Ops... we have got an ExecutionException.");
}

System.out.println("MainThread> application terminated.");
}

// MyProcess dorme per 6 secondi e mezzo circa e poi si degna di fare qualcosa, restituendo un messaggio
private class MyProcess implements Callable<String>
{
@Override
public String call() throws Exception {
System.out.println("MyProcess> TASK STARTED.");
try {
Thread.sleep(6500);
} catch (InterruptedException ignored) {}
String message = "GODDAMNIT, I AM LAZY!";

System.out.println("MyProcess> TASK COMPLETED.");
return message;
}
}

}

Se lo mandi in esecuzione dovrebbe produrre un output simile a questo:

MainThread> application started.
MainThread> myProcess created.
MainThread> launching myProcess.
MainThread> waiting for myProcess termination...
MyProcess> TASK STARTED.
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MainThread> waiting for myProcess termination...
MyProcess> TASK COMPLETED.
MainThread> retrive myProcess result.
MainThread> myProcess say: "GODDAMNIT, I AM LAZY!"
MainThread> application terminated.

In pratica si tratta di usare il package java.util.concurrent per creare un Callable, impachettarlo dentro un Future e schedularlo per l'esecuzione passandolo ad un Executor.

Callable in pratica è un Runnable, che in più ha la capacità di restituire un valore(oggetto) al termine della computazione.
Astrae questa capacità nel metodo call. Callable è parametrico, e il tipo parametrizzato rappresenta il tipo del valore(oggetto) restituito.
Nel nostro caso Callable<String> perchè ho voluto rappresentare un task che alla fine restituisce appunto una String.

Future rappresenta il risultato e lo stato finali di una computazione (ma non la computazione stessa). Nel nostro caso rappresenta il risultato e lo stato finali dell'esecuzione di MyProcess, il nostro Callable. Future è un'interfaccia, e nel codice ho usato FutureTask, una implementazione già fornita da java.util.concurrent, che "unisce" i concetti di risultato finale di una computazione (Future) e la computazione stessa che produce un risutato, ancora da eseguirsi (Callable).

Il FutureTask viene mandato in esecuzione asincrona passandolo al metodo execute di un Executor:

executor.execute(future);


Il thread principale resta così libero di fare altro, finchè l'esecuzione del task non è finita:

while (! future.isDone()) {
// fai altro
}


Se non si vuole fare niente finchè non si ha il risultato (perchè ad esempio si possono schedulare per l'esecuzione più task in contemporanea, e si vuole procede solo dopo aver ottenuto tutti i risultati dei task) si può chiamare direttamente il metodo get del Future, che è bloccante (blocca il thread chiamante finchè l'esecuzione del Future non è terminata):

String result = future.get();

[nuovoUtente86]

Ti serve un Thread indipendente dal main. Eventualmente, dovrai badare a sincronizzarli.

[lovaz]

Vedi se questo esempio fa per te:

http://sites.google.com/site/luomoradioattivo/javabase#timer

solo che devi usare il metodo schedule con parametri
( this, millisecondi )
in cui chiaramente sostituisci "millisecondi" con il tempo che devi attendere