Multithreading in Java-zelfstudie met programma en voorbeelden

Elke toepassing kan meerdere processen (instanties) hebben. Elk van dit proces kan worden toegewezen als een enkele thread of als meerdere threads. We zullen in deze tutorial zien hoe je meerdere taken tegelijkertijd kunt uitvoeren en ook meer leren over threads en synchronisatie tussen threads.

In deze Multithreading-tutorial in Java leren we:

• Wat is een enkele thread
• Wat is multithreading in Java?
• Levenscyclus van threads in Java
• Java-threadsynchronisatie
• Java Multithreading Voorbeeld

Wat is een enkele thread?

Een enkele thread in Java is in feite een lichtgewicht en de kleinste verwerkingseenheid. Java gebruikt threads door een “Thread Class” te gebruiken.

Er zijn twee soorten threads – gebruikersthread en daemonthread (daemon-threads worden gebruikt wanneer we de applicatie willen opschonen en worden op de achtergrond gebruikt).

Wanneer een toepassing voor het eerst wordt gestart, wordt een gebruikersthread gemaakt. Post dat, we kunnen veel gebruikersthreads en daemonthreads maken.

Voorbeeld van één thread:

package demotest;

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

Voordelen van een enkele thread:

• Vermindert de overhead in de applicatie als een enkele thread in het systeem wordt uitgevoerd
• Het vermindert ook de onderhoudskosten van de applicatie.

Wat is multithreading in Java?

Multithreading in Java is een proces waarbij twee of meer threads tegelijkertijd worden uitgevoerd om de CPU maximaal te benutten. Toepassingen met meerdere threads voeren twee of meer threads tegelijk uit. Daarom is het ook bekend als Concurrency in Java. Elke draad loopt parallel aan elkaar. Meerdere threads wijzen geen afzonderlijk geheugengebied toe, daarom besparen ze geheugen. Ook kost het wisselen van context tussen threads minder tijd.

Voorbeeld van multithread:

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() {
    }
}

Voordelen van multithread:

• De gebruikers worden niet geblokkeerd omdat threads onafhankelijk zijn en we soms meerdere bewerkingen kunnen uitvoeren
• Omdat de threads onafhankelijk zijn, worden de andere threads niet beïnvloed als een thread aan een uitzondering voldoet.

Thread-levenscyclus in Java

De levenscyclus van een thread:

Levenscyclus van threads in Java

Er zijn verschillende stadia van de levenscyclus van draad, zoals weergegeven in het bovenstaande diagram:

1. Nieuw
2. Uitvoerbaar
3. Hardlopen
4. Wachten
5. Dood

1. Nieuw: In deze fase wordt de thread gemaakt met behulp van de klasse "Thread class". Het blijft in deze staat totdat het programma start de draad. Het wordt ook wel geboren draad genoemd.
2. Uitvoerbaar: Op deze pagina wordt de instantie van de thread aangeroepen met een startmethode. De threadcontrole wordt aan de planner gegeven om de uitvoering te voltooien. Het hangt af van de planner of de thread moet worden uitgevoerd.
3. Hardlopen: Wanneer de thread wordt uitgevoerd, wordt de status gewijzigd in de status 'in werking'. De planner selecteert één thread uit de threadpool en deze begint te worden uitgevoerd in de toepassing.
4. Wachten: Dit is de toestand waarin een thread moet wachten. Omdat er meerdere threads in de applicatie draaien, is er behoefte aan synchronisatie tussen threads. Daarom moet de ene thread wachten tot de andere thread wordt uitgevoerd. Daarom wordt deze toestand een wachttoestand genoemd.
5. Dood: Dit is de status wanneer de thread wordt beëindigd. De thread is in actieve staat en zodra de verwerking is voltooid, bevindt deze zich in "dode staat".

Enkele veelgebruikte methoden voor threads zijn:

Voorbeeld: In dit multithreading-programma in Java gaan we een thread maken en de ingebouwde methoden verkennen die beschikbaar zijn voor threads.

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");
  }
}

Uitleg van de code:

