Multithreading i Java Tutorial med eksempler

Enhver applikation kan have flere processer (forekomster). Hver af denne proces kan tildeles enten som en enkelt tråd eller flere tråde. Vi vil se i denne vejledning, hvordan du udfører flere opgaver på samme tid og også lærer mere om tråde og synkronisering mellem tråde.

I denne vejledning lærer vi:

Hvad er en enkelt tråd
Hvad er multithreading i Java?
Trådens livscyklus i Java
Java trådsynkronisering
Java-multithreading-eksempel

Hvad er en enkelt tråd?

En enkelt tråd er dybest set en letvægts og den mindste behandlingsenhed. Java bruger tråde ved hjælp af en "trådklasse".

Der er to typer tråd - brugertråd og dæmontråd (dæmontråde bruges, når vi vil rense applikationen og bruges i baggrunden).

Når en applikation først begynder, oprettes brugertråd. Send det, vi kan oprette mange brugertråde og dæmontråde.

Enkelt trådeksempel:

demotest pakke;offentlig klasse GuruThread{public static void main (String [] args) {System.out.println ("Single Thread");}}

Fordele ved en enkelt tråd:

Reducerer overhead i applikationen, da en enkelt tråd udføres i systemet
Det reducerer også vedligeholdelsesomkostningerne ved applikationen.

Hvad er multithreading i Java?

MULTITREADING i Java er en proces til udførelse af to eller flere tråde samtidigt til maksimal udnyttelse af CPU. Multitrådede applikationer udfører to eller flere tråde, der køres samtidigt. Derfor er det også kendt som Concurrency i Java. Hver tråd løber parallelt med hinanden. Mulitple tråde tildeler ikke separat hukommelsesområde, hvorfor de sparer hukommelse. Det tager også kortere tid at skifte kontekst mellem tråde.

Eksempel på multitråd:

demotest pakke;offentlig klasse GuruThread1 implementerer Runnable{public static void main (String [] args) {Tråd guruThread1 = ny tråd ("Guru1");Tråd guruThread2 = ny tråd ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("Trådnavne følger:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Overrideoffentlig ugyldig kørsel () {}}

Fordele ved multithread:

Brugerne er ikke blokeret, fordi tråde er uafhængige, og vi kan til tider udføre flere operationer
Som sådan er trådene uafhængige, de andre tråde påvirkes ikke, hvis en tråd opfylder en undtagelse.

Trådens livscyklus i Java

Trådens livscyklus:

Der er forskellige faser af trådens livscyklus som vist i ovenstående diagram:

Ny
Kan køres
Løb
Venter
Død

Nyt: I denne fase oprettes tråden ved hjælp af klasse "Trådklasse". Den forbliver i denne tilstand, indtil programmet starter tråden. Det er også kendt som født tråd.
Kan køres: På denne side påberåbes forekomsten af tråden med en startmetode. Trådkontrollen gives til planlæggeren for at afslutte udførelsen. Det afhænger af planlæggeren, om tråden skal køres.
Kører: Når tråden begynder at blive udført, ændres tilstanden til "kørende" tilstand. Planlæggeren vælger en tråd fra trådpuljen, og den begynder at udføres i applikationen.
Venter: Dette er den tilstand, hvor en tråd skal vente. Da der kører flere tråde i applikationen, er der behov for synkronisering mellem tråde. Derfor skal den ene tråd vente, indtil den anden tråd bliver udført. Derfor kaldes denne tilstand som ventetilstand.
Død: Dette er tilstanden, når tråden afsluttes. Tråden er i kørende tilstand, og så snart den er færdigbehandlet, er den i "død tilstand".

Nogle af de almindeligt anvendte metoder til tråde er:

Metode	Beskrivelse
Start()	Denne metode starter udførelsen af tråden, og JVM kalder metoden run () på tråden.
Søvn (int millisekunder)	Denne metode får tråden til at sove, hvorfor trådens udførelse stopper i millisekunder, og derefter begynder tråden igen at blive udført. Dette hjælper med at synkronisere trådene.
getName ()	Det returnerer navnet på tråden.
setPriority (int newpriority)	Det ændrer trådens prioritet.
udbytte ()	Det får den aktuelle tråd til standsning og andre tråde til at udføre.

Eksempel: I dette eksempel skal vi oprette en tråd og udforske indbyggede metoder, der er tilgængelige for tråde.

demotest pakke;public class thread_example1 implementerer Runnable {@Overrideoffentlig ugyldig kørsel () {}public static void main (String [] args) {Tråd guruthread1 = ny tråd ();guruthread1.start ();prøve {guruthread1.sleep (1000);} fange (InterruptedException e) {// TODO Auto-genereret fangstbloke.printStackTrace ();}guruthread1.setPriority (1);int gurupriority = guruthread1.getPriority ();System.out.println (guruprioritet);System.out.println ("Tråd kører");}}

Forklaring af koden:

Kodelinje 2: Vi opretter en klasse "thread_Example1", der implementerer den Runnable-grænseflade (den skal implementeres af enhver klasse, hvis forekomster er beregnet til at blive udført af tråden.)
Kodelinje 4: Det tilsidesætter kørselsmetoden for den kørbare grænseflade, da det er obligatorisk at tilsidesætte den metode
Kodelinje 6: Her har vi defineret hovedmetoden, hvor vi starter udførelsen af tråden.
Kodelinje 7: Her opretter vi et nyt trådnavn som "guruthread1" ved at starte en ny trådklasse.
Kodelinje 8: vi bruger "start" -metoden for tråden ved hjælp af "guruthread1" -forekomst. Her begynder tråden at blive udført.
Kodelinje 10: Her bruger vi "sleep" -metoden i tråden ved hjælp af "guruthread1" -forekomsten. Derfor vil tråden sove i 1000 millisekunder.
Kode 9-14: Her har vi lagt sovemetoden i prøvefangstblok, da der er markeret undtagelse, der forekommer, dvs. Afbrudt undtagelse.
Kodelinje 15: Her indstiller vi trådens prioritet til 1, uanset hvilken prioritet den var
Kodelinje 16: Her får vi prioritet for tråden ved hjælp af getPriority ()
Kodelinje 17: Her udskriver vi den værdi, der er hentet fra getPriority
Kodelinje 18: Her skriver vi en tekst, som tråden kører.

Når du udfører ovenstående kode, får du følgende output:

Produktion:

5 er trådprioritet, og trådkørsel er den tekst, der er output af vores kode.

Java trådsynkronisering

I multithreading er der programmernes asynkrone opførsel. Hvis en tråd skriver nogle data og en anden tråd, der læser data på samme tid, kan det skabe uoverensstemmelse i applikationen.

Når der er behov for at få adgang til de delte ressourcer via to eller flere tråde, bruges synkroniseringsmetoden.

Java har leveret synkroniserede metoder til at implementere synkroniseret adfærd.

Når denne tråd når først inden i den synkroniserede blok, kan ingen anden tråd kalde denne metode på det samme objekt. Alle tråde skal vente, indtil tråden afslutter den synkroniserede blok og kommer ud af det.

På denne måde hjælper synkroniseringen i et multitrådet program. Én tråd skal vente, indtil den anden tråd er færdig med udførelsen, så de andre tråde er tilladt til udførelse.

Det kan skrives i følgende form:

Synkroniseret (objekt){// Blok af udsagn, der skal synkroniseres}

Java-multithreading-eksempel

I dette eksempel tager vi to tråde og henter trådens navne.

Eksempel 1:

GuruThread1.javademotest pakke;offentlig klasse GuruThread1 implementerer Runnable {/ *** @param argumenterer* /public static void main (String [] args) {Tråd guruThread1 = ny tråd ("Guru1");Tråd guruThread2 = ny tråd ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("Trådnavne følger:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Overrideoffentlig ugyldig kørsel () {}}

Forklaring af koden:

Kodelinje 3: Vi har taget en klasse "GuruThread1", der implementerer Runnable (den skal implementeres af enhver klasse, hvis forekomster er beregnet til at blive udført af tråden.)
Kodelinje 8: Dette er den vigtigste metode i klassen
Kodelinje 9: Her instantierer vi trådklassen og opretter en instans navngivet som "guruThread1" og opretter en tråd.
Kodelinje 10: Her instantierer vi trådklassen og opretter en instans med navnet "guruThread2" og opretter en tråd.
Kodelinje 11: Vi starter tråden, dvs. guruThread1.
Kodelinje 12: Vi starter tråden, dvs. guruThread2.
Kodelinje 13: Udsendelse af teksten som "Trådnavne følger:"
Kodelinje 14: Få navnet på tråd 1 ved hjælp af metoden getName () i trådklassen.
Kodelinje 15: Få navnet på tråd 2 ved hjælp af metoden getName () i trådklassen.

Når du udfører ovenstående kode, får du følgende output:

Produktion:

Trådnavne udsendes her som

Guru1
Guru2

Eksempel 2:

I dette eksempel lærer vi om overordnede metoder run () og start () -metoden til en kørbar grænseflade og opretter to tråde af den klasse og kører dem i overensstemmelse hermed.

Vi tager også to klasser,

En der vil implementere den kørbare grænseflade og
En anden, som har hovedmetoden og udføres i overensstemmelse hermed.

demotest pakke;offentlig klasse GuruThread2 {public static void main (String [] args) {// TODO Auto-genereret metodestubGuruThread3 threadguru1 = ny GuruThread3 ("guru1");threadguru1.start ();GuruThread3 threadguru2 = ny GuruThread3 ("guru2");threadguru2.start ();}}klasse GuruThread3 implementerer Runnable {Tråd guruthread;private String guruname;GuruThread3 (strengnavn) {guruname = navn;}@Overrideoffentlig ugyldig kørsel () {System.out.println ("Tråd kører" + guruname);for (int i = 0; i <4; i ++) {System.out.println (i);System.out.println (guruname);prøve {Tråd. Søvn (1000);} fange (InterruptedException e) {System.out.println ("Tråden er afbrudt");}}}offentlig ugyldig start () {System.out.println ("Tråd startet");hvis (guruthread == null) {guruthread = ny tråd (dette, guruname);guruthread.start ();}}}

Forklaring af koden:

Kodelinje 2: Her tager vi en klasse "GuruThread2", som vil have hovedmetoden i sig.
Kodelinje 4: Her tager vi en hovedmetode i klassen.
Kodelinje 6-7: Her opretter vi en forekomst af klasse GuruThread3 (som oprettes i nedenstående linier i koden) som "threadguru1", og vi starter tråden.
Kodelinje 8-9: Her opretter vi en anden forekomst af klasse GuruThread3 (som oprettes i nedenstående linier i koden) som "threadguru2", og vi starter tråden.
Kodelinje 11: Her opretter vi en klasse "GuruThread3", der implementerer den kørbare grænseflade (den skal implementeres af enhver klasse, hvis forekomster er beregnet til at blive udført af tråden.)
Kodelinje 13-14: vi tager to klassevariabler, hvoraf den ene er af typen trådklasse og den anden af strengklassen.
Kodelinje 15-18: Vi tilsidesætter GuruThread3-konstruktøren, som tager ét argument som strengtype (som er trådnavn), der tildeles klassevariablen guruname, og derfor lagres navnet på tråden.
Kodelinje 20: Her tilsidesætter vi run () -metoden til den kørbare grænseflade.
Kodelinje 21: Vi udsender trådnavnet ved hjælp af println-sætning.
Kodelinje 22-31: Her bruger vi en for-løkke med tæller initialiseret til 0, og den skal ikke være mindre end 4 (vi kan tage et hvilket som helst tal, her vil løkken løbe 4 gange) og inkrementere tælleren. Vi udskriver trådnavnet og får også tråden til at sove i 1000 millisekunder inden for en prøvefangstblok, da søvnmetoden hævede markeret undtagelse.
Kodelinje 33: Her tilsidesætter vi startmetoden til den kørbare grænseflade.
Kodelinje 35: Vi udsender teksten "Tråd startet".
Kodelinje 36-40: Her tager vi en if-betingelse for at kontrollere, om klassevariablen guruthread har værdi i sig eller ikke. Hvis det er null, opretter vi en forekomst ved hjælp af trådklasse, der tager navnet som en parameter (værdi, som der blev tildelt i konstruktøren). Herefter startes tråden ved hjælp af start () -metoden.

Når du udfører ovenstående kode, får du følgende output:

Output :

Der er to tråde, derfor får vi to gange beskeden "Tråd startet".

Vi får navnene på tråden, som vi har sendt dem ud.

Det går ind i loop, hvor vi udskriver tælleren, og trådnavnet og tælleren starter med 0.

Sløjfen udføres tre gange og imellem soves tråden i 1000 millisekunder.

Derfor får vi først guru1, så guru2 og derefter igen guru2, fordi tråden sover her i 1000 millisekunder og derefter næste guru1 og igen guru1, tråden sover i 1000 millisekunder, så vi får guru2 og derefter guru1.

Resume :

I denne vejledning så vi multitrådede applikationer i Java og hvordan man bruger enkelt- og multitråde.

I multithreading blokeres brugere ikke, da tråde er uafhængige og kan udføre flere operationer ad gangen
Forskellige faser af trådens livscyklus er,
- Ny
- Kan køres
- Løb
- Venter
- Død
Vi lærte også om synkronisering mellem tråde, som hjælper applikationen med at køre problemfrit.
Multithreading gør mange flere applikationsopgaver lettere.