Innehåll

• Jämförelsediagram
• Definition av trådklass
• Definition av Runnable Interface
• Viktiga skillnader mellan tråd och körbar i Java
• Slutsats:

En tråd kan definieras på två sätt. Först av utvidga en trådklass som redan har implementerat ett körbart gränssnitt. För det andra direkt implementera ett körbart gränssnitt. När du definierar en tråd genom att utöka trådklassen måste du åsidosätta metoden körning () i trådklassen. När du definierar en tråd som implementerar ett körbart gränssnitt måste du implementera den enda körmetoden () för Runnable interface. Den grundläggande skillnaden mellan tråd och körbar är att varje tråd definierad genom att utöka trådklassen skapar ett unikt objekt och blir associerat med det objektet. Å andra sidan delar varje tråd definierad genom att implementera Runnable-gränssnittet samma objekt.

Låt oss observera några andra skillnader mellan tråd och körbar med hjälp av jämförelsediagram som visas nedan:

1. Jämförelsediagram
2. Definition
3. Viktiga skillnader
4. Slutsats

Jämförelsediagram

Grund för jämförelse	Tråd	Runnable
Grundläggande	Varje tråd skapar ett unikt objekt och blir associerat med det.	Flera trådar delar samma objekt.
Minne	När varje tråd skapar ett unikt objekt krävs mer minne.	Eftersom flera trådar delar samma objekt används mindre minne.
Utöka	I Java är flera arv inte tillåtna, och efter att en klass har utökat trådklassen kan den inte utöka någon annan klass.	Om en klass definierar tråd som implementerar det körbara gränssnittet har det en chans att utöka en klass.
Använda sig av	En användare måste bara utöka trådklassen om den vill åsidosätta de andra metoderna i trådklassen.	Om du bara vill specialisera körmetod är implementering av Runnable ett bättre alternativ.
Koppling	Genom att utöka gängklassen introduceras en tät koppling eftersom klassen innehåller kod för trådklass och även det jobb som tilldelas tråden	Implementering Runnable interface introducerar lös koppling eftersom trådkoden är separat från Trådens jobb.

Definition av trådklass

Tråd är en klass i java.lang paket. Trådklassen förlänger en Objekt klass, och det implementeras Runnable gränssnitt. Trådklassen 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 förlänger trådklassen kan du vidare inte utöka någon annan klass eftersom java inte stöder flera arv. Så du bör välja att utöka trådklassen endast när du också vill åsidosätta några andra metoder i trådklass. Låt oss se ett exempel på att skapa en tråd som utvidgar en trådklass.

