Aanbevolen, 2020

Editor'S Choice

Verschil tussen Thread Class en Runnable Interface in Java

Een thread kan op twee manieren worden gedefinieerd. Allereerst door een Thread-klasse uit te breiden die al een Runnable-interface heeft geïmplementeerd. Ten tweede door een Runnable-interface rechtstreeks te implementeren . Wanneer u een thread definieert door de Thread-klasse uit te breiden, moet u de methode run () in de klasse Thread overschrijven. Wanneer u een thread definieert die een Runnable-interface implementeert, moet u de enige run () -methode van Runnable-interface implementeren. Het basisverschil tussen Thread en Runnable is dat elke thread die wordt gedefinieerd door de Thread-klasse uit te breiden, een uniek object maakt en aan dat object wordt gekoppeld. Aan de andere kant deelt elke thread die is gedefinieerd door de implementatie van de Runnable-interface hetzelfde object.

Laten we een aantal andere verschillen tussen Thread en Runnable bekijken met behulp van de onderstaande vergelijkingsgrafiek:

Vergelijkingstabel

Basis voor vergelijkingDraaduitvoerbare
basis-Elke thread maakt een uniek object en wordt ermee geassocieerd.Meerdere threads delen dezelfde objecten.
GeheugenOmdat elke thread een uniek object maakt, is meer geheugen vereist.Omdat meerdere threads hetzelfde object delen, wordt minder geheugen gebruikt.
Het uitbreidenIn Java is meerdere overerving niet toegestaan. Nadat een klasse de Thread-klasse heeft uitgebreid, kan deze geen andere klasse uitbreiden.Als een klasse een thread definieert die de Runnable-interface implementeert, heeft dit een kans om één klasse uit te breiden.
GebruikEen gebruiker moet alleen de threadklasse verlengen als deze de andere methoden in de klasse Thread wil overschrijven.Als u alleen de run-methode wilt specialiseren, is het implementeren van Runnable een betere optie.
KoppelenUitbreiding van Thread-klasse introduceert een strakke koppeling omdat de klasse de code van de Thread-klasse bevat en ook de taak die aan de thread is toegewezenHet implementeren van een Runnable interface introduceert losse koppeling omdat de code van Thread los staat van de taak van Threads.

Definitie van Thread Class