• Coderegel 2: We creëren een klasse "thread_Example1" die de Runnable-interface implementeert (deze moet worden geïmplementeerd door elke klasse waarvan de instanties bedoeld zijn om door de thread te worden uitgevoerd.)
• Coderegel 4: Het overschrijft de run-methode van de uitvoerbare interface omdat het verplicht is om die methode te overschrijven
• Coderegel 6: Hier hebben we de belangrijkste methode gedefinieerd waarin we de uitvoering van de thread zullen starten.
• Coderegel 7: Hier creëren we een nieuwe threadnaam als "guruthread1" door een nieuwe klasse thread te instantiëren.
• Coderegel 8: we zullen de "start" -methode van de thread gebruiken met behulp van de instantie "guruthread1". Hier wordt de thread uitgevoerd.
• Coderegel 10: Hier gebruiken we de "sleep" -methode van de thread met behulp van de instantie "guruthread1". Daarom slaapt de thread 1000 milliseconden.
• Code 9-14: Hier hebben we de slaapmethode in het try catch-blok geplaatst, omdat er een gecontroleerde uitzondering is die optreedt, d.w.z. een onderbroken uitzondering.
• Coderegel 15: Hier stellen we de prioriteit van de thread in op 1 van welke prioriteit het ook was
• Coderegel 16: Hier krijgen we de prioriteit van de thread met getPriority()
• Coderegel 17: Hier drukken we de waarde af die is opgehaald uit getPriority
• Coderegel 18: Hier zijn we een tekst aan het schrijven die in een thread loopt.

Wanneer u de bovenstaande code uitvoert, krijgt u de volgende uitvoer:

Uitvoer:

5 is de Thread-prioriteit en Thread Running is de tekst die de uitvoer van onze code is.

Java-threadsynchronisatie

Bij multithreading is er het asynchrone gedrag van de programma's. Als een thread gegevens schrijft en een andere thread die tegelijkertijd gegevens leest, kan dit tot inconsistentie in de toepassing leiden.

Wanneer het nodig is om toegang te krijgen tot de gedeelde bronnen via twee of meer threads, wordt een synchronisatiebenadering gebruikt.

Java heeft gesynchroniseerde methoden geleverd om gesynchroniseerd gedrag te implementeren.

In deze benadering, zodra de thread binnen het gesynchroniseerde blok komt, kan geen enkele andere thread die methode op hetzelfde object aanroepen. Alle threads moeten wachten tot die thread het gesynchroniseerde blok voltooit en daaruit komt.

Op deze manier helpt de synchronisatie in een multithreaded applicatie. Eén thread moet wachten tot de andere thread de uitvoering heeft voltooid, alleen dan mogen de andere threads worden uitgevoerd.

Het kan in de volgende vorm worden geschreven:

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

Java Multithreading Voorbeeld

In dit Java-voorbeeld met meerdere threads zullen we twee threads nemen en de namen van de thread ophalen.

Voorbeeld1:

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() {
    }
}

Uitleg van de code:

• Coderegel 3: We hebben een klasse "GuruThread1" genomen die Runnable implementeert (het zou moeten worden geïmplementeerd door elke klasse waarvan de instanties bedoeld zijn om door de thread te worden uitgevoerd.)
• Coderegel 8: Dit is de hoofdmethode van de klas
• Coderegel 9: Hier instantiëren we de Thread-klasse en maken we een instantie met de naam "guruThread1" en maken we een thread.
• Coderegel 10: Hier instantiëren we de Thread-klasse en maken we een instantie met de naam "guruThread2" en maken we een thread.
• Coderegel 11: We starten de thread, d.w.z. guruThread1.
• Coderegel 12: We starten de thread, d.w.z. guruThread2.
• Coderegel 13: De tekst uitvoeren als "Thread-namen volgen:"
• Coderegel 14: De naam van thread 1 verkrijgen met de methode getName() van de threadklasse.
• Coderegel 15: De naam van thread 2 verkrijgen met de methode getName() van de threadklasse.

Wanneer u de bovenstaande code uitvoert, krijgt u de volgende uitvoer:

Uitvoer:

Discussienamen worden hier uitgevoerd als

• Guru1
• Guru2

Voorbeeld 2:

