Multitrading i Java Tutorial med eksempler

Ethvert program kan ha flere prosesser (forekomster). Hver av denne prosessen kan tildeles enten som en enkelt tråd eller flere tråder. Vi vil se i denne veiledningen hvordan du kan utføre flere oppgaver samtidig og også lære mer om tråder og synkronisering mellom tråder.

I denne opplæringen vil vi lære:

Hva er enkelt tråd
Hva er Multithreading i Java?
Tråd livssyklus i Java
Java trådsynkronisering
Java Multithreading Eksempel

Hva er en tråd?

En enkelt tråd er i utgangspunktet en lett og den minste prosesseringsenheten. Java bruker tråder ved å bruke en "trådklasse".

Det er to typer tråder - brukertråd og daemon-tråd (daemon-tråder brukes når vi vil rense applikasjonen og brukes i bakgrunnen).

Når et program først begynner, opprettes brukertråd. Legg ut det, vi kan opprette mange brukertråder og daemon-tråder.

Enkelt trådeksempel:

demotest pakke;offentlig klasse GuruThread{public static void main (String [] args) {System.out.println ("Enkel tråd");}}

Fordeler med enkelt tråd:

Reduserer overhead i applikasjonen som enkelt tråd utføres i systemet
Det reduserer også vedlikeholdskostnadene for applikasjonen.

Hva er Multithreading i Java?

MULTITREADING i Java er en prosess for å utføre to eller flere tråder samtidig for maksimal utnyttelse av CPU. Flertrådede applikasjoner kjører to eller flere tråder kjøres samtidig. Derfor er det også kjent som Concurrency i Java. Hver tråd går parallelt med hverandre. Mulitple tråder tildeler ikke eget minneområde, derfor sparer de minne. Det tar også kortere tid å bytte kontekst mellom tråder.

Eksempel på flertrå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ådnavnene følger:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Overstyringoffentlig ugyldig kjøring () {}}

Fordeler med multithread:

Brukerne er ikke blokkert fordi tråder er uavhengige, og vi kan utføre flere operasjoner til tider
Som sådan er trådene uavhengige, og de andre trådene blir ikke berørt hvis en tråd oppfyller et unntak.

Tråd livssyklus i Java

Livssyklusen til en tråd:

Det er forskjellige stadier av trådenes livssyklus som vist i diagrammet ovenfor:

Ny
Kjørbar
Løping
Venter
Død

Nytt: I denne fasen opprettes tråden ved bruk av klasse "Trådklasse". Den forblir i denne tilstanden til programmet starter tråden. Det er også kjent som født tråd.
Kan kjøres: På denne siden påkalles forekomsten av tråden med en startmetode. Trådkontrollen blir gitt til planleggeren for å fullføre utførelsen. Det avhenger av planleggeren, om tråden skal kjøres.
Kjører: Når tråden begynner å kjøres, endres tilstanden til "kjører" -tilstand. Planleggeren velger en tråd fra trådgruppen, og den begynner å kjøres i applikasjonen.
Venter: Dette er tilstanden når en tråd må vente. Siden det kjøres flere tråder i applikasjonen, er det behov for synkronisering mellom tråder. Derfor må den ene tråden vente til den andre tråden blir utført. Derfor blir denne tilstanden referert til som ventetilstand.
Død: Dette er tilstanden når tråden avsluttes. Tråden er i kjører tilstand, og så snart den er ferdigbehandlet er den i "død tilstand".

Noen av de vanligste metodene for tråder er:

Metode	Beskrivelse
start()	Denne metoden starter kjøringen av tråden og JVM kaller metoden run () på tråden.
Søvn (int millisekunder)	Denne metoden får tråden til å sove, og derfor vil trådens utførelse stoppe i millisekunder, og deretter begynner tråden å kjøre igjen. Dette hjelper til med å synkronisere trådene.
getName ()	Den returnerer navnet på tråden.
setPriority (int newpriority)	Det endrer trådens prioritet.
utbytte ()	Det fører til at gjeldende tråd stopper og andre tråder utføres.

Eksempel: I dette eksemplet skal vi lage en tråd og utforske innebygde metoder som er tilgjengelige for tråder.

