Multithreading inn Java

Enhver applikasjon kan ha flere prosesser (instanser). Hver av disse prosessene kan tilordnes enten som en enkelt tråd eller flere tråder. Vi vil se i denne opplæringen hvordan du utfører flere oppgaver samtidig og også lære mer om tråder og synkronisering mellom tråder.

Hva er enkelttråd?

En enkelt tråd inn Java er i utgangspunktet en lett og den minste prosesseringsenheten. Java bruker tråder ved å bruke en "Trådklasse". Det finnes to typer tråd - brukertråd og daemon-tråd (demontråder brukes når vi ønsker å rense applikasjonen og brukes i bakgrunnen). Når en applikasjon først starter, opprettes brukertråd. Post det, vi kan lage mange brukertråder og daemontråder.

Eksempel på én tråd:

package demotest;

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

Fordeler med enkel tråd:

• Reduserer overhead i applikasjonen som enkelttrådskjøring i systemet
• Dessuten reduserer det vedlikeholdskostnadene for applikasjonen.

Eksempel på multitråd:

package demotest;
public class GuruThread1 implements Runnable
{
       public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Fordeler med multithread:

• Brukerne er ikke blokkert fordi trådene er uavhengige, og vi kan utføre flere operasjoner til tider
• Som sådan er trådene uavhengige, de andre trådene vil ikke bli påvirket hvis en tråd møter et unntak.

Tråd livssyklus inn Java

Livssyklusen til en tråd:

Det er ulike stadier av livssyklusen til tråden som vist i diagrammet ovenfor:

1. Ny
2. Kjørbar
3. kjører
4. venter
5. Død

1. Nytt: I denne fasen opprettes tråden ved hjelp av klassen "Trådklasse". Den forblir i denne tilstanden til programmet starter tråden. Det er også kjent som født tråd.
2. Kjørbar: På denne siden blir forekomsten av tråden påkalt med en startmetode. Trådkontrollen blir gitt til planleggeren for å fullføre utførelsen. Det avhenger av planleggeren om du skal kjøre tråden.
3. Løping: Når tråden begynner å kjøre, endres tilstanden til "kjører". Planleggeren velger én tråd fra trådpoolen, og den begynner å kjøre i applikasjonen.
4. Venter: Dette er tilstanden når en tråd må vente. Siden det kjører flere tråder i applikasjonen, er det behov for synkronisering mellom tråder. Derfor må en tråd vente til den andre tråden blir utført. Derfor omtales denne tilstanden som ventetilstand.
5. Død: Dette er tilstanden når tråden avsluttes. Tråden er i løpende tilstand og så snart den er ferdig behandlet er den i "død tilstand".

Metoder for multithreading Java

Noen av de vanligste metodene for tråder er:

Metode	Tekniske beskrivelser
start()	Denne metoden starter utførelsen av tråden og JVM kaller run()-metoden på tråden.
Søvn (int millisekunder)	Denne metoden gjør at tråden hviler, og derfor vil trådens kjøring pause i millisekunder gitt, og etter det begynner tråden å kjøres igjen. Dette hjelper til med synkronisering av trådene.
getName ()	Det returnerer navnet på tråden.
setPriority(int newpriority)	Det endrer prioritet til tråden.
avkastning ()	Det fører til at gjeldende tråd stopper og andre tråder kjøres.

Eksempel: I dette multithreading-programmet i Java for eksempel skal vi lage en tråd og utforske innebygde metoder som er tilgjengelige for tråder.

package demotest;
public class thread_example1 implements Runnable {
    @Override
    public void run() {
    }
    public static void main(String[] args) {
        Thread guruthread1 = new Thread();
        guruthread1.start();
        try {
            guruthread1.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        guruthread1.setPriority(1);
        int gurupriority = guruthread1.getPriority();
        System.out.println(gurupriority);
        System.out.println("Thread Running");
  }
}

Forklaring av koden:

• Code Linje 2: Vi oppretter en klasse "thread_Example1" som implementerer Runnable-grensesnittet (det bør implementeres av enhver klasse hvis instanser er ment å kjøres av tråden.)
• Code Linje 4: Den overstyrer kjøremetoden til det kjørbare grensesnittet, da det er obligatorisk å overstyre den metoden
• Code Linje 6: Her har vi definert hovedmetoden der vi skal starte utførelsen av tråden.
• Code Linje 7: Her lager vi et nytt trådnavn som "guruthread1" ved å instansiere en ny trådklasse.
• Code Linje 8: vi vil bruke "start"-metoden for tråden ved å bruke "guruthread1"-forekomst. Her vil tråden begynne å kjøre.
• Code Linje 10: Her bruker vi "sleep"-metoden til tråden ved å bruke "guruthread1"-forekomst. Derfor vil tråden sove i 1000 millisekunder.
• Code 9-14: Her har vi satt sleep-metoden i try catch-blokken da det er krysset av unntak som oppstår dvs. Avbrutt unntak.
• Code Linje 15: Her setter vi trådens prioritet til 1 fra hvilken prioritet den var
• Code Linje 16: Her får vi prioritet til tråden ved å bruke getPriority()
• Code Linje 17: Her skriver vi ut verdien hentet fra getPriority
• Code Linje 18: Her skriver vi en tekst som tråden kjører.

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

Utgang:

5 er trådprioritet, og tråd som kjører er teksten som er utdata fra koden vår.

Java Tråd Synchronisering

I multithreading er det den asynkrone oppførselen til programmene. Hvis en tråd skriver noen 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 synkroniseringstilnærming. Java har gitt synkroniserte metoder for å implementere synkronisert atferd.

I denne tilnærmingen, når tråden når inn i den synkroniserte blokken, kan ingen annen tråd kalle den metoden på det samme objektet. Alle tråder må vente til den tråden fullfører den synkroniserte blokken og kommer ut av den. På denne måten hjelper synkroniseringen i en flertrådsapplikasjon. En tråd må vente til den andre tråden er ferdig med utføringen, bare da er de andre trådene tillatt for utførelse.

Det kan skrives i følgende form:

Synchronized(object)
{  
        //Block of statements to be synchronized
}

Multithreading inn Java Eksempler på programmer

I denne multithreading Java for eksempel tar vi to tråder og henter navnene på tråden.

Example1:

GuruThread1.java
package demotest;
public class GuruThread1 implements Runnable{

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Forklaring av koden:

• Code Linje 3: Vi har tatt et kurs «Guru«Tråd1» som implementerer Runnable (den bør implementeres av enhver klasse hvis instanser er ment å bli utført av tråden.)
• Code Linje 8: Dette er hovedmetoden i klassen
• Code Linje 9: Her instansierer vi Thread-klassen og lager en forekomst kalt "guruThread1" og lager en tråd.
• Code Linje 10: Her instansierer vi Thread-klassen og lager en forekomst kalt "guruThread2" og lager en tråd.
• Code Linje 11: Vi starter tråden dvs. guruThread1.
• Code Linje 12: Vi starter tråden dvs. guruThread2.
• Code Linje 13: Skrive ut teksten som "Trådnavn følger:"
• Code Linje 14: Hente navnet på tråd 1 ved å bruke metoden getName() til trådklassen.
• Code Linje 15: Hente navnet på tråd 2 ved å bruke metoden getName() til trådklassen.

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

Utgang:

Trådnavn sendes ut her som

• Guru1
• Guru2

Eksempel 2:

I denne multithreading i Java for eksempel vil vi lære om å overstyre metodene run() og start() for et kjørbart grensesnitt og lage to tråder av den klassen og kjøre dem deretter.

Dessuten tar vi to klasser,

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

package demotest;
public class GuruThread2 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  GuruThread3 threadguru1 = new GuruThread3("guru1");
  threadguru1.start();
  GuruThread3 threadguru2 = new GuruThread3("guru2");
  threadguru2.start();
 }
}
class GuruThread3 implements Runnable {
 Thread guruthread;
 private String guruname;
 GuruThread3(String name) {
  guruname = name;
 }
 @Override
 public void run() {
  System.out.println("Thread running" + guruname);
  for (int i = 0; i < 4; i++) {
   System.out.println(i);
   System.out.println(guruname);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    System.out.println("Thread has been interrupted");
   }
  }
 }
 public void start() {
  System.out.println("Thread started");
  if (guruthread == null) {
   guruthread = new Thread(this, guruname);
   guruthread.start();
  }
 }
}

