multithreading java tutorial with examples
Denna handledning förklarar allt om multitrådning i Java, implementering av samtidighet, livscykeln för en tråd, trådklassexempel, tråd med körbart gränssnitt:
Samtidigheten i datorvärlden är förmågan hos ett system (vare sig det är applikation, dator eller programmeringsspråk) att utföra flera instanser av ett program eller en applikation parallellt.
Genom att köra instanser eller program samtidigt säkerställer vi hög genomströmning och högre prestanda eftersom vi kan använda de outnyttjade resurserna som operativsystemets hårdvara etc. Till exempel, om ett system har flera processorer kan applikationen använda dessa processorer effektivt och öka genomströmningen.
=> Besök här för den exklusiva Java-utbildningsserien.
Vad du kommer att lära dig:
Vad är multithreading i Java
I Java kan trådar ses som ryggraden för samtidighet. En tråd är en körbar, lätt enhet som har åtkomst till delade resurser såväl som sin egen samtalsstack.
En Java-applikation är en process och inom denna applikation kan vi ha flera trådar för att uppnå samtidighet.
Vi vet att en applikation som körs på systemet kan ha flera instanser och dessa kallas vanligtvis multi-doc-applikationer. Dessa applikationsinstanser kallas processer. Var och en av dessa processer tilldelas en exekveringsenhet som kallas en tråd.
Beroende på operativsystem och applikationskrav kan processen tilldelas antingen en enda tråd eller flera trådar. När ansökningsprocessen har tilldelats flera trådar måste vi köra dessa flera trådar samtidigt.
' Denna teknik för att utföra eller köra flera trådar samtidigt eller samtidigt kallas multithreading . '
Multitrådning betyder helt enkelt att vi har mer än en tråd som körs i samma applikation.
Java-programmeringsspråk har inbyggt stöd för multithreading.
Multitrådning avbildas i ovanstående diagram. Som visat finns det flera trådar som körs samtidigt i en applikation.
Till exempel, en stationär applikation som tillhandahåller funktioner som redigering, utskrift etc. är en multitrådad applikation. I den här applikationen, eftersom utskrift är en bakgrundsprocess, kan vi redigera dokument och skriva ut dokument samtidigt genom att tilldela dessa funktioner till två olika trådar.
Trådarna i flertrådade applikationer löper parallellt med varandra samtidigt. Således är multithreading också en del av samtidigheten i Java. Observera att även om det finns flera trådar, delar de minnesområdet och sparar därmed minne. Trådar kan också enkelt byta sammanhang på nolltid.
Multithreading är huvudsakligen användbart eftersom det ger samtidig körning av två eller flera delar av en applikation. Detta låter applikationen utnyttja CPU-tiden till dess maximala och tomgångstiden hålls på ett minimum.
Följande är några av de termer som vi borde känna till i förhållande till flertrådsmiljön eftersom de används ofta.
Göra flera saker samtidigt: I multitasking körs mer än en uppgift samtidigt.
Multithreading: Multithreading, som redan nämnts, är en process för att köra flera trådar samtidigt.
programvara för försäljning för iPad
Multiprocessing: Vid multiprocessing utförs mer än en process samtidigt. Liknar multitasking, men här är mer än en CPU inblandad.
Parallell bearbetning: Parallell bearbetning är en teknik där flera processorer arbetar samtidigt i ett datorsystem.
Efter att ha diskuterat multithreading uppstår frågan varför vi alls behöver multithreading?
Fördelar med multithreading
Multithreading har olika fördelar som hjälper till med effektiv programmering.
Nedanstående punkter kommer att göra det tydligt.
# 1) Effektiv användning av enstaka CPU-system
När det bara finns en CPU i systemet, med en enda tråd, går CPU-tiden bort. När tråden är upptagen med att använda andra resurser som IO, är CPU inaktiv. Vi kan förbättra detta och bättre använda CPU: n genom att ha flera trådade applikationer.
Genom att använda multitrådning, om en tråd är klar med CPU, kan den andra tråden använda den. Med flera trådar kommer CPU-tomgångstiden att minskas kraftigt.
# 2) Effektiv användning av flera CPU-system
Precis som enstaka processorer, även med system som har flera processorer, kan de flertrådade applikationerna använda flera processorer effektivt.
# 3) Förbättrad användarupplevelse med avseende på lyhördhet och rättvisa
Lyhördheten hos systemet förbättras med flertrådade applikationer. Vi upplever inte 'GUI hängande' när vi har flera trådar som utför olika uppgifter i applikationen och användarna inte behöver vänta länge för att få svar på deras önskemål.
På samma sätt är användarna korrekt tjänster i flertrådade system.
Hur man implementerar samtidighet i Java
Den första klassen med vilken vi kan implementera samtidighet i Java är java.lang.Tråd klass. Denna trådklass utgör grunden för samtidighet i Java.
Vi har också java.lang.Runnable gränssnitt som kan implementeras av en Java-klass för att abstrakta trådbeteendet. För avancerad applikationsutveckling kan vi använda java.util.concurrent paket tillgängligt sedan Java 1.5.
Framåt kommer vi att diskutera samtidighet i Java i detalj. Låt oss diskutera och förstå begreppet trådar i Java i denna handledning. I våra efterföljande handledning om multithreading kommer vi att utforska olika multithreading- och concurrency-koncept.
Vad är en tråd i Java
En enda tråd kan definieras som den minsta och lätta bearbetningsenheten. I Java används trådar i program som använder klassen ”Tråd”.
Java-trådar är av två typer:
# 1) Användartråd: användartråd skapas när applikationen startar. Då kan vi skapa så många användare och daemon trådar.
# 2) Daemon-tråd: daemon-trådar används främst i bakgrunden och används för uppgifter som att rengöra applikationen etc.
Trådar minskar underhållskostnaden för applikationen. Det minskar också applikationsomkostnaderna.
Ett exempel på en enda tråd visas nedan:
public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } } Ovanstående program visar “This is a thread” som när applikationen startar skapas en användartråd. I ovanstående program är huvudfunktionen startpunkten för applikationen och den skapar en användartråd.
Livscykeln för en tråd
Följande diagram visar livscykeln för en tråd i Java.
Som visas i ovanstående diagram har en tråd i Java följande tillstånd:
# 1) Nytt: Inledningsvis har den tråd som just skapats från trådklassen ett ”nytt” tillstånd. Det är ännu inte startat. Denna tråd kallas också ”Född tråd” .
# 2) Kan köras: I detta tillstånd åberopas förekomsten av en tråd med metoden 'Start' .
# 3) Löpning: Trådinstansens startmetod åberopas och tråden börjar köras. Detta är det löpande tillståndet. Schemaläggare planerar och hanterar oftast trådarna.
# 4) Blockerad: Det finns flera trådar i en applikation. Dessa trådar måste vänta på en annan eftersom deras körning måste synkroniseras.
# 5) Avslutad: När körningsprocessen för tråden är över avslutas tråden eller körningen stoppas.
Så en tråd skapas först, sedan planeras och senare kör schemaläggaren tråden. Medan den löpande tråden kan blockeras eller avbrytas för någon annan aktivitet. Sedan återupptas den och medan bearbetningen är klar körs tråden.
Trådprioriteter
En trådprioritet avgör hur en tråd ska behandlas med avseende på de andra trådarna i en applikation. En trådprioritet är ett heltal.
Nedan listas några punkter att komma ihåg när det gäller trådprioriteringar:
- Trådprioriteringar är heltal.
- Med hjälp av trådprioritet kan vi bestämma när vi ska byta från en tråd i löpande tillstånd till en annan. Detta är kontextväxlingsprocessen där vi byter sammanhang för trådarna.
- När som helst kan en tråd frivilligt släppa sin kontroll över CPU. Då kan tråden med högsta prioritet ta över.
- På samma sätt kan en tråd med högre prioritet förhindra alla andra trådar med lägre prioritet.
- Trådklassen tillhandahåller en setPriority () -metod som används för att ställa in prioriteten för tråden.
- Vi kan också använda konstanterna MIN_PRIORITY, MAX_PRIORITY eller NORM_PRIORITY istället för heltal.
Skapa en tråd
Vi kan skapa en tråd på något av följande sätt:
- Utöka klassen Java 'Thread'.
- Implementering av 'Runnable'.
Utöka Java-tråden
Klassen ”Tråd” innehåller konstruktörer och metoder som gör att vi kan skapa och utföra operationer på ett trådobjekt. Internt implementerar trådklassen Runnable-gränssnitt och utökar också objektklassen.
Följande tabell ger en sammanfattning av olika konstruktörer och metoder för en Thread () -klass.
| Byggare/ | Prototyp | Beskrivning |
|---|---|---|
| sova | allmän ogiltig sömn (långa millisekunder) | Körningen av den aktuella tråden stoppas under angivna millisekunder. |
| Tråd () konstruktör | Tråd() | Standardkonstruktör för att skapa ett trådobjekt. |
| Tråd (strängnamn) | Konstruktör för att skapa ett trådobjekt med angivet namn. | |
| Gänga (körbar r) | Skapa en trådinstans med angivet körbart gränssnittsobjekt. | |
| Tråd (körbar r, strängnamn) | Skapa en trådinstans med angivet körbart gränssnittsobjekt och förnamn | |
| springa | offentlig ogiltig körning () | Körmetoden utför åtgärden för en tråd. Anropar tråden. |
| Start | offentlig ogiltig start () | Används för att starta körningen av tråden. Internt JVM-samtal kör () -metoden på den här tråden. |
| Ansluta sig | public void join () | Vänta tills tråden dör |
| public void join (långa millisekunder) | Vänta i angivna millisekunder tills tråden dör. | |
| getPriority | public int getPriority () | Återställ trådprioriteten |
| prioritera | public int setPriority (int-prioritet) | Ändra trådprioritet till angiven prioritet |
| hämta namn | offentlig sträng getName () | returnera namnet på tråden. |
| Ange namn | public void setName (strängnamn) | Ställ in namnet på tråden till angiven sträng |
| currentThread | offentlig tråd aktuellTråd () | Returnerar referensen för den tråd som är aktiv för närvarande |
| getId | public int getId () | Return tråd Id |
| getState () | offentlig tråd.State getState () | Returnerar trådens aktuella tillstånd |
| lever | public boolean isAlive () | Kontrollera om tråden lever och returnera true om ja. |
| avkastning | offentlig ogiltig avkastning () | Pausar den aktuella tråden tillfälligt och låter andra trådar köras. |
| isDaemon | public boolean isDaemon () | Kontrollera om tråden är en daemontråd; återvänd sant om ja. |
| setDaemon | public void setDaemon (boolean b) | Ställ in tråden som en demontråd om b = true; annars anges som användartråd. |
| avbryta | offentligt tomrumsavbrott () | Avbryt den aktuella tråden. |
| är avbruten | public boolean isInterrupted () | Kontrollera om tråden är avbruten. |
| avbröts | offentlig statisk boolesk avbruten () | Kontrollera om den aktuella tråden har avbrutits. |
| dumpStack | Statisk ogiltig dumpStack () | Skriver ut en stapelspårning av den aktuella tråden till standardfelströmmen. |
| uppskjuta | offentligt ogiltigt upphäva () | Stänger av alla trådar. (** metoden har upphört att gälla i de senaste Java-versionerna) |
| återuppta | offentligt ogiltigt CV () | Återuppta upphängd tråd. (** metoden har upphört att gälla i de senaste Java-versionerna) |
| sluta | offentligt ogiltigt stopp () | Stoppar tråden. (** metoden har upphört att gälla i de senaste Java-versionerna) |
Vi kommer att utarbeta dessa trådmetoder i vår nästa handledning om multithreading.
Startar en tråd
Metoden start () som används för att starta tråden utför följande steg:
- Startar en ny trådinstans med en ny CallStack.
- Trådtillståndet ändras från nytt till körbart.
- När det är trådens tur körs metoden run ().
Implementering av det 'körbara' gränssnittet
En trådinstans kan också skapas med Runnable-gränssnittet. För att skapa en trådinstans bör klassen vars objekt ska köras av en tråd implementera Runnable-gränssnittet.
Det körbara gränssnittet har bara en metod:
public void run () => this method is used to execute the thread. Trådklasssexempel
Låt oss nu visa tråd i Java med hjälp av trådklass.
//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 med hjälp av körbart gränssnitt
Följande exempel visar användningen av Runnable-gränssnittet för att skapa en trådinstans.
//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
Hur man stoppar en tråd i Java
Vi har sett trådexemplen ovan. Från dessa exempel vet vi att när körmetoden är klar körningen, stoppar tråden eller stoppas den också på grund av vissa undantag.
Tidigare versioner av Java hade en stop () -metod i trådklassen som kunde användas för att stoppa tråden direkt. Men det har nu avskaffats av säkerhetsskäl. Således måste vi använda de andra metoderna för att stoppa tråden som körs.
Det finns två metoder vi kan använda för att stoppa tråden.
- Använda en flyktig boolesk variabel
- Använda avbrott.
I det här avsnittet kommer vi att diskutera båda dessa metoder för att stoppa en tråd.
Använda en flyktig boolsk variabel
I den här metoden upprätthåller vi en boolean variabel säger flagga för att stoppa tråden. Tråden körs så länge den booleska variabeln är satt till true. I det ögonblick det blir falskt stoppas tråden.
Specialiteten med denna metod är att vi förklarar den booleska variabeln som “ flyktig ”Så att det alltid läses från huvudminnet och programmet inte kan cache det i CPU-cachen. På det här sättet kommer det inte att finnas någon skillnad i värden som ställs in och läses.
Implementeringen av att stoppa en tråd med en flyktig boolesk variabel visas nedan.
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
Notera: Här har vi bara visat en del av produktionen. Tråden kan gå i flera minuter innan den stoppas. Så att vi kan få olika resultat på olika system.
Använda avbrott
Här stoppas tråden med interrupt () -metoden som vi redan diskuterade ovan i trådklassmetoderna. Metoden interrupt () ställer in trådens status som avbruten. Denna status skickas till while-slingan i run () -metoden. Vi kan få avbruten status med metoden avbruten ().
Följande program visar användningen av interrupt () -metoden för att stoppa 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
Vanliga frågor
F # 1) Varför använder vi Multithreading i Java?
Svar: Multitrådning möjliggör samtidig eller samtidig körning av två eller flera trådar i en applikation. Samtidigt utförande maximerar genomströmningen och använder också CPU: n till sitt maximala.
F # 2) Vad är Multithreading? Vilka är dess typer?
Svar: Multitrådning innebär att man kör mer än en tråd. Detta utförande kan ske samtidigt eller parallellt. Således har multitrådning två typer, dvs samtidigt eller parallellt.
F # 3) Vad är Multithreading vs. Multiprocessing?
Svar: I multitrådning finns det flera trådar för samma eller olika processer och dessa trådar körs samtidigt för att förbättra datorns hastighet för ett system. I multiprocessing har ett system mer än två processorer och flera processer körs samtidigt.
java lägg till i slutet av matrisen
F # 4) Vilka är fördelarna med Multithreading i Java?
Svar: Med hjälp av multithreading kan vi köra olika delar av en applikation samtidigt med hjälp av trådar. Multitrådning ökar systemgenomströmningen. Multithreading maximerar också CPU-användningen eftersom olika trådar kontinuerligt använder CPU.
F # 5) Är Multithreading bra för spel?
Svar: Ja, speciellt för moderna spel.
Slutsats
Det här handlar om introduktion av multithreading. Vi har diskuterat samtidigheten och multi-threading i Java i denna handledning. Vi diskuterade skapandet av en tråd med trådklass samt Runnable-gränssnittet och har gett lämpliga exempel.
Vi har också lärt oss begreppen en enda tråd och dess skapande i detalj. Trådkoncepten inklusive livscykeln för en tråd, stopp av en tråd, typer av trådar etc. har diskuterats i denna handledning.
Vi diskuterade också multitrådning i längd och samtidighet i Java. I slutet av denna handledning ska läsaren lätt kunna förstå begreppen samtidighet och multitrådning och även trådar i Java.
=> Se upp den enkla Java-träningsserien här.
Rekommenderad läsning
- Multitrådning i C ++ med exempel
- Java-trådar med metoder och livscykel
- Thread.Sleep () - Thread Sleep () Metod i Java med exempel
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- Java Reflection Tutorial med exempel
- Java String innehåller () Metodhandledning med exempel
- Jagged Array In Java - Handledning med exempel
- Java Scanner-klasshandledning med exempel