Contenuto

• Tabella di comparazione
• Definizione della classe di thread
• Definizione di interfaccia eseguibile
• Differenze chiave tra Thread e Runnable in Java
• Conclusione:

Un thread può essere definito in due modi. Primo, di estendere una classe Thread che ha già implementato un'interfaccia Runnable. In secondo luogo, direttamente implementazione di un'interfaccia Runnable. Quando si definisce un thread estendendo la classe Thread, è necessario sovrascrivere il metodo run () nella classe Thread. Quando si definisce un thread che implementa un'interfaccia Runnable, è necessario implementare l'unico metodo run () dell'interfaccia Runnable. La differenza di base tra Thread e Runnable è che ogni thread definito estendendo la classe Thread crea un oggetto unico e viene associato a quell'oggetto. D'altra parte, ogni thread definito implementando l'interfaccia Runnable condivide lo stesso oggetto.

Osserviamo alcune altre differenze tra Thread e Runnable con l'aiuto della tabella di confronto mostrata di seguito:

1. Tabella di comparazione
2. Definizione
3. Differenze chiave
4. Conclusione

Tabella di comparazione

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 altre classi.	Se una classe definisce un thread che implementa l'interfaccia Runnable, ha la possibilità di estendere una classe.
Uso	Un utente deve estendere la classe thread solo se desidera sovrascrivere gli altri metodi nella classe thread.	Se vuoi solo specializzare il metodo run, l'implementazione di 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 al thread	L'implementazione dell'interfaccia Runnable introduce un accoppiamento libero poiché il codice di Thread è separato dal lavoro di Thread.

Definizione della classe di thread

Filo è una classe in java.lang pacchetto. La classe Thread estende un Oggetto classe e implementa Runnable interfacce. La classe Thread ha costruttori e metodi per creare e operare sul thread. Quando creiamo più thread, ogni thread crea un oggetto unico e ci associa a quell'oggetto. Se si crea un thread che estende la classe Thread, inoltre non è possibile estendere qualsiasi altra classe poiché java non supporta l'ereditarietà multipla. Quindi, dovresti scegliere di estendere la classe Thread solo quando vuoi anche sovrascrivere alcuni altri metodi della classe Thread. Vediamo un esempio di creazione di un thread che estende una classe Thread.

/ * Definizione di un thread * / Class Mythread estende il thread {/ * processo del thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Discussione figlio" ); }} Class mainThread {/ * job del thread principale * / public static void main (String args) {Mythread mt = new Mythread (); / * il thread principale ha creato il thread figlio * / mt.start (); per (int i = 0; i <10; i ++) {System.Out. ("Discussione principale"); }}} / * Uscita * / Filetto principale Filetto principale Filetto principale Filetto principale Filetto secondario Filetto secondario Filetto secondario Filetto secondario Filetto secondario Filetto secondario Filetto principale Filetto secondario Filetto principale Filetto secondario Filetto secondario Filetto principale Filetto secondario Filetto secondario Filetto secondario Filetto principale

Nel codice sopra, creo una classe Mythread che estende la classe Thread e sovrascrive un metodo run della classe Thread. Nella classe contenente il metodo principale creo un oggetto thread (mt) della classe Mythread e usando l'oggetto thread ho invocato il metodo start (). Il metodo start avvia l'esecuzione del thread e allo stesso tempo JVM invoca il metodo run del thread. Ora ci sono due thread nel programma, un thread principale e un secondo thread figlio creati dal thread principale. L'esecuzione di entrambi i thread avviene contemporaneamente, ma non è possibile pretendere l'output esatto.

Definizione di interfaccia eseguibile

Runnable è un'interfaccia in java.lang pacchetto. Implementando l'interfaccia Runnable possiamo definire un thread. L'interfaccia eseguibile ha un solo metodo correre(), che è implementato dalla classe che implementa l'interfaccia Runnable. Quando scegli di definire il thread che implementa un'interfaccia Runnable hai ancora la possibilità di estendere qualsiasi altra classe. Quando si creano più thread implementando l'interfaccia Runnable, ogni thread condivide la stessa istanza eseguibile. impariamo a definire un thread usando l'interfaccia Runnable.

/ * Definizione di un thread * / Class Runnablethread implementa Runnable {/ * job del thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Discussione figlio" ); }} Class mainThread {/ * job del thread principale * / public static void main (String args) {Mythread rt = new Mythread (); / * il thread principale ha creato l'oggetto eseguibile * / Thread t = new Thread (rt); / * thread principale crea thread figlio e passa l'oggetto eseguibile * / t.start (); per (int i = 0; i <10; i ++) {System.Out. ("Discussione principale"); }}} / * Uscita * / Filetto principale Filetto principale Filetto principale Filetto principale Filetto secondario Filetto secondario Filetto secondario Filetto secondario Filetto secondario Filetto secondario Filetto principale Filetto secondario Filetto principale Filetto secondario Filetto secondario Filetto principale Filetto secondario Filetto secondario Filetto secondario Filetto principale

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 eseguibile della classe Runnablethread e ho passato questo oggetto al costruttore del thread mentre dichiaravo un thread. In questo modo, ho collegato l'oggetto thread (t) con un oggetto eseguibile (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 eseguibile con l'oggetto Thread, il metodo di avvio dei thread avrebbe invocato il metodo di esecuzione della classe Thread. Ora, di nuovo ci sono due thread nel codice, il thread principale e il thread principale creano thread secondari entrambi eseguiti simultaneamente ma non si può mai pretendere un output esatto.

Differenze chiave tra Thread e Runnable in Java

1. 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.
2. 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.
3. Se estendi ulteriormente la classe Thread, puoi ereditare qualsiasi altra classe poiché Java non consente l'ereditarietà multipla, mentre l'implementazione di Runnable offre comunque la possibilità a una classe di ereditare qualsiasi altra classe.
4. Uno deve estendere una classe Thread solo se deve sovrascrivere o specializzare alcuni altri metodi della classe Thread. È necessario implementare un'interfaccia Runnable se si desidera specializzare solo il metodo run.
5. L'estensione della classe Thread introduce un accoppiamento stretto nel codice poiché il codice del thread e il processo del thread sono contenuti nella stessa classe. D'altra parte, l'interfaccia di Implementazione Runnable introduce un accoppiamento libero nel codice poiché il codice di Thread è separato dal lavoro assegnato al thread.

Conclusione:

Si preferisce implementare un'interfaccia Runnable invece di estendere la classe Thread. Poiché l'implementazione di Runnable rende il codice liberamente accoppiato in quanto il codice del thread è diverso dalla classe che assegna il lavoro al thread. Richiede meno memoria e consente inoltre a una classe di ereditare qualsiasi altra classe.