Java e Thread

[JavaFurbix]

Salve a tutti volevo delle delucidazioni sull'uso dei thread, non riesco a capire certi meccanismi :

facciamo un esempio pratico :


io simulo un browser ovvero mi scrivo il mio codice con cui posso fare delle richieste attraverso un URL :


Ho una classe chiamata HTTPCLIENT che ha due metodi : getRequest, postRequest.

il metodo getRequest accetta un parametro, l'URL.

Il metodo postRequest contiene due parametri, l'URL e la stringa "post" .

Ora volendo usare i thread, voglio che la mia applicazione, può inviare diverse connessioni (getRequest e postRequest) in "parallelo"...

come strutturare questa classe??

Vado in difficoltà perchè il metodo run non accetta parametri.

In più ho il probelma che i metodi getRequest e postRequest, restituiscono una stringa che altro non è che l'html della nuova pagina.. usando i thread invocando il metodo Thread.start() non posso farmi ritornare più la string "html" .. Come agire?

// PROVIAMO A FARE UN ESEMPIO SEMPLIFICATO : 

public class HttpClient
{

   public HttpClient()
   {
   }

   public static String getRequest(URL url)
  {
    //codice
    return html;
  }

  public static String postRequest(Url url, String post)
  {
   //codice
   return html;
  }
} 

Come faccio ad integrare i thread in una situazione del genere dovendo ricevere un parametro e restituire un valore??

Tenendo presente che entrambi i metodi devono poter essere invocati in parallelo e che entrambi ritornano un valore?

Mi manda in confusione che nel metodo run non posso passare paramentri e ne posso fare :

tmp = thread.start(); 

quando restituisco il valore..

Help me!

[andbin]

Originariamente inviato da JavaFurbix
Vado in difficoltà perchè il metodo run non accetta parametri.

Il run() di Runnable ovviamente no. La signature deve restare quella dettata da Runnable.
Ma tu devi implementare Runnable (o tecnicamente estendere Thread ma è meno consigliato), in un modo o nell'altro (con una classe normale, inner class, ecc...) e nessuno ti vieta (e anzi ... è questo l'approccio da seguire) di passare al costruttore della TuaClasseCheImplementaRunnable tutti i dati che vuoi che saranno poi usati nel run().

Originariamente inviato da JavaFurbix
In più ho il probelma che i metodi getRequest e postRequest, restituiscono una stringa che altro non è che l'html della nuova pagina.. usando i thread invocando il metodo Thread.start() non posso farmi ritornare più la string "html" .. Come agire?

Anche qui, ovviamente no. start() si limita solo a far andare il thread nello stato di "runnable". Non aspetta e non restituisce un bel nulla.
Ma ora la questione è: vuoi attendere tu la terminazione del thread e prendere in qualche modo i dati? O vuoi che sia il thread a notificare "qualcuno"?

Perché o fai es.:

t.start();
....
....
t.join();  // attendo la fine
... = mioRunnable.getRisultato();

Così sarebbe un approccio "sincrono".

Oppure passi al tuo runnable (sempre nel costruttore come detto sopra) un riferimento ad un oggetto e qui ci si basa generalmente sulle interfacce, es. una interfaccia RicevitoreRisultato.
Tu implementi questa interfaccia altrove e il thread appena ha terminato il suo lavoro può invocare su questo oggetto un metodo es. lavoroCompletato(....) passando ciò che serve.
E questo è un approccio "asincrono".

[JavaFurbix]

ciao andbin,

Ti aspettavo con ansia, sei preparatissimo e ti stimo perchè metti sempre a disposizione la tua conoscenza...


