Rekommenderas, 2022

Redaktionen

Skillnad mellan trådklass och Runnable Interface i Java

En tråd kan definieras på två sätt. Först genom att förlänga en Thread-klass som redan har implementerat ett Runnable-gränssnitt. För det andra genom att direkt implementera ett Runnable-gränssnitt . När du definierar en tråd genom att förlänga ämnes klassen måste du överväga körmetoden () i trådklassen. När du definierar en tråd som implementerar ett Runnable-gränssnitt måste du implementera den enda run () -metoden för Runnable-gränssnittet. Den grundläggande skillnaden mellan Thread och Runnable är att varje tråd som definieras genom att utöka Thread-klassen skapar ett unikt objekt och får samband med det objektet. Å andra sidan delar varje tråd som definieras genom att implementera Runnable-gränssnittet samma objekt.

Låt oss observera några andra skillnader mellan Thread och Runnable med hjälp av jämförelsetabellen som visas nedan:

Jämförelsediagram

Grunder för jämförelseTrådRunnable
GrundläggandeVarje tråd skapar ett unikt objekt och blir associerad med det.Flera trådar delar samma objekt.
MinneEftersom varje tråd skapar ett unikt objekt krävs mer minne.Eftersom flera trådar delar samma objekt används mindre minne.
UtökaI Java tillåts inte flera arv då, efter att en klass har utökat trådklassen, det inte kan förlänga någon annan klass.Om en klass definierar tråd som implementerar Runnable-gränssnittet har det en chans att utvidga en klass.
Använda sig avEn användare måste endast förlänga trådklassen om den vill överväga andra metoder i trådklass.Om du bara vill specialisera körmetod är implementering av Runnable ett bättre alternativ.
KopplingUtökad trådklass introducerar snäva kopplingar, eftersom klassen innehåller koden för trådklass och det jobb som tilldelats trådenImplementerbart Runnable gränssnitt introducerar lös koppling, eftersom koden för tråd är separat bildar jobbet av trådar.

Definition av trådklass

Tråd är en klass i java.lang- paketet. Gängklassen utökar en Objeklass, och den implementerar Runnable- gränssnitt. Thread-klassen har konstruktörer och metoder för att skapa och driva på tråden. När vi skapar flera trådar skapar varje tråd ett unikt objekt och blir associerat med det objektet. Om du skapar en tråd som utökar trådklassen, kan du inte förlänga någon annan klass, eftersom Java inte stöder flera arv. Så du borde välja att förlänga trådklassen endast när du också vill åsidosätta några andra metoder för trådklass. Låt oss se ett exempel på att skapa en tråd som utökar en trådklass.

 / * Definiera en tråd * / Klass Mythread utökar tråd {/ * jobb av tråden * / public void run () {för (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Class mainThread {/ * jobb av huvudtråden * / public static void main (String args []) {Mythread mt = new Mythread (); / * huvudgängan skapade barngänget * / mt.start (); för (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Utgång * / Huvudgänga Huvudgänga Huvudgänga Huvudgänga Barngänga Barngänga Barngänga Barngänga Barngänga Huvudgänga Barngänga Huvudgänga Huvudgänga Barngänga Barntråd Huvudgänga Huvudgänga Barngänga Barngänga Huvudgänga 

I koden ovan skapar jag en klass Mythread som utökar Thread-klassen och överstyrar en körmetod för Thread-klassen. I klassen som innehåller huvudmetoden skapar jag ett trådobjekt (mt) i Mythread-klassen och använder trådobjektet på startmetoden (). Startmetoden startar tråden och samtidigt aktiverar JVM tråden för körning. Nu finns det två trådar i programmet, en huvudgänga och en andra barngänga skapad av huvudgängan. Utförandet av båda trådarna sker samtidigt, men den exakta utsignalen kan inte föras upp.

Definition av Runnable Interface

Runnable är ett gränssnitt i java.lang- paketet. Genomförande Runnable gränssnitt vi kan definiera en tråd. Runnable gränssnittet har en enda metodkörning (), som implementeras av klassen som implementerar Runnable-gränssnittet. När du väljer att definiera tråd som implementerar ett Runnable-gränssnitt har du fortfarande möjlighet att utöka någon annan klass. När du skapar flera trådar genom att implementera Runnable-gränssnitt, delar varje tråd samma löpande instans. låt oss lära oss hur du definierar en tråd med Runnable-gränssnittet.

 / * Definiera en tråd * / Klass Runnablethread implementerar Runnable {/ * jobb av tråden * / public void run () {för (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Class mainThread {/ * jobb av huvudtråden * / public static void main (String args []) {Mythread rt = ny Mythread (); / * huvudgängan skapade det rörliga objektet * / Tråd t = Ny tråd (rt); / * huvudgängan skapar barngänga och passerade det rörliga objektet * / t.start (); för (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Utgång * / Huvudgänga Huvudgänga Huvudgänga Huvudgänga Barngänga Barngänga Barngänga Barngänga Barngänga Huvudgänga Barngänga Huvudgänga Huvudgänga Barngänga Barntråd Huvudgänga Huvudgänga Barngänga Barngänga Huvudgänga 

I koden ovan skapade jag en klass Runnablethread som implementerar Runnable-gränssnittet och definierar arbetet för tråden genom att implementera run () -metoden i Runnable-gränssnittet. Sedan skapar jag en klasshäftning som innehåller huvudmetoden. Inom huvudmetoden förklarade jag ett runnable objekt av klassen Runnablethread och skickade detta objekt till gängets konstruktör medan de förklarade en tråd. På så sätt kopplade jag trådobjektet (t) med ett runnable object (rt). Därefter åberopar trådobjektet startmetoden för tråden som vidare påbereder körmetoden för Runnablethread-klassen. Om jag inte hade länkat runnable objekt med Thread-objektet, skulle trådens startmetod ha åberopat körmetoden för Thread-klassen. Nu är det igen två trådar i koden, huvudgängan och huvudgängan skapar barngänga, båda blir körda samtidigt men exakt utmatning kan aldrig föras upp.

Viktiga skillnader mellan tråd och Runnable i Java

  1. Varje tråd som skapas genom att förlänga klassen Tråd skapar ett unikt objekt för det och blir associerat med det objektet. Å andra sidan delar varje tråd skapad genom att implementera ett Runnable-gränssnitt samma runnable-instans.
  2. Eftersom varje tråd är associerad med ett unikt objekt när det skapas genom att förlänga trådklassen krävs mer minne. Å andra sidan delar varje tråd som skapas genom att implementera Runnable-gränssnittet samma objektrymd, vilket kräver mindre minne.
  3. Om du förlänger Thread-klassen ytterligare, kan du ärva en annan klass, eftersom Java inte tillåter flera arv, medan implementering av Runnable fortfarande ger en chans för en klass att ärva någon annan klass.
  4. Man måste endast förlänga en trådklass, om den måste åsidosätta eller specialisera några andra metoder för trådklass. Du måste implementera ett Runnable-gränssnitt om du bara vill specialisera körmetod.
  5. Utvidgning av Thread-klassen introducerar snabb koppling i koden, eftersom koden för Thread och jobb av tråd ingår i samma klass. Å andra sidan introducerar Runnable-gränssnittet lös koppling i koden, eftersom koden för tråden separeras från jobbet som är tilldelat tråden.

Slutsats:

Det föredras att implementera ett Runnable-gränssnitt istället för att förlänga trådklassen. Som implementering Runnable görs din kod löst kopplad eftersom trådkoden skiljer sig från den klass som tilldelar jobb till tråden. Det kräver mindre minne och tillåter också att en klass arver någon annan klass.

Top