[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 ):

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/luomora...javabase#timer

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