Discussie is een klasse in het pakket java.lang . De Thread-klasse breidt een klasse Object uit en implementeert uitvoerbare interfaces. De Thread-klasse heeft constructors en methoden om de thread te maken en te gebruiken. Wanneer we meerdere threads maken, maakt elke thread een uniek object en wordt geassocieerd met dat object. Als u een thread maakt die de Thread-klasse uitbreidt, kunt u verder geen enkele andere klasse uitbreiden, omdat java niet meerdere overerving ondersteunt. U moet dus ervoor kiezen om de Thread-klasse alleen te verlengen als u ook andere methoden van de Thread-klasse wilt negeren. Laten we een voorbeeld zien van het maken van een thread die een Thread-klasse uitbreidt.

 / * Een thread definiëren * / Klasse Mythread breidt Thread uit {/ * job van de thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Klasse mainThread {/ * taak van de hoofdthread * / public static void main (String args []) {Mythread mt = new Mythread (); / * hoofdthread heeft de onderliggende thread gemaakt * / mt.start (); voor (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Uitvoer * / Main Thread Hoofdthoofd Main Thread Onderwerpreeks Onderwerpstreeft Kers discussie Onderwerpsgarnituur Onderwerpen Onderwerpstreep als doorsnee Thread Thread door Thread Thread Thread Onderwerp Onderwerp is van Thread Main Thread 

In de bovenstaande code maak ik een klasse Mythread die de Thread-klasse uitbreidt en een run-methode van de Thread-klasse vervangt. In de klasse met de hoofdmethode maak ik een thread-object (mt) van de Mythread-klasse en gebruik ik het thread-object dat de start () -methode heeft aangeroepen. De startmethode start de uitvoering van de thread en op hetzelfde moment roept JVM de run-methode van de thread aan. Nu zijn er twee threads in het programma één hoofdthread en een tweede child-thread gemaakt door de hoofdthread. De uitvoering van beide threads gebeurt tegelijkertijd, maar de exacte uitvoer kan niet worden gedaan.

Definitie van Runnable Interface

Runnable is een interface in het pakket java.lang . Implementatie van een bruikbare interface kunnen we een thread definiëren. Een bruikbare interface heeft een enkele methode- run (), die wordt geïmplementeerd door de klasse die de Runnable-interface implementeert. Wanneer u ervoor kiest om een ​​thread te definiëren die een Runnable-interface implementeert, hebt u nog steeds de keuze om een ​​andere klasse uit te breiden. Wanneer u meerdere threads maakt door een Runnable-interface te implementeren, deelt elke thread hetzelfde bruikbare exemplaar. laten we leren hoe we een thread definiëren met de interface Runnable.

 / * Een thread definiëren * / Klasse Runnablethread implementeert Runnable {/ * job van de thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Klasse mainThread {/ * job met hoofdthema * / public static void main (String args []) {Mythread rt = new Mythread (); / * de hoofdthread heeft het uitvoerbare object gemaakt * / Thread t = new Thread (rt); / * hoofdthread maakt onderliggende thread en geeft het loopbare object door * / t.start (); voor (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Uitvoer * / Main Thread Hoofdthoofd Main Thread Onderwerpreeks Onderwerpstreeft Kers discussie Onderwerpsgarnituur Onderwerpen Onderwerpstreep als doorsnee Thread Thread door Thread Thread Thread Onderwerp Onderwerp is van Thread Main Thread 

In de bovenstaande code heb ik een klasse Runnablethread gemaakt die de Runnable-interface implementeert en de taak van de thread definieert door de methode run () van de interface Runnable te implementeren. Vervolgens maak ik een hoofddomein van de klasse met de hoofdmethode. In de hoofdmethode heb ik een uitvoerbaar object van de klasse Runnablethread uitgeroepen en dit object doorgegeven aan de constructor van Thread terwijl ik een thread declareerde. Op deze manier heb ik het draadobject (t) gekoppeld aan een uitvoerbaar object (rt). Vervolgens roept het thread-object de startmethode van de thread op, die vervolgens de run-methode van de klasse Runnablethread aanroept. Als ik een bruikbaar object niet aan het Thread-object had gekoppeld, had de methode voor het starten van threads de run-methode van de Thread-klasse aangeroepen. Nu zijn er weer twee threads in de code, de hoofdthread en de hoofdthread maken de child-thread beide gelijktijdig uitgevoerd, maar exacte uitvoer kan nooit worden gedaan.

Belangrijkste verschillen tussen Thread en Runnable in Java

  1. Elke thread die wordt gemaakt door de Thread-klasse uit te breiden, maakt er een uniek object van en wordt geassocieerd met dat object. Aan de andere kant deelt elke thread die is gemaakt door het implementeren van een Runnable-interface hetzelfde uitvoerbare exemplaar.
  2. Omdat elke thread is gekoppeld aan een uniek object wanneer deze is gemaakt door de Thread-klasse uit te breiden, is meer geheugen vereist. Aan de andere kant heeft elke thread die is gemaakt door de Runnable-interface te implementeren dezelfde objectruimte en dus minder geheugen.
  3. Als u de Thread-klasse uitbreidt, kunt u elke andere klasse overnemen omdat Java geen meerdere overerving toestaat, terwijl het implementeren van Runnable nog steeds een kans biedt voor een klasse om een ​​andere klasse te erven.
  4. Men moet een Thread-klasse alleen uitbreiden als het een aantal andere methoden van Thread-klasse moet overrulen of specialiseren. U moet een Runnable-interface implementeren als u alleen alleen de run-methode wilt specialiseren.
  5. Als u de Thread-klasse uitbreidt, wordt een strakke koppeling in de code geïntroduceerd, omdat de code van Thread en de taak van thread zich in dezelfde klasse bevindt. Aan de andere kant introduceert de Implementing Runnable interface een losse koppeling in de code omdat de code van Thread gescheiden is van de taak die aan de thread is toegewezen.

Conclusie:

Het heeft de voorkeur om een ​​Runnable-interface te implementeren in plaats van de Thread-klasse uit te breiden. Aangezien het implementeren van Runnable uw code losjes koppelt, omdat de code van de thread verschilt van de klasse die de taak toewijst aan de thread. Het vereist minder geheugen en maakt het ook mogelijk dat een klasse een andere klasse erven.

Top