Inhoud

• Vergelijkingstabel
• Definitie van schroefdraadklasse
• Definitie van Runnable Interface
• Belangrijkste verschillen tussen Thread en Runnable in Java
• Gevolgtrekking:

Een thread kan op twee manieren worden gedefinieerd. Ten eerste door een threadklasse uitbreiden die al een Runnable-interface heeft geïmplementeerd. Ten tweede, door direct een Runnable-interface implementeren. Wanneer u een thread definieert door Thread-klasse uit te breiden, moet u de methode run () in Thread-klasse overschrijven. Wanneer u een thread definieert die een Runnable-interface implementeert, moet u de enige run () -methode van de Runnable-interface implementeren. Het basisverschil tussen Thread en Runnable is dat elke thread die wordt gedefinieerd door de klasse Thread 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 enkele andere verschillen tussen Thread en Runnable observeren met behulp van de onderstaande vergelijkingstabel:

1. Vergelijkingstabel
2. Definitie
3. Belangrijkste verschillen
4. Gevolgtrekking

Vergelijkingstabel

Basis voor vergelijking	Draad	uitvoerbare
basis-	Elke thread maakt een uniek object en wordt eraan gekoppeld.	Meerdere threads delen dezelfde objecten.
Geheugen	Omdat elke thread een uniek object maakt, is meer geheugen vereist.	Omdat meerdere threads hetzelfde object delen, wordt minder geheugen gebruikt.
Het uitbreiden	In Java is meervoudige overerving niet toegestaan, dus nadat een klasse Thread-klasse heeft uitgebreid, kan deze geen andere klasse uitbreiden.	Als een klasse thread definieert die de uitvoerbare interface implementeert, heeft het een kans om één klasse uit te breiden.
Gebruik	Een gebruiker moet de threadklasse alleen uitbreiden als hij de andere methoden in de threadklasse wil overschrijven.	Als u alleen de run-methode wilt specialiseren, is de implementatie van Runnable een betere optie.
Koppelen	Uitbreidende draadklasse introduceert een strakke koppeling omdat de klasse de code van de draadklasse bevat en ook de taak die aan de draad is toegewezen	Implementatie van een uitvoerbare interface introduceert losse koppeling omdat de code van Thread gescheiden is van de taak van Threads.

Definitie van schroefdraadklasse

Draad is een klas in java.lang pakket. De klasse Thread breidt een uit Voorwerp klasse, en het implementeert uitvoerbare interfaces. De klasse Thread heeft constructors en methoden om de thread te maken en te bewerken. Wanneer we meerdere threads maken, maakt elke thread een uniek object en worden we aan dat object gekoppeld. Als u een thread maakt die Thread-klasse uitbreidt, kunt u verder geen andere klasse uitbreiden, omdat Java geen meerdere overerving ondersteunt. U moet er dus voor kiezen om de Thread-klasse alleen uit te breiden als u ook enkele andere methoden van de Thread-klasse wilt overschrijven. Laten we een voorbeeld bekijken van het maken van een thread die een threadklasse uitbreidt.

