multithreading java tutorial with examples
Denne vejledning forklarer alt om multithreading i Java, implementering af samtidighed, en tråds livscyklus, trådeksempeleksempel, tråd ved hjælp af Runnable Interface:
Samtidigheden i computerverdenen er et systems evne (det være sig applikation, computer eller programmeringssprog) til at udføre flere forekomster af et program eller en applikation parallelt.
Ved at køre forekomster eller programmer samtidigt sikrer vi høj kapacitet og højere ydeevne, da vi kan udnytte de uudnyttede ressourcer som operativsystemhardware osv. For eksempel, hvis et system har flere CPU'er, kan applikationen udnytte disse CPU'er effektivt og øge kapaciteten.
=> Besøg her for den eksklusive Java-træningsundervisningsserie.
Hvad du lærer:
Hvad er multithreading i Java
I Java kan tråde ses som rygraden i samtidighed. En tråd er en eksekverbar, let enhed, der får adgang til delte ressourcer såvel som sin egen opkaldsstak.
En Java-applikation er en proces, og inden for denne applikation kan vi have flere tråde for at opnå samtidighed.
Vi ved, at et program, der kører på systemet, kan have flere forekomster, og disse kaldes normalt multi-doc-applikationer. Disse applikationsforekomster kaldes processer. Hver af disse processer tildeles en eksekveringsenhed kendt som en tråd.
Afhængigt af operativsystem og applikationskrav kan processen tildeles enten en enkelt tråd eller flere tråde. Når ansøgningsprocessen er tildelt flere tråde, skal vi udføre disse flere tråde samtidigt.
' Denne teknik til at udføre eller køre flere tråde samtidigt eller samtidigt kaldes multithreading . '
Multithreading betyder simpelthen, at-vi har mere end en tråd, der udføres i samme applikation.
Java-programmeringssprog har indbygget understøttelse af multithreading.
Multithreading er afbildet i ovenstående diagram. Som vist er der flere tråde, der kører samtidigt i en applikation.
For eksempel, en desktop-applikation, der leverer funktionalitet som redigering, udskrivning osv., er en multitrådet applikation. I denne applikation, da udskrivning er en baggrundsproces, kan vi udføre redigering af dokumenter og udskrivning af dokumenter samtidigt ved at tildele disse funktioner til to forskellige tråde.
Trådene i flertrådede applikationer kører parallelt med hinanden samtidigt. Multithreading er således også en del af samtidighed i Java. Bemærk, at selvom der er flere tråde, deler de hukommelsesområdet og sparer derved hukommelse. Tråde kan også nemt skifte sammenhæng på ingen tid.
Multithreading er hovedsageligt nyttigt, da det giver samtidig udførelse af to eller flere dele af en applikation. Dette gør det muligt for applikationen at bruge CPU-tiden til sit maksimale, og inaktiv tid holdes på et minimum.
Følgende er nogle af de termer, som vi bør kende i forhold til multithreading-miljøet, da de ofte bruges.
Multitasking: I multitasking udføres mere end en opgave på samme tid.
Multithreading: Multithreading, som allerede nævnt, er en proces til udførelse af flere tråde samtidigt.
selen webdriver interview spørgsmål og svar i 3 års erfaring
Multiprocessing: I multiprocessing udføres mere end en proces samtidigt. Svarende til multitasking, men her er mere end en CPU involveret.
Parallel behandling: Parallel behandling er en teknik, hvor flere CPU'er fungerer samtidigt i et computersystem.
Efter at have diskuteret multithreading opstår spørgsmålet, hvorfor vi overhovedet har brug for multithreading?
Fordele ved multithreading
Multithreading har forskellige fordele, der hjælper med effektiv programmering.
Nedenstående punkter gør det klart.
# 1) Effektiv udnyttelse af enkelt CPU-systemer
Når der kun er en CPU i systemet med en enkelt tråd, spildes CPU-tiden. Når tråden har travlt med at bruge andre ressourcer som IO, er CPU'en inaktiv. Vi kan forbedre dette og bedre udnytte CPU'en ved at have multitrådede applikationer.
Ved at bruge multithreading, hvis en tråd er færdig med CPU, kan den anden tråd bruge den. Med flere tråde reduceres CPU-inaktiv tid kraftigt.
# 2) Effektiv udnyttelse af flere CPU-systemer
Ligesom enkelte CPU'er, selv med systemer med flere CPU'er, er de multitrådede applikationer i stand til at udnytte flere CPU'er effektivt.
# 3) Forbedret brugeroplevelse med hensyn til lydhørhed og retfærdighed
Systemets lydhørhed forbedres med multitrådede applikationer. Vi oplever ikke 'GUI hængende' når vi har flere tråde, der udfører forskellige opgaver i applikationen, og brugerne ikke behøver at vente længe på at få svar på deres anmodninger.
Tilsvarende er brugerne korrekt tjenester i flertrådede systemer.
Sådan implementeres samtidighed i Java
Den første klasse, hvor vi kan implementere samtidighed i Java, er java.lang.Tråd klasse. Denne trådklasse danner grundlaget for samtidighed i Java.
Vi har også java.lang.Køres interface, der kan implementeres af en Java-klasse for at abstrakte trådadfærden. Til avanceret applikationsudvikling kan vi gøre brug af java.util.concurrent pakke tilgængelig siden Java 1.5.
Fremadrettet vil vi diskutere samtidighed i Java i detaljer. Lad os diskutere og forstå begrebet tråde i Java i denne vejledning. I vores efterfølgende tutorials om multithreading vil vi udforske forskellige multithreading- og samtidskoncepter.
Hvad er en tråd i Java
En enkelt tråd kan defineres som den mindste og lette behandlingsenhed. I Java bruges tråde i programmer, der bruger klassen 'Tråd'.
Java-tråde er af to typer:
# 1) Brugertråd: brugertråd oprettes, når applikationen først starter. Derefter kan vi oprette så mange bruger- og dæmontråde.
# 2) Daemon tråd: daemon-tråde bruges hovedsageligt i baggrunden og bruges til opgaver som rengøring af applikationen osv.
Tråde reducerer vedligeholdelsesomkostningerne ved applikationen. Det reducerer også applikationsomkostningerne.
Et eksempel på en enkelt tråd er vist nedenfor:
public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } } Ovenstående program viser “Dette er en tråd” som når applikationen starter oprettes en brugertråd. I ovenstående program er hovedfunktionen startpunktet for applikationen, og den opretter en brugertråd.
En tråds livscyklus
Følgende diagram viser livscyklussen for en tråd i Java.
Som vist i ovenstående diagram har en tråd i Java følgende tilstande:
# 1) Nyt: Oprindeligt har tråden, der netop er oprettet fra trådklassen, en 'ny' tilstand. Det er endnu ikke startet. Denne tråd kaldes også 'Født tråd' .
# 2) Kan køres: I denne tilstand påkaldes forekomsten af en tråd ved hjælp af metoden 'Start' .
# 3) Løb: Trådinstansens startmetode påberåbes, og tråden begynder at udføres. Dette er den kørende tilstand. Planlægger og administrerer hovedsageligt planlægning af tråde.
# 4) Blokeret: Der er flere tråde i en applikation. Disse tråde skal vente på en anden, da deres udførelse skal synkroniseres.
# 5) Afsluttet: Når udførelsesprocessen for tråden er slut, afsluttes tråden, eller dens udførelse stoppes.
Så der oprettes først en tråd, derefter planlægges og senere udfører planlæggeren tråden. Mens den kørende tråd muligvis er blokeret eller suspenderet på grund af anden aktivitet. Derefter genoptages den, og mens behandlingen er afsluttet, udføres tråden.
Trådprioriteter
En trådprioritet bestemmer, hvordan en tråd skal behandles i forhold til de andre tråde i en applikation. En trådprioritet er et heltal.
Nedenfor er nogle punkter, der skal huskes om trådprioriteter:
filinput output c ++
- Trådprioriteter er heltal.
- Ved hjælp af trådprioritet kan vi beslutte, hvornår vi skal skifte fra en tråd i kørende tilstand til en anden. Dette er kontekstskifteprocessen, hvor vi skifter sammenhænge mellem trådene.
- Når som helst en tråd kan frivilligt frigive sin kontrol over CPU. Så kan tråden med den højeste prioritet overtage.
- Tilsvarende kan en tråd med højere prioritet forhindre enhver anden tråd med lavere prioritet.
- Trådklassen giver en setPriority () metode, der bruges til at indstille prioriteten for tråden.
- Vi kan også bruge konstanter MIN_PRIORITY, MAX_PRIORITY eller NORM_PRIORITY i stedet for heltal.
Opret en tråd
Vi kan oprette en tråd på en af følgende måder:
- Udvidelse af klassen Java 'Thread'.
- Implementering af 'Runnable'.
Udvidelse af Java 'Thread' -klassen
Klassen 'Tråd' indeholder konstruktører og metoder, der giver os mulighed for at oprette og udføre operationer på et trådobjekt. Internt implementerer trådklassen Runnable-interface og udvider også objektklassen.
Følgende tabel giver et resumé af forskellige konstruktører og metoder i en tråd () klasse.
| Bygger/ | Prototype | Beskrivelse |
|---|---|---|
| søvn | offentlig ugyldig søvn (lange millisekunder) | Udførelsen af den aktuelle tråd stoppes i specificerede millisekunder. |
| Tråd () konstruktør | Tråd() | Standardkonstruktør til at oprette et trådobjekt. |
| Tråd (strengnavn) | Konstruktør til at oprette et trådobjekt med angivet navn. | |
| Tråd (Runnable r) | Opret en trådforekomst med et specificeret interface, der kan køres. | |
| Tråd (Runnable r, strengnavn) | Opret en trådforekomst med specificeret Runnable interface-objekt og givet navn | |
| løb | offentlig ugyldig kørsel () | Kør-metoden udfører handlingen for en tråd. Påkalder tråden. |
| Start | offentlig ugyldig start () | Bruges til at starte udførelsen af tråden. Internt JVM call run () -metoden på denne tråd. |
| tilslutte | offentlig ugyldig deltagelse () | Vent til tråden dør |
| offentlig ugyldig tilslutning (lange millisekunder) | Vent til specificerede millisekunder, før tråden dør. | |
| getPriority | offentlig int getPriority () | Returner trådprioriteten |
| sætPrioritet | public int setPriority (int-prioritet) | Skift trådprioritet til specificeret prioritet |
| getName | offentlig streng getName () | returner navnet på tråden. |
| sætnavn | public void setName (strengnavn) | Indstil navnet på tråden til den angivne streng |
| nuværende tråd | offentlig tråd aktuel tråd () | Returnerer referencen for den tråd, der aktuelt er aktiv |
| getId | offentlig int getId () | Retur-tråd-id |
| getState () | offentlig tråd.State getState () | Returnerer trådens aktuelle tilstand |
| er i live | offentlig boolsk isAlive () | Kontroller, om tråden er i live, og vend sandt tilbage, hvis ja. |
| udbytte | offentligt ugyldigt udbytte () | Sætter den aktuelle tråd midlertidigt på pause og tillader andre tråde at udføre. |
| isDaemon | offentlig boolsk isDaemon () | Kontroller, om tråden er en dæmontråd; returner sandt, hvis ja. |
| sætDaemon | public void setDaemon (boolsk b) | Indstil tråden som en dæmontråd, hvis b = sand; ellers indstillet som brugertråd. |
| afbryde | offentlig tomrumsafbrydelse () | Afbryd den aktuelle tråd. |
| er afbrudt | offentlig boolsk isInterrupted () | Kontroller, om tråden er afbrudt. |
| afbrudt | offentlig statisk boolsk afbrudt () | Kontroller, om den aktuelle tråd er afbrudt. |
| dumpStack | Statisk ugyldigt dumpStack () | Udskriver et staksspor af den aktuelle tråd til standardfejlstrømmen. |
| suspendere | offentlig ugyldig suspension () | Suspenderer alle tråde. (** Metoden er udfaset i de nyeste Java-versioner) |
| Genoptag | offentligt ugyldigt CV () | Genoptag den suspenderede tråd. (** Metoden er udfaset i de nyeste Java-versioner) |
| hold op | offentligt ugyldigt stop () | Stopper tråden. (** Metoden er udfaset i de nyeste Java-versioner) |
Vi vil uddybe disse trådmetoder i vores næste tutorial om multithreading.
Starter en tråd
Metoden start (), der bruges til at starte tråden, udfører følgende trin:
- Starter en ny trådforekomst med en ny CallStack.
- Trådtilstanden ændres fra ny til kørbar.
- Når det er trådens tur, udfører den metoden run ().
Implementering af det 'Runnable' interface
En trådforekomst kan også oprettes ved hjælp af Runnable-grænsefladen. For at oprette en trådforekomst skal den klasse, hvis objekter skal udføres af en tråd, implementere grænsefladen Runnable.
Runnable-grænsefladen har kun en metode:
public void run () => this method is used to execute the thread. Trådklasseeksempel
Lad os nu demonstrere tråd i Java ved hjælp af 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...'); } } Produktion
Java-tråd ved hjælp af kørbart interface
Det følgende eksempel viser brugen af den Runnable-grænseflade til at oprette 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...'); } }Produktion
Sådan stoppes en tråd i Java
Vi har set eksemplerne på tråden ovenfor. Fra disse eksempler ved vi, at når køremetoden afslutter udførelsen, stopper tråden, eller stopper den også på grund af nogle undtagelser.
Tidligere versioner af Java havde en stop () -metode i trådklasse, der kunne bruges til direkte at stoppe tråden. Men det er nu afskaffet af sikkerhedsmæssige årsager. Derfor er vi nødt til at anvende de andre metoder for at stoppe tråden, der udføres.
Der er to metoder, vi kan bruge til at stoppe tråden.
- Brug af en flygtig boolsk variabel
- Brug af afbrydelser.
I dette afsnit vil vi diskutere begge disse metoder til at stoppe en tråd.
Brug af en flygtig boolsk variabel
I denne metode opretholder vi en boolsk variabel siger flag for at stoppe tråden. Tråden kører, så længe den boolske variabel er indstillet til sand. I det øjeblik det bliver falsk, stoppes tråden.
Specialiteten ved denne metode er, at vi erklærer den boolske variabel som “ flygtige ”Så det altid læses fra hovedhukommelsen, og programmet kan ikke cache det i CPU-cachen. På denne måde vil der ikke være nogen forskel i de værdier, der indstilles og læses.
Implementeringen af at stoppe en tråd ved hjælp af en flygtig 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(); } } Produktion
Bemærk: Her har vi kun vist en del af output. Tråden kan køre i flere minutter, før den stopper. Så vi kan opnå forskellige output på forskellige systemer.
Brug af afbrydelser
Her stoppes tråden ved hjælp af interrupt () -metoden, som vi allerede diskuterede ovenfor i trådklassemetoderne. Interrupt () -metoden indstiller trådens status som afbrudt. Denne status videregives til while-loop i run () -metoden. Vi kan få den afbrudte status ved hjælp af metoden afbrudt ().
Det følgende program demonstrerer brugen af interrupt () -metoden til at 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(); } } Produktion
Ofte stillede spørgsmål
Q # 1) Hvorfor bruger vi Multithreading i Java?
Svar: Multithreading tillader samtidig eller samtidig udførelse af to eller flere tråde i en applikation. Den samtidige udførelse maksimerer gennemløbet og bruger også CPU'en til sit maksimale.
Q # 2) Hvad er multithreading? Hvad er dens typer?
Svar: Multithreading betyder at udføre mere end en tråd. Denne udførelse kan være samtidig eller parallel. Multithreading har således to typer, dvs. samtidig eller parallel.
Q # 3) Hvad er Multithreading vs. Multiprocessing?
Svar: I multithreading er der flere tråde til de samme eller forskellige processer, og disse tråde udføres samtidigt for at forbedre computerens hastighed for et system. I multiprocessing har et system mere end to CPU'er, og flere processer udføres samtidigt.
Q # 4) Hvad er fordelene ved Multithreading i Java?
Svar: Ved hjælp af multithreading kan vi udføre forskellige dele af en applikation samtidigt ved hjælp af tråde. Multithreading øger systemgennemstrømningen. Multithreading maksimerer også CPU-udnyttelse, da forskellige tråde kontinuerligt bruger CPU'en.
Q # 5) Er multithreading god til spil?
Svar: Ja, især til moderne spil.
Konklusion
Dette handler om introduktion af multithreading. Vi har diskuteret samtidigheden og multi-threading i Java i denne vejledning. Vi diskuterede oprettelsen af en tråd med trådklasse samt Runnable-grænsefladen og har givet passende eksempler.
Vi har også lært begreberne med en enkelt tråd og dens oprettelse i detaljer. Trådkoncepterne inklusive en tråds livscyklus, stop af en tråd, trådtyper osv. Er blevet diskuteret i denne vejledning.
Vi diskuterede også multithreading langvarigt og samtidig i Java. I slutningen af denne vejledning skal læseren være i stand til nemt at forstå begreberne samtidighed og multithreading og også tråde i Java.
=> Pas på den enkle Java-træningsserie her.
Anbefalet læsning
- Multithreading i C ++ med eksempler
- Java-tråde med metoder og livscyklus
- Thread.Sleep () - Metode til thread Sleep () i Java med eksempler
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger
- Java Reflection Tutorial med eksempler
- Java String indeholder () Metodevejledning med eksempler
- Jagged Array In Java - Vejledning med eksempler
- Java Scanner-klassevejledning med eksempler