Io studio dai libri di horstmann in particolare (core java2 VolumeI e VolumeII traduzione in italiano settiman edizione anche se è uscita l'8 non ancora tradotta).

A volte alcuni passaggi sono ostici e non riesco a comprenderli a pieno...


Questa volta non ho ben capito neanche il tuo suggerimento...


cerco di esprimermi con esempi cosi forse riesco a passarti ciò che ho appreso e ciò che non mi è chiaro :

public class HttpClient implements Runnable
{
 private URL url;
 private String post;

 public HTTPClient()
 {}

  public HttpClient(URL url,String post)
  {
    this.url= url;
    this.post=post;
  }

   public HttpClient(URL url)
   {
     HttpClient(url,null);
   }

   public String getRequest()
  {
    //codice    
    // url è membro interno della classe
    return html;
  }

  public String postRequest()
  {
   //codice
   // url è membro interno della classe
  // post è membro interno della classe
  }


  // inserisco dei metodi get e set per modificare e leggere sia la variabile post
 // che la variabile url .


 public URL getUrl();
 {
   return this.url;
 }


 public void setUrl(URL url)
 {
    this.url = url;
 }

 public String getPost()
 {
   return this.post;
 }

 public void setPost(String post)
 {
   this.post = post;
 }


 // Ora viene il bello, nel metodo run che "baiocco" :bhò:   :spy: scrivo?? 
 // c'è da considera che io non so se l'utente avrà bisogno di un metodo getRequest() o postRequest()

//quindi come scrivo il metodo run ?? 

// in più non ho capito ancora il discorso per ritornare dei valori .... 

} 

Il main diciamo sarà più o meno così

public class Test
{
 public static void main(String[] args)

 HttpClient Client = new HttpClient();
 Client.setUrl("esempio");

 Thread uno = new Thread(Client);
 uno.start(); 

 //ora uno.start() dovrebbe aver invocato uno dei due metodi: getRequest o postRequest 
 // e a fine esecuzione di quel metodi, l'html che viene ritornato non so come recuperarlo 
  // in quanto una volta terminato il thread muore  :( 


} 

Illuminami, grazie!


@Quote, piccola correzione i metodi ora non sono più statici dovendo cmq istanziare la classe HttpClient

[JavaFurbix]

Mi sembra di capire che una classe deve essere specializzata nel fare una sola cosa per volta per usare i thread, cioè nello specifico per usare i thread...

Tipo la mai classe HttpClient ha due funzionalità, un metodo getRequest e un metodo postRequest.

Da quel che ho capito fino a quì nel mio metodo run non potrà mai poter scegliere quale metodo invocare.. Quindi come ho strutturato io la classe non và bene...

andbin sto sbagliando tutto ??

Hai suggerimenti su dove studiare i thread in java (possibilimente in italiano), purtroppo dal mio libro alcune cose non riesco a recepirle. E in più non sono trattati tutti i casi come quello dei parametri e dei valori di ritorno :-( ...

Sono un pò sfiduciato ora

[desa]

"Sfiduciato"... ma figurati!
La programmazione concorrente con i thread è una cosa complessa: per dirti, in università avevo fatto un esame solo su questo argomento! E' normale avere delle difficoltà agli inizi!

Quasi sempre quando programmi non esiste una cosa "giusta" o una cosa "sbagliata": ci sono tante possibili soluzioni, alcune delle quali più pratiche, altre più efficienti... uno dei compiti più complessi è infatti riuscire ad identificare la migliore, che solitamente è in realtà il "miglior compromesso".

La struttura della tua classe è sensata: GET e POST sono sicuramente due cose diverse, ma a mio parere (per l'utilizzo che ne fai) presentano dei tratti in comune per cui è ragionevole racchiuderle insieme.
Secondo me la soluzione più pratica per te è passare al thread in fase di costruzione (o anche tramite un metodo "set") un parametro booleano che verrà valutato dal metodo run(): se true invocherà la GET, se false invocherà la POST. O viceversa, naturalmente.

Soluzione un pochino più complessa, è definire un metodo astratto sendRequest() nella classe HttpClient (che sarà astratta a sua volta) che verrà ridefinito con le operazioni da eseguire in due sottoclassi GetHttpClient e PostHttpClient.

Prova a pensarci un po'!

[JavaFurbix]

Originariamente inviato da desa
"Sfiduciato"... ma figurati!
La programmazione concorrente con i thread è una cosa complessa: per dirti, in università avevo fatto un esame solo su questo argomento! E' normale avere delle difficoltà agli inizi!

Quasi sempre quando programmi non esiste una cosa "giusta" o una cosa "sbagliata": ci sono tante possibili soluzioni, alcune delle quali più pratiche, altre più efficienti... uno dei compiti più complessi è infatti riuscire ad identificare la migliore, che solitamente è in realtà il "miglior compromesso".

La struttura della tua classe è sensata: GET e POST sono sicuramente due cose diverse, ma a mio parere (per l'utilizzo che ne fai) presentano dei tratti in comune per cui è ragionevole racchiuderle insieme.
Secondo me la soluzione più pratica per te è passare al thread in fase di costruzione (o anche tramite un metodo "set") un parametro booleano che verrà valutato dal metodo run(): se true invocherà la GET, se false invocherà la POST. O viceversa, naturalmente.

Soluzione un pochino più complessa, è definire un metodo astratto sendRequest() nella classe HttpClient (che sarà astratta a sua volta) che verrà ridefinito con le operazioni da eseguire in due sottoclassi GetHttpClient e PostHttpClient.

Prova a pensarci un po'!

Grazie, la tua idea non è male... Cmq ho parlato con il mio prof. Purtroppo da me i thread nella laurea triennale non si fanno se non per in un corso a scelta, ma io ne ho scelti altri più interessanti, aspettando la specialistica... Ma intanto scrivo qualcosina, cerco di imparare.

Per quanto riguarda il booleano non è una cattiva idea ma in una visione futura, non sarebbe scalabile... (Parlandone con il prof di programmazione distribuita) ... In quanto se in un futuro dovrò creare altri metodi per assurdo put o cmq altri, non ci sarebbe il modo di farlo in maniera semplice... Magari quindi usare delle costanti (quindi un int) per verificare che metodo chiamare...... Ho un idea più chiara ora, però rimango completamente inibito nella situazione di dover ritornare qualcosa (come l'html) nei miei metodi. Non so usare ancora nulla, notifica, attesa di thread e nulla.... Sul libro sembra molto veloce e semplificato il discorso.Non affronta casi in cui passare e ritornare parametri etc....

Ma come mai ?

Sono un pò triste, cioè se delle cose non puoi impararle dai libri che ci fan da maestri a casa... Dove impararle ??? Ci rimango male davvero quand'è così perchè tutta la voglia che ho viene frenata in maniera drastica da questi muri

[desa]

Penso che tu sia stato sfortunato con il libro che stai consultando.
I Thread (in termini accademici) sono un argomento avanzato di java, quindi molto probabilmente in un manuale base ne troverai solo un accenno... oppure non li troverai proprio. Perchè non fai un giro nella tua biblioteca universitaria - o nel reparto manualistica di una libreria (magari con suggerimenti del tuo prof) e consulti i libri che hanno a disposizione? Magari ne trovi uno che fa al caso tuo.
Io sulla programmazione concorrente avevo questo qui:
http://www.doc.ic.ac.uk/~jnm/book/
ma (ai tempi) era in inglese ed un po' caro... se ne hai la possibilità ti conviene consultarlo piuttosto che - eventualmente - comprarlo "alla cieca".
In Rete è fatto molto bene il tutorial sul sito della Sun:
http://java.sun.com/docs/books/tutor...l/concurrency/
Ma, anche qua, è in inglese... come te la cavi?

Per la scalabilità usare un int va benissimo: i metodi HTTP sono 8, se non ricordo male, basta che assegni una costante ad ognuno.

Per il passaggio di parametri... dipende cosa vuoi fare: una soluzione potrebbe essere salvare l'HTML ritornato in una variabile di HttpClient, ad esempio...

[JavaFurbix]

L'idea di mettere una variabile istanza di HttpClient come ad esempio
private String html, con relativo metodo getHtml(); non è male

Però.....


A volte guardo anche l'efficienza anche se mi sa che è il metodo più veloce.

Sono interessato anche ad altre soluzioni , quali altre conoscete?

andbin accennava ad una notifica da inviare, ma non ho ben capito .....




Ps: uso i libri di horstmann (core java 2 volumeI e volumeII) che non sono affatto male anzi non so se c'è di meglio. L'unica cosa è che sui thread e il passaggio/ritorno di valori o sono cieco io o non ho trovato nulla in particolare... Forse per assurdo li tratta più avanti in quanto il capitolo sui thread è molto lungo ma prima di arrivare a quel punto introduce tutta una serie di meccanismi complessi, io preferisco andare per grado e piano piano.

Rimango in attesa,

Grazie!