[JAVA]Monitorare i thread lanciati da una servlet

[PuNkEtTaRo]

Ciao a tutti ragazzi,
sto scrivendo una servlet che, ad ogni chiamata del metodo doGet, lancia un thread più o meno in questo modo:
String host = request.getParameter("host");
int depth = Integer.parseInt(request.getParameter("depth"));
long lapse = Long.parseLong(request.getParameter("lapse"));

new Thread(new Traverse(host, depth, lapse)).start();
Il thread in questione entrerà in un loop dove farà periodicamente quello che deve fare.
Il mio problema ora è come stoppare i singoli thread che verranno lanciati e come monitorarli ovvero, io voglio sapere in ogni momento quanti e quali sono i thread running (lanciati dal doGet ovviamente) ed avere la possibilità di fermarli.
Qualcuno ha qualche idea?

Grazie in anticipo

[nuovoUtente86]

Ti basta tenerne riferimento in una struttura dati. Quanto all' interrompibilità, dipende da cosa c'è scritto nel metodo run, ovvero se hai previsto la verifica periodica di un flag di interruzione.

[PuNkEtTaRo]

Ti basta tenerne riferimento in una struttura dati. Quanto all' interrompibilità, dipende da cosa c'è scritto nel metodo run, ovvero se hai previsto la verifica periodica di un flag di interruzione.
Ed in che modo ne tengo il riferimento? Dovrei chiamare ogni thread in un modo diverso...
Nel metodo run avevo previsto un flag che settato su false interrompesse il while in modo da terminare il thread.
Il mio problema è semplicemente come tener traccia di tutti i thread avviati. Magari se potessi farmi un esempio mi saresti di grande aiuto. Per quanto riguarda la struttura dati non ci sono problemi.
Grazie

Ciao

[nuovoUtente86]

QualsiasiStrutturaDati listaThread= new QualsiasiStrutturaDati();
per ogni thread lanciato
listaThread.add (new Thread(....));

[banryu79]

Se hai in ballo questioni di scalabilità prova a dare un'occhiata al package java.util.concurrent

Vedendo ogni singola Traverse come un task da eseguire, puoi appoggiarti ad un Executor a cui passare ogni nuovo task creato per l'esecuzione.
In pratica passeresti dallo scrivere:

(new Thread(t)).start();
// dove 't' è un Traverse "travestito" da Runnable.

a:

e.execute(r);
// dove 'e' è un Executor.

Traverse, il tuo task, diventa l'implementazione di un Runnable (se Traverse non ritorna niente ne lancia eccezioni che ti interessa catturare; altrimenti l'alternativa è Callable) da passare all'Executor per l'esecuzione.

Volendo c'è anche l'interfaccia ExecutorService (la specifica implementazione dell'ExecutorService che si sceglie definisce le politiche di creazione e gestione dei thread per l'esecuzione dei task) che, dato il task da mandare in esecuzione, restituisce l'oggetto Future che ne rappresenta il futuro risultato (cosa che ti permette di gestirne lo stato, ad esempio richiedere la cancellazione dell'esecuzione del task):

Future<?> t = es.submit(r);
// dove 'es' è l'ExecutorService scelto, e 't' è il Future per il task 'r' passato in ingresso.


Tutto questo ovviamente aumenta la quantità & complessità del tuo codice, per cui il gioco vale la candela solo se i task da mandare in esecuzione possono anche essere tanti, per cui l'ExecutoService può diventare utile per questioni di scalabilità.

Puoi cominciare a leggere qualcosa qui (http://java.sun.com/docs/books/tutorial/essential/concurrency/exinter.html).

[PuNkEtTaRo]

Se hai in ballo questioni di scalabilità prova a dare un'occhiata al package java.util.concurrent

Vedendo ogni singola Traverse come un task da eseguire, puoi appoggiarti ad un Executor a cui passare ogni nuovo task creato per l'esecuzione.
CUT
Sei stato veramente gentile ed esauriente, appena torno a casa mi fiondo a documentarmi sugli Executor!
Grazie

Ciao

[banryu79]

appena torno a casa mi fiondo a documentarmi sugli Executor!

Ti posto qualche risorsa online che potresti trovare interessante da esaminare:

- Ovviamente il capitolo dedicato al multithreading (http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html) presente nel compendio "The Really Big Index" dei Java Tutorial;
- I javadoc (informazioni sparse sulle varie classi e interfacce) del package java.util.concurrent; (in particolare: Callable, Future, RunnableFuture, FutureTask, Executor, ExecutorService, ThreadFactory, ThreadPoolExecutor, Executors);
- Questo tutorial [2004] della IBM (https://www6.software.ibm.com/developerworks/education/j-concur/index.html) (è neccessario registrarsi per accedere ai tutorial);
- Questo tutorial, estratto dal testo "Java - How to program" (http://www.deitel.com/articles/java_tutorials/20051126/JavaMultithreading_Tutorial_Part1.html) edito dalla Deitel (che però non ho letto).