demotest pakke;public class thread_example1 implementerer Runnable {@Overstyringoffentlig ugyldig kjøring () {}public static void main (String [] args) {Tråd guruthread1 = ny tråd ();guruthread1.start ();prøv {guruthread1.sleep (1000);} fangst (InterruptedException e) {// TODO Auto-generert fangstblokke.printStackTrace ();}guruthread1.setPriority (1);int gurupriority = guruthread1.getPriority ();System.out.println (gurupriority);System.out.println ("Tråd kjører");}}

Forklaring av koden:

Kodelinje 2: Vi lager en klasse "thread_Example1" som implementerer det kjørbare grensesnittet (det skal implementeres av en hvilken som helst klasse hvis forekomster er ment å utføres av tråden.)
Kodelinje 4: Den overstyrer kjøremetoden til det kjørbare grensesnittet, da det er obligatorisk å overstyre den metoden
Kodelinje 6: Her har vi definert hovedmetoden der vi skal starte utførelsen av tråden.
Kodelinje 7: Her lager vi et nytt trådnavn som "guruthread1" ved å starte en ny trådklasse.
Kodelinje 8: vi vil bruke "start" -metoden til tråden ved hjelp av "guruthread1" -forekomst. Her vil tråden begynne å kjøres.
Kodelinje 10: Her bruker vi "sleep" -metoden til tråden ved bruk av "guruthread1" -forekomst. Derfor vil tråden sove i 1000 millisekunder.
Kode 9-14: Her har vi lagt sovemetoden i prøvefangstblokk da det er avkrysset unntak som oppstår dvs. Avbrutt unntak.
Kodelinje 15: Her setter vi prioriteten til tråden til 1 fra hvilken prioritet den var
Kodelinje 16: Her får vi prioritet til tråden ved hjelp av getPriority ()
Kodelinje 17: Her skriver vi ut verdien hentet fra getPriority
Kodelinje 18: Her skriver vi en tekst som tråden kjører.

Når du utfører koden ovenfor, får du følgende utgang:

Produksjon:

5 er trådprioriteten, og trådløp er teksten som er utdataene for koden vår.

Java trådsynkronisering

I multitrading er det programmenes asynkrone oppførsel. Hvis en tråd skriver data og en annen tråd som leser data samtidig, kan det skape inkonsekvens i applikasjonen.

Når det er behov for å få tilgang til de delte ressursene med to eller flere tråder, brukes synkroniseringsmetoden.

Java har gitt synkroniserte metoder for å implementere synkronisert atferd.

Når denne tråden når inn i den synkroniserte blokken, kan ingen andre tråder kalle den metoden på det samme objektet. Alle tråder må vente til den tråden er ferdig med den synkroniserte blokken og kommer ut av den.

På denne måten hjelper synkroniseringen i et flertrådet program. Den ene tråden må vente til den andre tråden er ferdig med utførelsen, så de andre trådene er tillatt for kjøring.

Det kan skrives i følgende form:

Synkronisert (objekt){// Blokk av utsagn som skal synkroniseres}

Java Multithreading Eksempel

I dette eksemplet tar vi to tråder og henter navnene på tråden.

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ådnavnene følger:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Overstyringoffentlig ugyldig kjøring () {}}

Forklaring av koden:

Kodelinje 3: Vi har tatt en klasse "GuruThread1" som implementerer Runnable (den skal implementeres av enhver klasse hvis forekomster er ment å utføres av tråden.)
Kodelinje 8: Dette er hovedmetoden i klassen
Kodelinje 9: Her starter vi trådklassen og lager en forekomst kalt "guruThread1" og lager en tråd.
Kodelinje 10: Her starter vi trådklassen og lager en forekomst kalt en "guruThread2" og lager en tråd.
Kodelinje 11: Vi starter tråden, dvs. guruThread1.
Kodelinje 12: Vi starter tråden, dvs. guruThread2.
Kodelinje 13: Skriver ut teksten som "Trådnavn følger:"
Kodelinje 14: Få navnet på tråd 1 ved hjelp av metoden getName () i trådklassen.
Kodelinje 15: Få navnet på tråd 2 ved hjelp av metoden getName () i trådklassen.

Når du utfører koden ovenfor, får du følgende utgang:

Produksjon:

Trådnavn blir sendt ut her som

Guru1
Guru2

Eksempel 2:

I dette eksemplet vil vi lære om overordnede metoder run () og start () -metoden til et kjørbart grensesnitt og lage to tråder av den klassen og kjøre dem deretter.

Vi tar også to klasser,

En som vil implementere det kjørbare grensesnittet og
En annen som vil ha hovedmetoden og utføre deretter.

demotest pakke;offentlig klasse GuruThread2 {public static void main (String [] args) {// TODO Auto-generert 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;}@Overstyringoffentlig ugyldig kjøring () {System.out.println ("Tråden kjører" + guruname);for (int i = 0; i <4; i ++) {System.out.println (i);System.out.println (guruname);prøv {Tråd. Søvn (1000);} fangst (InterruptedException e) {System.out.println ("Tråden er avbrutt");}}}offentlig ugyldig start () {System.out.println ("Tråden startet");hvis (guruthread == null) {guruthread = new Thread (dette, guruname);guruthread.start ();}}}

Forklaring av koden:

Kodelinje 2: Her tar vi en klasse "GuruThread2" som vil ha hovedmetoden i seg.
Kodelinje 4: Her tar vi en hovedmetode i klassen.
Kodelinje 6-7: Her lager vi en forekomst av klassen GuruThread3 (som er opprettet under linjene i koden) som "threadguru1", og vi starter tråden.
Kodelinje 8-9: Her lager vi en annen forekomst av klasse GuruThread3 (som er opprettet under linjene i koden) som "threadguru2", og vi starter tråden.
Kodelinje 11: Her lager vi en klasse "GuruThread3" som implementerer det kjørbare grensesnittet (det skal implementeres av enhver klasse hvis forekomster er ment å utføres av tråden.)
Kodelinje 13-14: vi tar to klassevariabler som den ene er av typen trådklasse og den andre av strengklassen.
Kodelinje 15-18: Vi overstyrer GuruThread3-konstruktøren, som tar ett argument som strengtype (som er trådnavn) som blir tildelt klassevariabelen guruname, og derfor lagres navnet på tråden.
Kodelinje 20: Her overstyrer vi run () -metoden til det kjørbare grensesnittet.
Kodelinje 21: Vi skriver ut trådnavnet ved hjelp av println-setningen.
Kodelinje 22-31: Her bruker vi en for-løkke med teller initialisert til 0, og den skal ikke være mindre enn 4 (vi kan ta et hvilket som helst tall, her vil løkken løpe 4 ganger) og øke telleren. Vi skriver ut trådnavnet og får også tråden til å sove i 1000 millisekunder i en prøvefangstblokk som søvnmetode hevet avmerket unntak.
Kodelinje 33: Her overstyrer vi startmetoden til det kjørbare grensesnittet.
Kodelinje 35: Vi skriver ut teksten "Tråden startet".
Kodelinje 36-40: Her tar vi en if-betingelse for å sjekke om klassevariabelen guruthread har verdi i seg eller ikke. Hvis det er null, lager vi en forekomst ved hjelp av trådklasse som tar navnet som en parameter (verdien som ble tildelt i konstruktøren). Deretter startes tråden ved hjelp av start () -metoden.

Når du utfører koden ovenfor, får du følgende utdata:

Utgang :

Det er to tråder, vi får to ganger beskjeden "Tråden startet".

Vi får navnene på tråden slik vi har sendt dem ut.

Det går inn i loop der vi skriver ut telleren og trådnavnet og telleren starter med 0.

Sløyfen utføres tre ganger og mellom tråden er sovnet i 1000 millisekunder.

Derfor får vi først guru1 så guru2 og deretter guru2 fordi tråden sover her i 1000 millisekunder og deretter neste guru1 og igjen guru1, tråden sover i 1000 millisekunder, så vi får guru2 og deretter guru1.

Sammendrag :

I denne opplæringen så vi flertrådede applikasjoner i Java og hvordan du bruker enkle og flere tråder.

I flertråding blokkeres ikke brukerne ettersom tråder er uavhengige og kan utføre flere operasjoner om gangen
Ulike stadier av trådenes livssyklus er,
- Ny
- Kjørbar
- Løping
- Venter
- Død
Vi lærte også om synkronisering mellom tråder, noe som hjelper applikasjonen til å kjøre problemfritt.
Multithreading gjør mange flere applikasjonsoppgaver lettere.