Anbefalt, 2022

Redaksjonens

Forskjellen mellom trådklasse og Runnable Interface i Java

En tråd kan defineres på to måter. Først ved å utvide en Thread-klasse som allerede har implementert et Runnable-grensesnitt. For det andre, ved direkte å implementere et Runnable-grensesnitt . Når du definerer en tråd ved å utvide Genglass, må du overstyre run () -metoden i Genglass. Når du definerer en tråd som implementerer et Runnable-grensesnitt, må du implementere den eneste run () -metoden for Runnable-grensesnittet. Den grunnleggende forskjellen mellom Thread og Runnable er at hver tråd definert ved å utvide Thread-klassen skaper en unik gjenstand og får tilknytning til objektet. På den annen side deler hver tråd definert ved å implementere Runnable-grensesnitt det samme objektet.

La oss observere noen andre forskjeller mellom Thread and Runnable ved hjelp av sammenligningstabell vist nedenfor:

Sammenligningstabel

Grunnlag for sammenligningTrådkjørbart
grunn~~POS=TRUNCHver tråd oppretter en unik gjenstand og blir assosiert med den.Flere tråder deler de samme objektene.
HukommelseSom hver tråd oppretter en unik gjenstand, krever mer minne.Siden flere tråder deler det samme objektet, brukes mindre minne.
utvideI Java er ikke flere arv tillatt, etter at en klasse utvider diskusjonsklassen, kan den ikke forlenge noen annen klasse.Hvis en klasse definerer en tråd som implementerer Runnable-grensesnittet, har den en sjanse til å utvide en klasse.
BrukEn bruker må kun utvide trådklasse hvis den ønsker å overstyre de andre metodene i trådklasse.Hvis du bare vil spesialisere løpemetode, er implementering Runnable et bedre alternativ.
koblingUtvidet trådklasse introduserer tett kobling når klassen inneholder kode for trådklasse og også jobben tildelt trådenImplementering Runnable grensesnitt introduserer løs kobling ettersom koden til tråden er skilt fra jobben til tråder.

Definisjon av trådklasse