Forklaring av koden:

• Code Linje 2: Her tar vi et kurs"GuruTråd2» som vil ha hovedmetoden i seg.
• Code Linje 4: Her tar vi en hovedmetode for klassen.
• Code Linje 6-7: Her lager vi en instans av klassen GuruTråd3 (som er opprettet i kodelinjene nedenfor) som «threadguru1», og vi starter tråden.
• Code Linje 8-9: Her lager vi en ny instans av klassen GuruTråd3 (som er opprettet i kodelinjene nedenfor) som «threadguru2», og vi starter tråden.
• Code Linje 11: Her lager vi en klasse «GuruThread3» som implementerer det kjørbare grensesnittet (det bør implementeres av enhver klasse hvis instanser er ment å bli utført av tråden.)
• Code Linje 13-14: vi tar to klassevariabler hvorfra den ene er av typen trådklasse og den andre av strengklassen.
• Code Linje 15-18: vi overstyrer GuruTråd3-konstruktøren, som tar ett argument som strengtype (som er trådnavnet) som blir tilordnet klassevariabelen guruname, og dermed lagres navnet på tråden.
• Code Linje 20: Her overstyrer vi run()-metoden til det kjørbare grensesnittet.
• Code Linje 21: Vi skriver ut trådnavnet ved å bruke println-setningen.
• Code Linje 22-31: Her bruker vi en for-løkke med telleren initialisert til 0, og den skal ikke være mindre enn 4 (vi kan ta et hvilket som helst tall, derfor vil løkken kjøre 4 ganger) og øke telleren. Vi skriver ut trådnavnet og gjør også at tråden hviler i 1000 millisekunder innenfor en prøvefangst-blokk, da søvnmetoden hevet sjekket unntak.
• Code Linje 33: Her overstyrer vi startmetoden til det kjørbare grensesnittet.
• Code Linje 35: Vi sender ut teksten "Tråd startet".
• Code Linje 36-40: Her tar vi en if-betingelse for å sjekke om klassevariabelen guruthread har verdi i seg eller ikke. Hvis den er null, lager vi en forekomst ved å bruke trådklassen 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 kjører koden ovenfor får du følgende utgang:

Produksjon:

Det er to tråder, derfor får vi to ganger meldingen "Tråd startet".

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

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

Sløyfen kjøres tre ganger og i mellom sover tråden i 1000 millisekunder.

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

Sammendrag

I denne opplæringen så vi flertrådede applikasjoner i Java og hvordan du bruker enkelt og flertråd i Java.

• Forklar multithreading Java: i multithreading blokkeres ikke brukere da tråder er uavhengige og kan utføre flere operasjoner samtidig
• Ulike stadier av livssyklusen til tråden er,
  • Ny
  • Kjørbar
  • kjører
  • venter
  • Død
• Vi lærte også om synkronisering mellom tråder, som hjelper applikasjonen til å kjøre jevnt.
• Flertrådsprogrammering inn Java gjør mange flere applikasjonsoppgaver enklere.