/ * Een thread definiëren * / Class Mythread breidt thread uit {/ * job van de thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Child Thread" ); }} Klasse mainThread {/ * taak van hoofdthread * / public static void main (String args) {Mythread mt = new Mythread (); / * hoofdthread heeft de onderliggende thread gemaakt * / mt.start (); for (int i = 0; i <10; i ++) {System.Out. ("Hoofdthread"); }}} / * Uitgang * / Hoofddraad Hoofddraad Hoofddraad Hoofddraad Kinddraad Kinddraad Kinddraad Kinddraad Kinddraad Hoofddraad Kinddraad Hoofddraad Hoofddraad Kinddraad Kinddraad Hoofddraad Hoofddraad Kinddraad Kinddraad Hoofddraad

In de bovenstaande code maak ik een klasse Mythread die de Thread-klasse uitbreidt en een run-methode van de Thread-klasse overschrijft. In de klasse die de hoofdmethode bevat, maak ik een thread-object (mt) van de klasse Mythread en gebruik het thread-object de methode start (). De startmethode start de uitvoering van de thread en tegelijkertijd roept JVM de run-methode van de thread op. Nu zijn er twee threads in het programma, een hoofdthread en een tweede onderliggende thread gemaakt door de hoofdthread. De uitvoering van beide threads vindt gelijktijdig plaats, maar de exacte uitvoer kan niet worden beweerd.

Definitie van Runnable Interface

uitvoerbare is een interface in java.lang pakket. Door een uitvoerbare interface te implementeren, kunnen we een thread definiëren. Runnable interface heeft een enkele methode rennen(), die wordt geïmplementeerd door de klasse die Runnable-interface implementeert. Wanneer u ervoor kiest om thread te definiëren die een uitvoerbare interface implementeert, heeft u nog steeds de keuze om een ​​andere klasse uit te breiden. Wanneer u meerdere threads maakt door de uitvoerbare interface te implementeren, deelt elke thread dezelfde uitvoerbare instantie. laten we leren hoe we een thread kunnen definiëren met behulp van de Runnable-interface.

/ * Een thread definiëren * / Class Runnablethread implementeert Runnable {/ * job van de thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Child Thread" ); }} Klasse mainThread {/ * taak van hoofdthread * / public static void main (String args) {Mythread rt = new Mythread (); / * hoofdthread creëerde het runnable object * / Thread t = new Thread (rt); / * hoofdthread maakt onderliggende thread en gaf het runnable object * / t.start (); for (int i = 0; i <10; i ++) {System.Out. ("Hoofdthread"); }}} / * Uitgang * / Hoofddraad Hoofddraad Hoofddraad Hoofddraad Kinddraad Kinddraad Kinddraad Kinddraad Kinddraad Hoofddraad Kinddraad Hoofddraad Hoofddraad Kinddraad Kinddraad Hoofddraad Hoofddraad Kinddraad Kinddraad Hoofddraad

In de bovenstaande code heb ik een klasse Runnablethread gemaakt die Runnable-interface implementeert en de taak van de thread definieert door de methode run () van de Runnable-interface te implementeren. Vervolgens maak ik een klassenhoofdhoofd met de belangrijkste methode. Binnen de hoofdmethode verklaarde ik een uitvoerbaar object van de klasse Runnablethread en gaf dit object door aan de constructeur van de Thread terwijl ik een thread verklaarde. Op deze manier heb ik het thread-object (t) gekoppeld aan een runnable object (rt). Vervolgens roept het thread-object de startmethode van de thread aan, die verder de run-methode van de klasse Runnablethread aanroept. Als ik geen uitvoerbaar object aan Thread-object had gekoppeld, zou de startmethode threads de methode run van de klasse Thread hebben aangeroepen. Nu, nogmaals, er zijn twee threads in de code, hoofdthread en hoofdthread creëert onderliggende thread die beide gelijktijdig worden uitgevoerd, maar exacte uitvoer kan nooit worden beweerd.

Belangrijkste verschillen tussen Thread en Runnable in Java

1. Elke thread die is gemaakt door de klasse Thread uit te breiden, maakt er een uniek object voor en wordt gekoppeld aan dat object. Aan de andere kant heeft elke thread die is gemaakt door een Runnable-interface te implementeren, dezelfde runnable-instantie.
2. Omdat elke thread is gekoppeld aan een uniek object wanneer deze wordt gemaakt door de Thread-klasse uit te breiden, is meer geheugen vereist. Aan de andere kant deelt elke thread die is gemaakt door de implementatie van de Runnable-interface dezelfde objectruimte, dus heeft het minder geheugen nodig.
3. Als je de Thread-klasse verder uitbreidt, kun je elke andere klasse erven, 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. Een Thread-klasse moet alleen worden uitgebreid als deze een andere methode van Thread-klasse moet overschrijven of specialiseren. U moet een Runnable-interface implementeren als u alleen de run-methode wilt specialiseren.
5. Uitbreiding van de draadklasse introduceert een strakke koppeling in de code, aangezien de code van draad en taak van draad door dezelfde klasse is opgenomen. Aan de andere kant introduceert Implementing Runnable-interface losse koppeling in de code omdat de code van de draad gescheiden is van de taak die aan de draad is toegewezen.

Gevolgtrekking:

Het heeft de voorkeur om een ​​uitvoerbare interface te implementeren in plaats van de Thread-klasse uit te breiden. Als u Runnable implementeert, wordt uw code losjes gekoppeld, omdat de threadcode anders is dan de klasse die taak aan de thread toewijst. Het vereist minder geheugen en laat een klasse ook elke andere klasse erven.