multithreading java tutorial with examples
Denne opplæringen forklarer alt om flertråding i Java, implementering av samtidighet, livssyklusen til en tråd, trådklasseeksempel, tråd ved bruk av kjørbart grensesnitt:
Samtidigheten i datamaskinverdenen er evnen til et system (det være seg applikasjon, datamaskin eller programmeringsspråk) til å utføre flere forekomster av et program eller en applikasjon parallelt.
Ved å kjøre forekomster eller programmer samtidig, sikrer vi høy gjennomstrømning og høyere ytelse, ettersom vi kan utnytte uutnyttede ressurser som operativsystemmaskinvare etc. For eksempel, Hvis et system har flere CPUer, kan applikasjonen utnytte disse CPUene effektivt og øke gjennomstrømningen.
=> Besøk her for den eksklusive opplæringsserien for Java Training.
Hva du vil lære:
Hva er multitrading i Java
I Java kan tråder sees på som ryggraden i samtidighet. En tråd er en kjørbar, lett enhet som får tilgang til delte ressurser så vel som sin egen samtalestabel.
En Java-applikasjon er en prosess, og i denne applikasjonen kan vi ha flere tråder for å oppnå samtidighet.
Vi vet at et program som kjører på systemet kan ha flere forekomster, og disse kalles vanligvis multi-doc-applikasjoner. Disse applikasjonsforekomstene kalles prosesser. Hver av disse prosessene tildeles en kjøringsenhet kjent som en tråd.
Avhengig av operativsystem og applikasjonskrav, kan prosessen tildeles enten en enkelt tråd eller flere tråder. Når søknadsprosessen er tildelt flere tråder, må vi utføre disse flere tråder samtidig.
' Denne teknikken for å utføre eller kjøre flere tråder samtidig eller samtidig er kjent som multithreading . '
Multitrading betyr ganske enkelt at vi har mer enn en tråd som kjøres i samme applikasjon.
Java-programmeringsspråk har innebygd støtte for multithreading.
Multitråding er avbildet i diagrammet ovenfor. Som vist er det flere tråder som kjører samtidig i et program.
For eksempel, et skrivebordsprogram som gir funksjonalitet som redigering, utskrift, etc. er et multitrådet program. I dette programmet, siden utskrift er en bakgrunnsprosess, kan vi redigere dokumenter og skrive ut dokumenter samtidig ved å tildele disse funksjonene til to forskjellige tråder.
Trådene i flertrådede applikasjoner går parallelt med hverandre samtidig. Dermed er multithreading også en del av samtidighet i Java. Merk at selv om det er flere tråder, deler de minneområdet og sparer dermed minne. Tråder kan også enkelt bytte kontekst på kort tid.
Multithreading er hovedsakelig nyttig ettersom det gir samtidig kjøring av to eller flere deler av en applikasjon. Dette lar applikasjonen bruke CPU-tiden til sitt maksimale og inaktivitet holdes på et minimum.
Følgende er noen av begrepene vi bør kjenne til i forhold til flertrådingsmiljøet, ettersom de ofte brukes.
Multitasking: I multitasking utføres mer enn en oppgave samtidig.
Multitrading: Multithreading, som allerede nevnt, er en prosess for å utføre flere tråder samtidig.
boble sortering c ++ eksempel
Multiprosessering: Ved flerbehandling utføres mer enn en prosess samtidig. I likhet med multitasking, men her er mer enn en CPU involvert.
Parallell behandling: Parallellbehandling er en teknikk der flere CPUer fungerer samtidig i et datasystem.
Etter å ha diskutert multitråding, oppstår spørsmålet om hvorfor vi i det hele tatt trenger multitråding?
Fordeler med multithreading
Multithreading har forskjellige fordeler som hjelper til med effektiv programmering.
Punktene nedenfor vil gjøre det klart.
# 1) Effektiv bruk av enkelt CPU-systemer
Når det bare er en CPU i systemet, med en enkelt tråd, blir CPU-tiden bortkastet. Når tråden er opptatt med å bruke andre ressurser som IO, er CPU-en inaktiv. Vi kan forbedre dette og bedre bruke CPU ved å ha flertrådede applikasjoner.
Ved å bruke multitrading, hvis en tråd er ferdig med CPU, kan den andre tråden bruke den. Med flere tråder vil CPU-inaktivitetstid reduseres kraftig.
# 2) Effektiv bruk av flere CPU-systemer
Akkurat som enkelt-prosessorer, selv med systemer som har flere prosessorer, kan de flertrådede applikasjonene bruke flere prosessorer effektivt.
# 3) Forbedret brukeropplevelse med hensyn til respons og rettferdighet
Responsen til systemet forbedres med flertrådede applikasjoner. Vi opplever ikke 'GUI hengende' når vi har flere tråder som utfører forskjellige oppgaver i applikasjonen, og brukerne ikke trenger å vente lenge på å få svar på deres forespørsler.
Tilsvarende er brukerne ordentlig tjenester i flertrådede systemer.
Hvordan implementere samtidighet i Java
Den første klassen som vi kan implementere samtidighet i Java er java.lang.Tråd klasse. Denne trådklassen danner grunnlaget for samtidighet i Java.
Vi har også java.lang.Runnable grensesnitt som kan implementeres av en Java-klasse for å abstrakte trådens oppførsel. For avansert applikasjonsutvikling kan vi benytte oss av java.util.concurrent pakke tilgjengelig siden Java 1.5.
Fremover vil vi diskutere samtidighet i Java i detalj. La oss diskutere og forstå begrepet tråder i Java i denne opplæringen. I våre påfølgende opplæringsprogrammer om multitråding vil vi utforske ulike flertråding og samtidighetskonsepter.
Hva er en tråd i Java
En enkelt tråd kan defineres som den minste og lette prosesseringsenheten. I Java brukes tråder i programmer som bruker klassen ‘Thread’.
Java-tråder er av to typer:
# 1) Brukertråd: brukertråd opprettes når applikasjonen først starter. Da kan vi opprette så mange bruker- og daemon-tråder.
# 2) Daemon-tråd: daemon-tråder brukes hovedsakelig i bakgrunnen og brukes til oppgaver som å rengjøre applikasjonen, etc.
Tråder reduserer vedlikeholdskostnadene for applikasjonen. Det reduserer også applikasjonsomkostningene.
Et enkelt trådeksempel er vist nedenfor:
public class Main{ public static void main (String [] args){ System.out.println('This is a thread'); } }
Ovennevnte program vil vise 'Dette er en tråd' som når applikasjonen starter, blir en brukertråd opprettet. I programmet ovenfor er hovedfunksjonen startpunktet for applikasjonen, og den lager en brukertråd.
Livssyklusen til en tråd
Følgende diagram viser livssyklusen til en tråd i Java.
Som vist i diagrammet ovenfor har en tråd i Java følgende tilstander:
# 1) Nytt: Opprinnelig har tråden nettopp opprettet fra trådklassen en ‘ny’ tilstand. Det er ennå ikke startet. Denne tråden kalles også ‘Born thread’ .
# 2) Kjørbar: I denne tilstanden påkalles forekomsten av en tråd ved hjelp av metoden 'start' .
# 3) Løping: Trådforekomstens startmetode påkalles og tråden begynner å kjøres. Dette er den løpende tilstanden. For det meste planlegger og administrerer planleggere trådene.
# 4) Blokkert: Det er flere tråder i et program. Disse trådene må vente på en annen ettersom utførelsen må synkroniseres.
# 5) Avsluttet: Når kjøringsprosessen til tråden er over, blir tråden avsluttet eller kjøringen stoppet.
Så en tråd blir først opprettet, deretter planlagt og senere utfører planleggeren tråden. Mens den løpende tråden kan være blokkert eller suspendert på grunn av annen aktivitet. Deretter gjenopptas den og mens behandlingen er fullført, blir tråden utført.
Trådprioriteter
En trådprioritet avgjør hvordan en tråd skal behandles med hensyn til de andre trådene i en applikasjon. En trådprioritet er et heltall.
Nedenfor er noen punkter du må huske på trådprioriteter:
- Trådprioritetene er heltall.
- Ved å bruke trådprioritet kan vi bestemme når vi skal bytte fra en tråd i løpende tilstand til en annen. Dette er kontekstvekslingsprosessen der vi bytter sammenheng av trådene.
- Når som helst kan en tråd frivillig frigjøre kontrollen over CPU. Da kan tråden med høyest prioritet ta over.
- Tilsvarende kan en tråd med høyere prioritet forhindre enhver annen tråd med lavere prioritet.
- Trådklassen gir en setPriority () -metode som brukes til å angi prioriteten for tråden.
- Vi kan også bruke konstanter MIN_PRIORITY, MAX_PRIORITY eller NORM_PRIORITY i stedet for heltall.
Lag en tråd
Vi kan lage en tråd på en av følgende måter:
- Utvide klassen Java ‘Thread’.
- Implementering ‘Runnable’.
Utvide Java-tråden
Klassen ‘Thread’ inneholder konstruktørene og metodene som lar oss lage og utføre operasjoner på et trådobjekt. Internt implementerer trådklassen Runnable interface og utvider også objektklassen.
Den følgende tabellen gir et sammendrag av forskjellige konstruktører og metoder for en tråd () klasse.
Bygger/ | Prototype | Beskrivelse |
---|---|---|
sove | offentlig ugyldig søvn (lange millisekunder) | Utførelsen av gjeldende tråd stoppes i spesifiserte millisekunder. |
Tråd () konstruktør | Tråd() | Standardkonstruktør for å lage et trådobjekt. |
Tråd (strengnavn) | Konstruktør for å lage et trådobjekt med spesifisert navn. | |
Tråd (Runnable r) | Opprett en trådforekomst med spesifisert kjørbart grensesnittobjekt. | |
Tråd (kjørbar r, strengnavn) | Opprett en trådforekomst med spesifisert kjørbart grensesnittobjekt og gitt navn | |
løpe | offentlig tomromkjøring () | Kjør metoden utfører handlingen for en tråd. Påkaller tråden. |
start | offentlig ugyldig start () | Brukes til å starte utførelsen av tråden. Internt kjører JVM-samtalene run () -metoden på denne tråden. |
bli med | offentlig ugyldig delta () | Vent til tråden dør |
offentlig ugyldig tilknytning (lange millisekunder) | Vent til spesifiserte millisekunder for at tråden skal dø. | |
getPriority | offentlig int getPriority () | Returner trådprioriteten |
settPrioritet | public int setPriority (int-prioritet) | Endre trådprioriteten til angitt prioritet |
getName | offentlig streng getName () | returner navnet på tråden. |
setName | public void setName (strengnavn) | Sett navnet på tråden til spesifisert streng |
gjeldende tråd | offentlig tråd gjeldende tråd () | Returnerer referansen til tråden som er aktiv for øyeblikket |
getId | offentlig int getId () | Retur tråd Id |
getState () | offentlig tråd.State getState () | Returnerer gjeldens nåværende tilstand |
er i live | offentlig boolsk isAlive () | Sjekk om tråden er i live og returner sann hvis ja. |
utbytte | offentlig ugyldig avkastning () | Pauser gjeldende tråd midlertidig og lar andre tråder utføre. |
isDaemon | offentlig boolsk isDaemon () | Sjekk om tråden er en demonstråd; returner sann hvis ja. |
setDaemon | public void setDaemon (boolsk b) | Sett tråden som en demonstråd hvis b = sant; annet angitt som brukertråd. |
avbryte | offentlig ugyldig avbrudd () | Avbryt gjeldende tråd. |
er avbrutt | public boolean isInterrupted () | Sjekk om tråden er avbrutt. |
avbrutt | offentlig statisk boolsk avbrutt () | Sjekk om gjeldende tråd er avbrutt. |
dumpStack | Statisk tomrom dumpStack () | Skriver ut en stakkspor av gjeldende tråd til standard feilstrøm. |
utsette | offentlig ugyldig suspendere () | Suspenderer alle tråder. (** metoden avvikles i de nyeste Java-versjonene) |
gjenoppta | offentlig ugyldig CV () | Gjenoppta suspendert tråd. (** metoden avvikles i de nyeste Java-versjonene) |
Stoppe | offentlig ugyldig stopp () | Stopper tråden. (** metoden avvikles i de nyeste Java-versjonene) |
Vi vil utdype disse trådmetodene i vår neste opplæring om multitrading.
Starter en tråd
Metoden start () som brukes til å starte tråden, utfører følgende trinn:
- Starter en ny trådforekomst med en ny CallStack.
- Trådtilstanden endres fra ny til kjørbar.
- Når det er trådens tur, kjører den run () -metoden.
Implementering av det 'Runnable' grensesnittet
En trådforekomst kan også opprettes ved hjelp av Runnable-grensesnittet. For å opprette en trådforekomst, skal klassen hvis objekter skal kjøres av en tråd implementere Runnable-grensesnittet.
Runnable-grensesnittet har bare en metode:
public void run () => this method is used to execute the thread.
Trådklasseeksempel
La oss nå demonstrere tråden i Java ved hjelp av trådklasse.
//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String [] args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } }
Produksjon
Java-tråd ved bruk av kjørbart grensesnitt
Følgende eksempel viser bruken av Runnable-grensesnittet for å opprette en trådforekomst.
//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String [] args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }
Produksjon
Hvordan stoppe en tråd i Java
Vi har sett trådeksemplene ovenfor. Fra disse eksemplene vet vi at når kjøremetoden er ferdig med kjøringen, stopper tråden eller stopper den også på grunn av noen unntak.
Tidligere versjoner av Java hadde en stop () -metode i trådklassen som kunne brukes til å stoppe tråden direkte. Men det er nå avskrevet av sikkerhetsmessige årsaker. Derfor må vi bruke de andre metodene for å stoppe tråden som kjøres.
Det er to metoder vi kan bruke for å stoppe tråden.
- Ved hjelp av en flyktig boolsk variabel
- Bruke Interrupts.
I denne delen vil vi diskutere begge disse metodene for å stoppe en tråd.
Bruke en flyktig boolsk variabel
I denne metoden opprettholder vi en boolsk variabel si flagg, for å stoppe tråden. Tråden går så lenge den boolske variabelen er satt til sann. I det øyeblikket det blir falskt, stoppes tråden.
Spesialiteten til denne metoden er at vi erklærer den boolske variabelen som “ flyktige ”Slik at det alltid blir lest fra hovedminnet og programmet ikke kan cache det i CPU-cachen. På denne måten vil det ikke være noen forskjell i verdiene som er satt og lest.
Implementeringen av å stoppe en tråd ved hjelp av en flyktig boolsk variabel er vist nedenfor.
class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String[] args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } }
Produksjon
Merk: Her har vi bare vist en del av produksjonen. Tråden kan gå i flere minutter før den stopper. Slik at vi kan oppnå forskjellig produksjon på forskjellige systemer.
Bruke Interrupts
Her stoppes tråden ved hjelp av interrupt () -metoden som vi allerede diskuterte ovenfor i trådklassemetodene. Interrupt () -metoden setter statusen til tråden som avbrutt. Denne statusen overføres til while-løkken til run () -metoden. Vi kan oppnå avbrutt status ved hjelp av avbrutt () -metoden.
Det følgende programmet viser bruken av interrupt () -metoden for å stoppe tråden.
class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String[] args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } }
Produksjon
java legg til i slutten av matrisen
ofte stilte spørsmål
Q # 1) Hvorfor bruker vi Multithreading i Java?
Svar: Multithreading tillater samtidig eller samtidig kjøring av to eller flere tråder i et program. Den samtidige kjøringen maksimerer gjennomstrømningen og bruker også CPUen maksimalt.
Spørsmål 2) Hva er flertråding? Hva er typene?
Svar: Multitrading betyr å utføre mer enn en tråd. Denne utførelsen kan være samtidig eller parallell. Multithreading har således to typer, dvs. samtidig eller parallell.
Spørsmål nr. 3) Hva er multithreading vs. multiprosessering?
Svar: I flertråding er det flere tråder for de samme eller forskjellige prosessene, og disse trådene kjøres samtidig for å forbedre beregningshastigheten til et system. I flerbehandling har et system mer enn to CPUer, og flere prosesser kjøres samtidig.
Q # 4) Hva er fordelene med Multithreading i Java?
Svar: Ved å bruke multitrading kan vi utføre forskjellige deler av et program samtidig ved hjelp av tråder. Multithreading øker systemgjennomstrømningen. Multithreading maksimerer også CPU-utnyttelse ettersom forskjellige tråder kontinuerlig bruker CPU.
Q # 5) Er multithreading bra for spill?
Svar: Ja, spesielt for moderne spill.
Konklusjon
Dette handler om innføring av multithreading. Vi har diskutert samtidigheten og multi-threading i Java i denne opplæringen. Vi diskuterte etableringen av en tråd med trådklasse samt Runnable-grensesnittet og har gitt passende eksempler.
Vi har også lært konseptene til en enkelt tråd og dens oppretting i detalj. Trådkonseptene, inkludert livssyklusen til en tråd, stopp av en tråd, typer tråder, etc. har blitt diskutert i denne opplæringen.
Vi diskuterte også multitrading i lengde og samtidighet i Java. På slutten av denne opplæringen skal leseren være i stand til enkelt å forstå begrepene samtidighet og multitråding og også tråder i Java.
=> Se opp den enkle Java-treningsserien her.
Anbefalt lesing
- Multitrading i C ++ med eksempler
- Java-tråder med metoder og livssyklus
- Thread.Sleep () - Thread Sleep () Metode i Java med eksempler
- JAVA-opplæring for nybegynnere: 100+ praktiske Java-videoveiledninger
- Java Reflection Tutorial med eksempler
- Java String inneholder () Metodeopplæring med eksempler
- Jagged Array In Java - Opplæring med eksempler
- Java-skanner klasseveiledning med eksempler