/ * Definiera en tråd * / Klass Mythread förlänger tråd {/ * jobb för tråden * / public void run () {för (int i = 0; i <10; i ++) {System.Out.ln ("Child Thread" ); }} Klass mainThread {/ * jobb för huvudtråd * / public static void main (String args) {Mythread mt = new Mythread (); / * huvudtråd skapade undertråden * / mt.start (); för (int i = 0; i <10; i ++) {System.Out. ("Huvudtråd"); }}} / * Utgång * / Main Thread Huvud Thread Huvud Thread Huvudgäng Barn Gäng Barn Gäng Barn Gäng Barn Gängbarngänghuvudgäng Barn Gänghuvudgänghuvudgäng Barn Gängbarngänghuvudgänghuvudgäng Barn Gängbarn Gänga Huvudgäng

I koden ovan skapar jag en klass Mythread som utvidgar trådklassen och åsidosätter en körmetod för trådklassen. I klassen som innehåller huvudmetoden skapar jag ett trådobjekt (mt) av klassen Mythread och med hjälp av trådobjektet åberopade startmetoden. Startmetoden startar exekveringen av tråden och samtidigt åberopar JVM trådens körmetod. Nu finns det två trådar i programmet, en huvudtråd och en andra barntråd skapad av huvudtråden. Exekveringen av båda trådarna sker samtidigt, men exakt utgång kan inte låtsas.

Definition av Runnable Interface

Runnable är ett gränssnitt i java.lang paket. Implementering Runnable interface vi kan definiera en tråd. Körbart gränssnitt har en enda metod springa(), som implementeras av klassen som implementerar Runnable-gränssnitt. När du väljer att definiera tråd som implementerar ett körbart gränssnitt har du fortfarande ett val att utöka någon annan klass. När du skapar flera trådar genom att implementera Runnable-gränssnittet delar varje tråd samma löpbara instans. låt oss lära oss att definiera en tråd med Runnable-gränssnitt.

/ * Definiera en tråd * / Class Runnablethread implementerar körbart {/ * jobb för tråden * / public void run () {för (int i = 0; i <10; i ++) {System.Out.ln ("Child Thread" ); }} Klass mainThread {/ * jobb för huvudtråd * / public static void main (String args) {Mythread rt = new Mythread (); / * huvudtråd skapade det löpbara objektet * / Tråd t = ny tråd (rt); / * huvudtråd skapar undertråd och passerade det löpbara objektet * / t.start (); för (int i = 0; i <10; i ++) {System.Out. ("Huvudtråd"); }}} / * Utgång * / Main Thread Huvud Thread Huvud Thread Huvudgäng Barn Gäng Barn Gäng Barn Gäng Barn Gängbarngänghuvudgäng Barn Gänghuvudgänghuvudgäng Barn Gängbarngänghuvudgänghuvudgäng Barn Gängbarn Gänga Huvudgäng

I koden ovan skapade jag en klass Runnablethread som implementerar Runnable-gränssnittet och definierar trådens jobb genom att implementera metoden run () för Runnable-gränssnittet. Sedan skapar jag en klass mainthread som innehåller huvudmetoden. Inuti huvudmetoden förklarade jag ett löpbart objekt i klassen Runnablethread och överförde detta objekt till trådens konstruktör medan jag förklarade en tråd. På detta sätt kopplade jag trådobjektet (t) till ett löpbart objekt (rt). Sedan åberopar trådobjektet startmetoden för tråden som ytterligare åberopar körmetod för klassen Runnablethread. Om jag inte hade kopplat löpbart objekt till trådobjektet, skulle trådens startmetod ha åberopat körmetoden för trådklassen. Nu, återigen finns det två trådar i koden, huvudtråd och huvudtråd skapar barntråd båda blir exekverade samtidigt men exakt utgång kan aldrig låtsas.

Viktiga skillnader mellan tråd och körbar i Java

1. Varje tråd skapad genom att utöka trådklassen skapar ett unikt objekt för det och blir associerat med det objektet. Å andra sidan delar varje tråd som skapas genom att implementera ett körbart gränssnitt samma körbara instans.
2. Eftersom varje tråd är associerad med ett unikt objekt när det skapas genom att utöka trådklassen krävs mer minne. Å andra sidan delar varje tråd som skapas genom att implementera Runnable interface samma objektutrymme, och det kräver mindre minne.
3. Om du utökar trådklassen ytterligare, kan du ärva någon 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 utöka en trådklass bara om den måste åsidosätta eller specialisera vissa andra metoder i trådklass. Du måste implementera ett körbart gränssnitt om du bara vill specialisera körmetoden.
5. Genom att utvidga gängklassen introduceras en tät koppling i koden eftersom koden för gängan och tråden jobbar av samma klass. Å andra sidan, Implementing Runnable interface introducerar lös koppling i koden eftersom koden för tråd är separerad från jobbet som tilldelats tråden.

Slutsats:

Det är föredraget att implementera ett körbart gränssnitt istället för att utöka trådklassen. Eftersom implementering av Runnable gör din kod löst kopplad eftersom trådkoden skiljer sig från klassen som tilldelar jobb till tråden. Det kräver mindre minne och gör det också möjligt för en klass att ärva någon annan klass.