Conţinut

• Diagramă de comparație
• Definiția Thread Class
• Definiția Runnable Interface
• Diferențe cheie între filet și rundabil în Java
• Concluzie:

Un fir poate fi definit în două moduri. În primul rând, prin extinderea unei clase Thread care a implementat deja o interfață Runnable. În al doilea rând, direct implementarea unei interfețe Runnable. Când definiți un thread extinzând clasa Thread, trebuie să înlocuiți metoda run () din clasa Thread. Când definiți un thread care implementează o interfață Runnable, trebuie să implementați singura metodă run () a interfeței Runnable. Diferența de bază dintre Thread și Runnable este că fiecare fir definit prin extinderea clasei Thread creează un obiect unic și se asociază cu acel obiect. Pe de altă parte, fiecare fir definit prin implementarea interfeței Runnable partajează același obiect.

Să observăm câteva alte diferențe între Thread și Runnable cu ajutorul graficului de comparație prezentat mai jos:

1. Diagramă de comparație
2. Definiție
3. Diferențele cheie
4. Concluzie

Diagramă de comparație

Baza pentru comparație	Fir	runnable
De bază	Fiecare fir creează un obiect unic și se asociază cu acesta.	Mai multe fire împărtășesc aceleași obiecte.
Memorie	Pe măsură ce fiecare thread creează un obiect unic, este necesară mai multă memorie.	Deoarece mai multe fire partajează același obiect, se folosește 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 thread care implementează interfața Runnable, are șansa de a extinde o clasă.
Utilizare	Un utilizator trebuie să extindă clasa de thread doar dacă dorește să înlocuiască celelalte metode din clasa Thread.	Dacă doriți doar să specializați metoda de rulare, atunci implementarea Runnable este o opțiune mai bună.
Cuplare	Extinderea clasei Thread introduce cuplajul strâns, deoarece clasa conține codul clasei Thread și, de asemenea, sarcina atribuită thread-ului	Punerea în aplicare a interfeței Runnable introduce cuplajul liber deoarece codul de fir este separat de lucrarea Threads.

Definiția Thread Class

Fir este o clasă în java.lang pachet. Clasa Thread extinde an Obiect clasa, și pune în aplicare runnable interfețe. Clasa Thread are constructori și metode pentru a crea și opera pe fir. Când creăm mai multe thread-uri, fiecare thread creează un obiect unic și se asociază cu acel obiect. Dacă creați un thread care extinde clasa Thread, nu puteți extinde nici o altă clasă, deoarece java nu acceptă moștenire multiplă. Deci, ar trebui să alegeți să extindeți clasa Thread doar atunci când doriți să treceți peste alte alte metode ale clasei Thread. Să vedem un exemplu de creare a unui thread care extinde o clasă Thread.

/ * Definirea unui thread * / Class Mythread extinde Thread {/ * job of the thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Firul copilului" ); }} Clasa mainThread {/ * job of thread principal * / public static void main (args String) {Mythread mt = new Mythread (); / * firul principal a creat firul copil * / mt.start (); for (int i = 0; i <10; i ++) {System.Out. ("Fir principal"); }}} / * Ieșire * / Fire principală Fire principală Fire principal Fire principală Fire copil Copilă fire copil Copilă fire copil Fil principal copil Thread fire principală Thread main filet pentru copii Thread fire principală fire pentru fire fire pentru copii Thread main

În codul de mai sus, creez o clasă Mythread care extinde clasa Thread și înlocuiește o metodă de rulare a clasei Thread. În clasa care conține metoda principală am creat un obiect thread (mt) din clasa Mythread și folosind obiectul thread a invocat metoda start (). Metoda de pornire începe executarea firului și, în același timp, JVM invocă metoda de rulare a firului. Acum, în program există două fire, un fir principal și un al doilea copil copil, create de firul principal. Execuția ambelor fire are loc simultan, dar, ieșirea exactă nu poate fi preconizată.

Definiția Runnable Interface

runnable este o interfață în java.lang pachet. Implementând interfața Runnable putem defini un thread. Interfața Runnable are o singură metodă alerga(), care este implementat de clasa care implementează interfața Runnable. Când alegeți să definiți thread care implementează o interfață Runnable, mai aveți de ales să extindeți orice altă clasă. Când creați mai multe fire implementând interfața Runnable, fiecare thread împărtășește aceeași instanță de rulare. să învățăm cum să definim un thread folosind interfața Runnable.

/ * Definirea unui thread * / Class Runnablethread implementează Runnable {/ * job of the thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Firul copilului" ); }} Clasa mainThread {/ * job of thread principal * / public static void main (args String) {Mythread rt = new Mythread (); / * thread-ul principal a creat obiectul rulabil * / Thread t = new Thread (rt); / * firul principal creează firul copil și a trecut obiectul rulabil * / t.start (); for (int i = 0; i <10; i ++) {System.Out. ("Fir principal"); }}} / * Ieșire * / Fire principală Fire principală Fire principal Fire principală Fire copil Copilă fire copil Copilă fire copil Fil principal copil Thread fire principală Thread main filet pentru copii Thread fire principală fire pentru fire fire pentru copii Thread main

În codul de mai sus, am creat o clasă Runnablethread care implementează interfața Runnable și definește jobul thread-ului prin implementarea metodei run () a interfeței Runnable. Apoi am creat un mainthread de clasă care conține metoda principală. În cadrul metodei principale, am declarat un obiect care poate fi executat din clasa Runnablethread și am transmis acest obiect constructorului Firului în timp ce declarau un fir. În acest fel, am conectat obiectul (t) de thread cu un obiect care rulează (rt). Apoi obiectul thread invocă metoda de început a thread-ului care invocă suplimentar metoda de rulare a clasei Runnablethread. Dacă nu aș fi legat obiectul runnable cu obiectul Thread, atunci metoda de start a thread-urilor ar fi invocat metoda de rulare a clasei Thread. Acum, din nou, există două fire în cod, firul principal și firul principal creează firul copil ambele executate simultan, dar ieșirea exactă nu poate fi niciodată preconizată.

Diferențe cheie între filet și rundabil în Java

1. Fiecare fir creat prin extinderea clasei Thread creează un obiect unic pentru ea ș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ță rulantă.
2. Deoarece fiecare thread este asociat cu un obiect unic atunci 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, necesită mai puțină memorie.
3. 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ă o șansă unei clase de a moșteni orice altă clasă.
4. Trebuie să extindeți o clasă Thread numai dacă trebuie să înlocuiască sau să specializeze unele alte metode ale clasei Thread. Trebuie să implementați o interfață Runnable doar dacă doriți să specializați doar metoda de rulare.
5. Extinderea clasei Thread introduce cuplarea strânsă în cod, întrucât codul Thread, iar job of thread este conținut de aceeași clasă. Pe de altă parte, Implementing Runnable interface introduce cuplajul liber în cod, deoarece codul Thread se seprate din lucrarea atribuită firului.

Concluzie:

Este de preferat să implementați o interfață Runnable în loc să extindeți clasa Thread. Pe măsură ce implementează Runnable, codul tău este cuplat, întrucât codul thread-ului este diferit de clasa care atribuie job-ului. Necesită mai puțină memorie și permite, de asemenea, unei clase să moștenească orice altă clasă.