In dit voorbeeld van multithreading in Java leren we over het overschrijven van methoden run() en start() van een uitvoerbare interface en maken we twee threads van die klasse en voeren ze dienovereenkomstig uit.

We volgen ook twee lessen,

• Een die de uitvoerbare interface zal implementeren en
• Een andere die de hoofdmethode zal hebben en dienovereenkomstig zal uitvoeren.

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();
  }
 }
}

Uitleg van de code:

• Coderegel 2: Hier nemen we een klasse "GuruThread2" die de hoofdmethode erin zal hebben.
• Coderegel 4: Hier nemen we een hoofdmethode van de klas.
• Coderegel 6-7: Hier maken we een instantie van klasse GuruThread3 (die is gemaakt in de onderstaande regels van de code) als "threadguru1" en we starten de thread.
• Coderegel 8-9: Hier maken we nog een instantie van klasse GuruThread3 (die in de onderstaande regels van de code is gemaakt) als "threadguru2" en we starten de thread.
• Coderegel 11: Hier creëren we een klasse "GuruThread3" die de uitvoerbare interface implementeert (deze zou moeten worden geïmplementeerd door elke klasse waarvan de instanties bedoeld zijn om door de thread te worden uitgevoerd.)
• Coderegel 13-14: we nemen twee klassevariabelen waarvan de ene van het type threadklasse is en de andere van de stringklasse.
• Coderegel 15-18: we overschrijven de GuruThread3-constructor, die één argument als stringtype neemt (de naam van de thread) die wordt toegewezen aan de klassevariabele guruname en vandaar dat de naam van de thread wordt opgeslagen.
• Coderegel 20: Hier overschrijven we de methode run() van de uitvoerbare interface.
• Coderegel 21: We voeren de threadnaam uit met de instructie println.
• Coderegel 22-31: Hier gebruiken we een for-lus met een teller die is geïnitialiseerd op 0, en deze mag niet minder zijn dan 4 (we kunnen elk nummer nemen, dus hier wordt de lus 4 keer uitgevoerd) en de teller wordt verhoogd. We drukken de threadnaam af en laten de thread ook 1000 milliseconden slapen binnen een try-catch-blok, aangezien de slaapmethode een gecontroleerde uitzondering heeft veroorzaakt.
• Coderegel 33: Hier overschrijven we de startmethode van de uitvoerbare interface.
• Coderegel 35: We geven de tekst "Thread gestart" uit.
• Coderegel 36-40: Hier nemen we een if-voorwaarde om te controleren of klassevariabele guruthread een waarde heeft of niet. Als het null is, maken we een instantie met behulp van de threadklasse die de naam als parameter neemt (waarvoor de waarde is toegewezen in de constructor). Waarna de thread wordt gestart met de methode start().

Wanneer u de bovenstaande code uitvoert, krijgt u de volgende uitvoer:

Uitvoer :

Er zijn twee threads, dus we krijgen twee keer de melding "Thread gestart".

We krijgen de namen van de thread zoals we ze hebben uitgevoerd.

Het gaat naar de for-lus waar we de teller en de threadnaam afdrukken en de teller begint met 0.

De lus wordt drie keer uitgevoerd en daartussen wordt de draad 1000 milliseconden in slaap gehouden.

Daarom krijgen we eerst guru1 dan guru2 en dan weer guru2 omdat de draad hier 1000 milliseconden slaapt en dan volgende guru1 en opnieuw guru1, de draad slaapt 1000 milliseconden, dus we krijgen guru2 en dan guru1.

Samenvatting

In deze zelfstudie zagen we toepassingen met meerdere threads in Java en hoe u enkele en multithreads in Java kunt gebruiken.

• Uitleg multithreading in Java:bij multithreading worden gebruikers niet geblokkeerd omdat threads onafhankelijk zijn en meerdere bewerkingen tegelijk kunnen uitvoeren
• Verschillende stadia van de levenscyclus van de draad zijn,
  • Nieuw
  • Uitvoerbaar
  • Hardlopen
  • Wachten
  • Dood
• We hebben ook geleerd over synchronisatie tussen threads, waardoor de toepassing soepel verloopt.
• Multithreaded programmeren in Java maakt veel meer applicatietaken eenvoudiger.