Diferència entre Thread Class i Runnable Interface a Java
Content
- Gràfic de comparació
- Definició de Thread Class
- Definició de Runnable Interface
- Diferències claus entre el fil i l'executable en Java
- Conclusió:
Un fil es pot definir de dues maneres. Primer, per ampliant una classe de fil que ja ha implementat una interfície Runnable. En segon lloc, directament implementant una interfície Runnable. Quan definiu un fil ampliant la classe Thread, heu de substituir el mètode run () a la classe Thread. Quan definiu un fil implementant una interfície Runnable, heu d’implementar l’únic mètode run () de la interfície Runnable. La diferència bàsica entre Thread i Runnable és que cada fil definit per ampliar la classe Thread crea un objecte únic i s’associa amb aquest objecte. D'altra banda, cada fil definit per implementar la interfície Runnable comparteix el mateix objecte.
Observem algunes altres diferències entre Thread i Runnable amb l'ajuda del gràfic de comparació que es mostra a continuació:
- Gràfic de comparació
- Definició
- Diferències claus
- Conclusió
Gràfic de comparació
| Bases per a la comparació | Fil | Runnable |
|---|---|---|
| Bàsic | Cada fil crea un objecte únic i s’associa amb ell. | Diversos fils comparteixen els mateixos objectes. |
| Memòria | A mesura que cada fil crea un objecte únic, es requereix més memòria. | Com que diversos fils comparteixen el mateix objecte s’utilitza menys memòria. |
| S'estén | A Java, no s’admet l’herència múltiple, per tant, després que una classe s’estengui la classe de fil, no es pugui estendre cap altra classe. | Si una classe de definició de fil implementant la interfície Runnable té la possibilitat d'ampliar una classe. |
| Utilitzeu | Un usuari només ha d’estendre la classe de fil si vol substituir els altres mètodes de la classe Fil. | Si només voleu especialitzar-vos en mètode d'execució, implementar Runnable és una opció millor. |
| Acoblament | L'extensió de la classe Thread introdueix un acoblament ajustat ja que la classe conté codi de la classe Thread i també la tasca assignada al fil | La implementació de la interfície Runnable introdueix un acoblament solt, ja que el codi de fil ha separat per separat del treball de Threads. |
Definició de Thread Class
Fil és una classe en java.lang paquet. La classe Thread amplia una Objecte classe, i implementa Runnable interfícies. La classe Thread té constructors i mètodes per crear i operar al fil. Quan creem diversos fils, cada fil crea un objecte únic i s’associa amb aquest. Si creeu un fil d'ampliació de la classe de fil, no podeu ampliar cap altra classe ja que Java no admet herències múltiples. Per tant, heu d'optar per ampliar la classe de fil només quan voleu substituir alguns altres mètodes de la classe de fil. Veiem un exemple de creació d’un fil que estén una classe Fil.
/ * Definició d'un fil * / Class Mythread estén Thread {/ * treball del fil * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Fil infantil" ); }} Class mainThread {/ * treball del fil principal * / public static void main (String args) {Mythread mt = new Mythread (); / * el fil principal ha creat el fil infantil * / mt.start (); for (int i = 0; i <10; i ++) {System.Out. ("Fil principal"); }}} / * Sortida * / Fil principal Fil principal Fil conductor principal Fil principal Fil infantil Nen fil infantil Nen fil infantil Nen fil principal Fil conductor infantil Fil principal principal Fil principal infantil Fil infantil Fil principal principal Fil principal Fil infantil Nen fil infantil
Al codi anterior, creo una classe Mythread que amplia la classe Thread i substitueix un mètode d'execució de la classe Thread. A la classe que conté el mètode principal, creo un objecte de fil (mt) de la classe Mythread i utilitzant l'objecte de fil invocat el mètode start (). El mètode d’inici inicia l’execució del fil i al mateix temps JVM invoca el mètode d’execució del fil. Ara hi ha dos fils del programa un fil principal i un segon fil secundari creat pel fil principal. L'execució dels dos fils es produeix simultàniament, però no es pot fingir la sortida exacta.
Definició de Runnable Interface
Runnable és una interfície java.lang paquet. Implementant la interfície de Runnable podem definir un fil. La interfície Runnable té un sol mètode correr(), que és implementat per la classe que implementa la interfície Runnable. Quan trieu definir el fil implementant una interfície Runnable, encara podreu estendre qualsevol altra classe. Quan creeu diversos fils implementant la interfície de Runnable, cada fil comparteix la mateixa instància de runnable. aprenem a definir un fil mitjançant la interfície executable.
/ * Definició d'un fil * / Class Runnablethread implementa Runnable {/ * treball del fil * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Fil infantil" ); }} Classe mainThread {/ * treball del fil principal * / public static void main (String args) {Mythread rt = new Mythread (); / * el fil principal ha creat l'objecte executable * / Thread t = new Thread (rt); / * el fil principal crea el fil infantil i va passar l'objecte executable * / t.start (); for (int i = 0; i <10; i ++) {System.Out. ("Fil principal"); }}} / * Sortida * / Fil principal Fil principal Fil conductor principal Fil principal Fil infantil Nen fil infantil Nen fil infantil Nen fil principal Fil conductor infantil Fil principal principal Fil principal infantil Fil infantil Fil principal principal Fil principal Fil infantil Nen fil infantil
Al codi anterior, vaig crear una classe Runnablethread que implementa la interfície Runnable i defineix la tasca del fil mitjançant la implementació del mètode run () de la interfície Runnable. Després creo un mainthread de classes que conté el mètode principal. Dins del mètode principal, vaig declarar un objecte executable de la classe Runnablethread i vaig passar aquest objecte al constructor del fil tot declarant un fil. D’aquesta manera, vaig enllaçar l’objecte de fil (t) amb un objecte executable (rt). A continuació, l'objecte de fil invoca el mètode d'inici del fil, que invoca a més el mètode d'execució de la classe Runnablethread. Si no hagués enllaçat l'objecte runnable amb l'objecte Thread, el mètode d'inici de fils hauria invocat el mètode d'execució de la classe Thread. Ara, de nou, hi ha dos fils del codi, el fil principal i el fil principal creen que el fil fill s'executa simultàniament, però mai no es pot fingir la sortida exacta.
Diferències claus entre el fil i l'executable en Java
- Cada fil creat mitjançant l'ampliació de la classe Thread crea un objecte únic i s'associa amb aquest objecte. D’altra banda, cada fil creat mitjançant la implementació d’una interfície Runnable comparteix la mateixa instància executable.
- Com cada fil s'associa a un objecte únic quan es crea mitjançant l'ampliació de la classe de fil, es requereix més memòria. D'altra banda, cada fil creat mitjançant la implementació de la interfície Runnable comparteix el mateix espai d'objectes, per tant, requereix menys memòria.
- Si amplieu la classe de fil més enllà, podeu heretar qualsevol altra classe ja que Java no permet l'herència múltiple, mentre que implementar Runnable pot proporcionar una classe per heretar qualsevol altra classe.
- Cal extendre una classe de fil només si ha de substituir o especialitzar alguns altres mètodes de la classe de fil. Heu d’implementar una interfície Runnable si només voleu especialitzar-vos només en mètode d’execució.
- L'extensió de la classe Thread introdueix un acoblament estricte en el codi ja que el codi de Thread i el treball de fil el conté la mateixa classe. D'altra banda, Implementing Runnable interface introdueix un acoblament solt en el codi ja que el codi de Thread se separa del treball assignat al fil.
Conclusió:
Es prefereix implementar una interfície Runnable en lloc d'extendre la classe Thread. A mesura que implementem Runnable, el teu codi es combina amb freqüència, ja que el codi de fil és diferent de la classe que assigna el treball al fil. Requereix menys memòria i també permet que una classe hereti qualsevol altra classe.