Tråd er en klasse i java.lang- pakken. Thread-klassen utvider en Objeklasse, og den implementerer Runnable- grensesnitt. The Thread-klassen har konstruktører og metoder for å lage og operere på tråden. Når vi lager flere tråder, oppretter hver tråd et unikt objekt og får tilknytning til det aktuelle objektet. Hvis du lager en tråd som utvider Thread-klassen, kan du heller ikke utvide noen annen klasse, da java ikke støtter flere arv. Så bør du velge å utvide diskusjonsklassen bare når du også vil overstyre noen andre metoder for trådklasse. La oss se et eksempel på å lage en tråd som utvider en trådklasse.

 / * Definere en tråd * / Klasse Mythread utvider tråden {/ * jobb av tråden * / offentlig tomgangsløp () {for (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Klasse mainThread {/ * jobb av hovedtråden * / offentlig statisk tomt hoved (String args []) {Mythread mt = new Mythread (); / * hovedtråd opprettet barnetråden * / mt.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Utgang * / Hovedtrekk Hovedgjenge Hovedgarn Hovedgarn Barnetråd Barnetråden Barnetråden Barnetråden Barnetråden Hovedråden Barnetråden Hovedgarn Hovedgarn Barnetråden Barnetråden Hovedgarn Hovedgjenstander Barnetråd Barnetråden Hovedgjenstanden 

I koden ovenfor oppretter jeg en klasse Mythread som utvider gjengeklassen og overstyrer en løpemetode for trådklasse. I klassen som inneholder hovedmetoden lager jeg et trådobjekt (mt) av Mythread-klassen og bruker trådobjektet påbegynt startmetoden (). Startmetoden starter gjennomføringen av tråden, samtidig som JVM påbereder kjøremetoden for tråden. Nå er det to tråder i programmet, en hovedtråd og andre barnetråd laget av hovedtråden. Utførelsen av begge trådene skjer samtidig, men den eksakte utgangen kan ikke foregå.

Definisjon av Runnable Interface

Runnable er et grensesnitt i java.lang- pakken. Implementere Runnable grensesnitt vi kan definere en tråd. Runnable grensesnitt har en enkelt metode kjøring (), som implementeres av klassen som implementerer Runnable grensesnitt. Når du velger å definere tråd som implementerer et Runnable-grensesnitt, har du fortsatt mulighet til å utvide en annen klasse. Når du lager flere tråder ved å implementere Runnable-grensesnitt, deler hver tråd samme runde-forekomst. la oss lære å definere en tråd ved hjelp av Runnable-grensesnittet.

 / * Definere en tråd * / Klasse Runnablethread implementerer Runnable {/ * jobb av tråden * / offentlig tomgangsløp () {for (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Klasse mainThread {/ * jobb av hovedtråden * / offentlig statisk tomt hoved (String args []) {Mythread rt = new Mythread (); / * Hovedgjenstander opprettet runnable objektet * / Tråd t = Ny tråd (rt); / * hovedtråd oppretter barnetråden og passerer det runnable objektet * / t.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Utgang * / Hovedtrekk Hovedgjenge Hovedgarn Hovedgarn Barnetråd Barnetråden Barnetråden Barnetråden Barnetråden Hovedråden Barnetråden Hovedgarn Hovedgarn Barnetråden Barnetråden Hovedgarn Hovedgjenstander Barnetråd Barnetråden Hovedgjenstanden 

I koden ovenfor opprettet jeg en klasse Runnablethread som implementerer Runnable-grensesnittet og definerer jobben av tråden ved å implementere run () -metoden til Runnable-grensesnittet. Deretter oppretter jeg en klassesenter som inneholder hovedmetoden. Innenfor hovedmetoden erklærte jeg et løpbart objekt av klassen Runnablethread og sendt dette objektet til trådenes konstruktør mens de erklærte en tråd. På denne måten koblede jeg trådobjektet (t) med et runnable objekt (rt). Deretter påkaller trådobjektet startmetoden til tråden som videre påberoper løpemetoden til Runnablethread-klassen. Hvis jeg ikke hadde koblet runnable objekt med Thread-objekt, ville trådenes startmetode ha påkalt løpemetoden for Thread-klassen. Nå er det igjen to tråder i koden, hovedtråden og hovedtråden skaper barnetråden, begge blir utført samtidig, men eksakt utgang kan aldri bli utgitt.

Nøkkelfordeler mellom tråd og Runnable i Java

  1. Hver tråd som er opprettet ved å utvide tråkklassen, skaper en unik gjenstand for den og får tilknytning til objektet. På den annen side deler hver tråd som er opprettet ved å implementere et Runnable-grensesnitt, det samme runde-eksemplet.
  2. Siden hver tråd er knyttet til en unik gjenstand når den opprettes ved å utvide Genglass, er det nødvendig med mer minne. På den annen side deler hver tråd opprettet ved å implementere Runnable-grensesnittet samme objekt mellomrom, og det krever derfor mindre minne.
  3. Hvis du utvider Thread-klassen så videre, kan du arve noen annen klasse som Java tillater ikke flere arv, mens implementering av Runnable fortsatt gir en sjanse for at en klasse skal arve noen annen klasse.
  4. Man må bare utvide en trådklasse hvis den må overstyre eller spesialisere noen andre metoder for trådklasse. Du må implementere et Runnable-grensesnitt hvis du bare vil spesialisere løpsmetode bare.
  5. Utvidelse av tråkklassen introduserer stram kobling i koden som koden for tråden og jobben av tråden er inneholdt av samme klasse. På den annen side, implementerer Runnable grensesnitt introduserer løs kobling i koden som koden for tråden er separert fra jobben tildelt til tråden.

Konklusjon:

Det er foretrukket å implementere et Runnable-grensesnitt i stedet for å utvide Genglass. Som implementering Runnable blir koden løst koblet da koden for tråden er forskjellig fra klassen som tilordner jobb til tråden. Det krever mindre minne og tillater også en klasse å arve noen annen klasse.

Top