Osserviamo alcune altre differenze tra Thread e Runnable con l'aiuto del grafico di confronto mostrato di seguito:
Grafico comparativo
| Base per il confronto | Filo | Runnable |
|---|---|---|
| Di base | Ogni thread crea un oggetto unico e viene associato ad esso. | Più thread condividono gli stessi oggetti. |
| Memoria | Poiché ogni thread crea un oggetto unico, è necessaria più memoria. | Poiché più thread condividono lo stesso oggetto, viene utilizzata meno memoria. |
| Estensione | In Java, l'ereditarietà multipla non è consentita, quindi, dopo che una classe estende la classe Thread, non può estendere alcuna altra classe. | Se una classe definisce thread che implementa l'interfaccia Runnable ha la possibilità di estendere una classe. |
| Uso | Un utente deve estendere la classe thread solo se vuole sovrascrivere gli altri metodi nella classe Thread. | Se vuoi solo specializzare il metodo run allora implementare Runnable è un'opzione migliore. |
| accoppiamento | L'estensione della classe Thread introduce un accoppiamento stretto poiché la classe contiene il codice della classe Thread e anche il lavoro assegnato alla discussione | L'implementazione dell'interfaccia Runnable introduce l'accoppiamento libero poiché il codice di Thread è separato dal lavoro di Threads. |
Definizione della classe Thread
Thread è una classe nel pacchetto java.lang . La classe Thread estende una classe Object e implementa interfacce Runnable . La classe Thread ha costruttori e metodi per creare e operare sul thread. Quando creiamo più thread, ogni thread crea un oggetto univoco e viene associato a tale oggetto. Se si crea una discussione che estende la classe Thread, non è possibile estendere un'altra classe poiché java non supporta l'ereditarietà multipla. Pertanto, si dovrebbe scegliere di estendere la classe Thread solo quando si desidera sovrascrivere anche altri metodi della classe Thread. Vediamo un esempio di creazione di un thread che estende una classe Thread.
/ * Definizione di un thread * / Classe Mythread estende Thread {/ * job del thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Thread figlio") ); }} Class mainThread {/ * job of main thread * / public static void main (String args []) {Mythread mt = new Mythread (); / * main thread ha creato il thread secondario * / mt.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Output * / Main Discussione Main Discussione Main Discussione Main Discussione Child Discussione Child Discussione Child Discussione Child Discussione Child Thread Main Discussione Child Discussione Main Discussione Main Discussione Child Thread Child Discussione Main Discussione Main Discussione Child Discussione Child Thread Main Discussione Nel codice sopra, creo una classe Mythread che estende la classe Thread e sovrascrive un metodo run della classe Thread. Nella classe che contiene il metodo principale, creo un oggetto thread (mt) della classe Mythread e utilizzo l'oggetto thread invocato il metodo start (). Il metodo start avvia l'esecuzione del thread e allo stesso tempo JVM richiama il metodo run del thread. Ora ci sono due thread nel programma un thread principale e un secondo secondario creato dal thread principale. L'esecuzione di entrambi i thread avviene contemporaneamente, ma l'output esatto non può essere preteso.
Definizione di Runnable Interface
Runnable è un'interfaccia nel pacchetto java.lang . Implementando l'interfaccia Runnable possiamo definire un thread. L'interfaccia eseguibile ha un singolo metodo run (), che viene implementato dalla classe che implementa l'interfaccia Runnable. Quando scegli di definire thread che implementa un'interfaccia Runnable hai ancora la possibilità di estendere qualsiasi altra classe. Quando crei più thread implementando l'interfaccia Runnable, ogni thread condivide la stessa istanza eseguibile. impariamo come definire un thread usando l'interfaccia Runnable.
/ * Definizione di un thread * / Classe Runnablethread implementa Runnable {/ * job del thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Thread figlio") ); }} Class mainThread {/ * job of main thread * / public static void main (String args []) {Mythread rt = new Mythread (); / * main thread ha creato l'oggetto runnable * / Thread t = new Thread (rt); / * main thread crea un thread secondario e passa l'oggetto runnable * / t.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Output * / Main Discussione Main Discussione Main Discussione Main Discussione Child Discussione Child Discussione Child Discussione Child Discussione Child Thread Main Discussione Child Discussione Main Discussione Main Discussione Child Thread Child Discussione Main Discussione Main Discussione Child Discussione Child Thread Main Discussione Nel codice sopra, ho creato una classe Runnablethread che implementa l'interfaccia Runnable e definisce il lavoro del thread implementando il metodo run () dell'interfaccia Runnable. Quindi creo un mainthread di classe contenente il metodo principale. All'interno del metodo principale, ho dichiarato un oggetto runnable della classe Runnablethread e ho passato questo oggetto al costruttore del Thread mentre dichiaro un thread. In questo modo, ho collegato l'oggetto thread (t) con un oggetto runnable (rt). Quindi l'oggetto thread richiama il metodo start del thread che richiama ulteriormente il metodo run della classe Runnablethread. Se non avessi collegato l'oggetto runnable con l'oggetto Thread, il metodo di avvio dei thread avrebbe richiamato il metodo run della classe Thread. Ora, di nuovo ci sono due thread nel codice, il thread principale e il thread principale crea il thread figlio entrambi vengono eseguiti simultaneamente ma l'output esatto non può mai essere preteso.
Differenze chiave tra thread e eseguibili in Java
- Ogni thread creato estendendo la classe Thread crea un oggetto univoco per esso e viene associato a tale oggetto. D'altra parte, ogni thread creato implementando un'interfaccia Runnable condivide la stessa istanza eseguibile.
- Poiché ogni thread è associato a un oggetto univoco quando viene creato estendendo la classe Thread, è necessaria più memoria. D'altra parte, ogni thread creato implementando l'interfaccia Runnable condivide lo stesso spazio oggetti, quindi richiede meno memoria.
- Se si estende ulteriormente la classe Thread, è possibile ereditare qualsiasi altra classe poiché Java non consente l'ereditarietà multipla mentre, implementando Runnable, è ancora possibile che una classe erediti un'altra classe.
- È necessario estendere una classe Thread solo se deve eseguire l'override o specializzare altri metodi della classe Thread. È necessario implementare un'interfaccia Runnable se si desidera solo specializzare solo il metodo run.
- L'estensione della classe Thread introduce un accoppiamento stretto nel codice poiché il codice di Thread e il lavoro del thread sono contenuti nella stessa classe. D'altra parte, l'interfaccia Runnable Implementing introduce un accoppiamento libero nel codice poiché il codice di Thread è separato dal lavoro assegnato al thread.
Conclusione:
È preferibile implementare un'interfaccia Runnable invece di estendere la classe Thread. Poiché l'implementazione di Runnable rende il codice liberamente accoppiato poiché il codice del thread è diverso dalla classe che assegna il lavoro al thread. Richiede meno memoria e consente a una classe di ereditare qualsiasi altra classe.
