Să observăm câteva alte diferențe între Thread și Runnable cu ajutorul diagramei de comparație de mai jos:
Diagramă de comparație
| Bazele comparației | Fir | runnable |
|---|---|---|
| De bază | Fiecare fir creează un obiect unic și devine asociat cu acesta. | Firele multiple au aceleași obiecte. |
| Memorie | Pe măsură ce fiecare fir creează un obiect unic, este necesară mai multă memorie. | Întrucât firele multiple partajează același obiect, se utilizează mai puțin memorie. |
| Extinderea | În Java, moștenirea multiplă nu este permisă prin urmare, după ce o clasă extinde clasa Thread, nu poate extinde nici o altă clasă. | Dacă o clasă definește firul care implementează interfața Runnable, are șansa de a extinde o clasă. |
| Utilizare | Un utilizator trebuie să extindă clasa thread numai dacă dorește să suprascrie alte metode din clasa Thread. | Dacă doriți doar să se specializeze metoda de rulare atunci implementarea Runnable este o opțiune mai bună. |
| Cuplare | Extinderea Clasa Thread introduce un cuplaj strâns, deoarece clasa conține codul de clasă Thread și, de asemenea, lucrarea atribuită firului | Implementarea interfeței Runnable introduce cuplarea loose deoarece codul Thread este separat de sarcina thread-urilor. |
Definiția Thread Class
Thread este o clasă în pachetul java.lang . Clasa Thread extinde o clasă Object și implementează interfețe Runnable . Clasa Thread are constructori și metode de creare și operare pe fir. Când creăm mai multe fire, fiecare fir creează un obiect unic și se asociază cu acel obiect. Dacă creați un thread care extinde clasa Thread, nu mai puteți extinde nici o altă clasă, deoarece java nu suportă mai multe moșteniri. Deci, ar trebui să alegeți să extindeți clasa Thread numai atunci când doriți, de asemenea, să înlocuiți alte metode de clasă Thread. Să vedem un exemplu de creare a unui fir care să extindă o clasă Thread.
/ * Definirea unui thread * / Clasa Mythread extinde Thread {/ * job of thread * / public void run () {pentru (int i = 0; i <10; i ++) {System.Out.Println ); }} Clasa mainThread {/ * jobul principal al firului * / public static void principal (String args []) {Mythread mt = new Mythread (); / * firul principal a creat firul copil * / mt.start (); pentru (int i = 0; i <10; i ++) {System.Out.Print ("Subiectul principal"); }}} / * Iesire * / filet principal Filet principal Filet principal Filet Copii Filet Copii Thread Copii File Copil File Copil Filet Principal File Copil Filet Principal Filet Copii Filet Copii Filet Principal Filet Principal Thread Copii File Copii Filet Principal În codul de mai sus, creez o clasă Mythread care extinde clasa Thread și suprascrie o metodă de rulare a clasei Thread. În clasa care conține metoda principală, creez un obiect thread (mt) din clasa Mythread și folosind obiectul thread invocat de metoda start (). Metoda de pornire începe executarea firului și, în același timp, JVM invocă metoda de rulare a firului. Acum există două fire în program, un fir principal și un fir de al doilea copil creat de firul principal. Execuția ambelor fire are loc simultan, dar ieșirea exactă nu poate fi prefăcută.
Definiția Runnable Interface
Runnable este o interfață în pachetul java.lang . Implementarea interfeței Runnable putem defini un fir. Interfața care rulează are o singură metodă de rulare (), care este implementată de clasa care implementează interfața Runnable. Când alegeți să definiți firul de implementare a unei interfețe Runnable, aveți în continuare posibilitatea de a prelungi orice altă clasă. Când creați mai multe fire prin implementarea interfeței Runnable, fiecare thread împarte aceeași instanță care poate fi executată. să învățăm cum să definim un fir folosind interfața Runnable.
/ * Definirea unui thread * / Class Runnablethread implementează Runnable {/ * job of the thread * / public void run () {pentru (int i = 0; i <10; i ++) {System.Out.Println ); }} Clasa mainThread {/ * jobul principal al firului * / public static void main (String args []) {Mythread rt = nou Mythread (); / * firul principal a creat obiectul care poate fi rulat * / Thread t = Thread nou (rt); / * thread-ul principal creează fișierul copil și a trecut obiectul obișnuit * / t.start (); pentru (int i = 0; i <10; i ++) {System.Out.Print ("Subiectul principal"); }}} / * Iesire * / filet principal Filet principal Filet principal Filet Copii Filet Copii Thread Copii File Copil File Copil Filet Principal File Copil Filet Principal Filet Copii Filet Copii Filet Principal Filet Principal Thread Copii File Copii Filet Principal În codul de mai sus, am creat o clasă Runnablethread care implementează interfața Runnable și definește sarcina firului prin implementarea metodei run () a interfeței Runnable. Apoi, creez o clasă principală care conține metoda principală. În interiorul metodei principale, am declarat un obiect rulant al clasei Runnablethread și am trecut acest obiect la constructorul Thread în timp ce declarăm un fir. În acest fel, am legat obiectul thread (t) cu un obiect rulant (rt). Apoi obiectul thread invocă metoda de pornire a firului care invocă în continuare metoda de rulare a clasei Runnablethread. Dacă n-aș fi legat obiecte runnable cu obiect Thread, atunci metoda de pornire a firelor ar fi invocat metoda de executare a clasei Thread. Acum, din nou, există două fire în cod, firul principal și firul principal creează fire de fișiere atât executate simultan, dar ieșirea exactă nu poate fi niciodată prefăcută.
Diferentele cheie intre thread si runnable in Java
- Fiecare fir creat prin extinderea clasei Thread creează un obiect unic pentru el și se asociază cu acel obiect. Pe de altă parte, fiecare fir creat prin implementarea unei interfețe Runnable împărtășește aceeași instanță care poate fi rulată.
- Întrucât fiecare fir este asociat unui obiect unic când este creat prin extinderea clasei Thread, este necesară mai multă memorie. Pe de altă parte, fiecare fir creat prin implementarea interfeței Runnable împărtășește același spațiu obiect, prin urmare, aceasta necesită mai puțină memorie.
- Dacă extindeți clasa Thread apoi mai departe, puteți moșteni orice altă clasă deoarece Java nu permite moștenire multiplă, în timp ce implementarea Runnable oferă încă șansa unei clase de a moșteni orice altă clasă.
- Unul trebuie să extindă o clasă Thread numai dacă trebuie să suprascrie sau să specializeze alte metode din clasa Thread. Trebuie să implementați o interfață Runnable dacă doriți doar să vă specializați numai la metoda de rulare.
- Extinderea clasei Thread introduce cuplajul strâns în cod ca și codul Thread și sarcina firului este conținută de aceeași clasă. Pe de altă parte, implementarea interfeței Runnable introduce cuplajul liber în cod, deoarece codul Thread se separă de lucrarea atribuită firului.
Concluzie:
Este preferabil să implementați o interfață Runnable în loc să extindeți clasa Thread. Ca implementare Runnable face codul vostru cuplat în mod liber, deoarece codul de fir este diferit de clasa care atribuie sarcina firului. Aceasta necesită mai puțină memorie și, de asemenea, permite unei clase să moștenească orice altă clasă.
