Mitme lõime sisse lülitamine Java

Igal rakendusel võib olla mitu protsessi (eksemplari). Iga selle protsessi saab määrata kas ühe lõimena või mitme lõimena. Selles õpetuses näeme, kuidas teha korraga mitut ülesannet, ning õpime lisaks lõimede ja lõimedevahelise sünkroonimise kohta.

Mis on üksiklõng?

Üks lõng sisse Java on põhimõtteliselt kerge ja väikseim töötlemisüksus. Java kasutab lõime, kasutades "lõime klassi". Niite on kahte tüüpi - kasutajalõim ja deemonilõng (deemoni lõime kasutatakse siis, kui tahame rakendust puhastada ja neid kasutatakse taustal). Rakenduse esmakordsel käivitamisel luuakse kasutajalõim. Postitage see, et saame luua palju kasutajalõime ja deemonilõime.

Ühe lõime näide:

package demotest;

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

Ühe keerme eelised:

• Vähendab rakenduse üldkulusid, kuna süsteemis käivitatakse üks lõime
• Samuti vähendab see rakenduse hoolduskulusid.

Mitme lõime näide:

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

Mitme lõime eelised:

• Kasutajaid ei blokeerita, kuna lõimed on sõltumatud ja me saame mõnikord teha mitu toimingut
• Kuna lõimed on sõltumatud, ei mõjuta see teisi lõime, kui üks lõim vastab erandile.

Lõime elutsükkel sisse Java

Lõime elutsükkel:

Niidi elutsüklil on erinevad etapid, nagu on näidatud ülaltoodud diagrammil:

1. Uus
2. Jooksev
3. Running
4. ootamine
5. Surnud

1. Uus: Selles faasis luuakse lõim klassi "Thread class" abil. See jääb sellesse olekusse kuni programmini algab niit. Seda tuntakse ka sündinuna.
2. Käitatav: Sellel lehel käivitatakse lõime eksemplar käivitusmeetodiga. Lõime juhtimine antakse ajakavale täitmise lõpetamiseks. See sõltub ajakavast, kas lõime käivitada.
3. Jooks: Kui lõim hakkab täitma, muudetakse olek "töötavaks". Ajakavandaja valib lõimekogust ühe lõime ja see hakkab rakenduses täitma.
4. Ootel: See on seisund, mil niit peab ootama. Kuna rakenduses töötab mitu lõime, on vaja lõimede vahel sünkroonida. Seega peab üks lõim ootama, kuni teine ​​lõim täidetakse. Seetõttu nimetatakse seda olekut ooteolekuks.
5. Surnud: See on olek, mil lõim lõpetatakse. Lõim on tööolekus ja niipea, kui see on töötlemise lõpetanud, on see surnud olekus.

Mitmekeermestamise meetodid Java

Mõned lõimede jaoks tavaliselt kasutatavad meetodid on järgmised:

Meetod	Kirjeldus
start ()	See meetod alustab lõime täitmist ja FMV kutsub lõimes meetodi run().
Unerežiim (millissekundites)	See meetod muudab lõime unerežiimi, mistõttu lõime täitmine peatub ette nähtud millisekunditeks ja pärast seda hakkab lõime uuesti täitma. See aitab niidid sünkroonida.
getName ()	See tagastab lõime nime.
setPriority(in newpriority)	See muudab lõime prioriteeti.
saagikus ()	See põhjustab praeguse lõime peatamise ja teiste lõimede käivitamise.

Näide: Selles mitmelõimelises programmis sisse Java Näiteks loome lõime ja uurime lõimede jaoks saadaolevaid sisseehitatud meetodeid.

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

Koodi selgitus:

• Koodirida 2: Loome klassi "thread_Example1", mis rakendab Runnable-liidest (seda peaks rakendama iga klass, mille eksemplarid on mõeldud lõime täitmiseks).
• Koodirida 4: See alistab käivitatava liidese käitamismeetodi, kuna selle meetodi alistamine on kohustuslik
• Koodirida 6: Siin oleme määratlenud peamise meetodi, mille abil me lõime täitmist alustame.
• Koodirida 7: Siin loome uue lõime nime "guruthread1", luues uue lõime klassi.
• Koodirida 8: kasutame lõime "start" meetodit, kasutades "guruthread1" eksemplari. Siin hakkab lõim täitma.
• Koodirida 10: Siin kasutame lõime "unerežiimi" meetodit, kasutades "guruthread1" eksemplari. Seega jääb niit 1000 millisekundiks magama.
• Kood 9-14: Siin oleme pannud unerežiimi proovi püüdmise plokki, kuna seal on kontrollitud erand, mis esineb, st Katkestatud erand.
• Koodirida 15: Siin määrame lõime prioriteediks 1, olenevalt sellest, millise prioriteediga see oli
• Koodirida 16: Siin saame lõime prioriteedi, kasutades getPriority()
• Koodirida 17: Siin prindime getPriorityst hangitud väärtuse
• Koodirida 18: Siin kirjutame teksti, mis lõim töötab.

Kui käivitate ülaltoodud koodi, saate järgmise väljundi:

Väljund:

5 on lõime prioriteet ja lõime käitamine on tekst, mis on meie koodi väljund.

Java Keere Synchroniseerimine

Mitme lõimega töötlemisel on programmide asünkroonne käitumine. Kui üks lõim kirjutab andmeid ja teine ​​lõim, mis loeb samal ajal andmeid, võib rakenduses tekkida ebakõla. Kui on vaja juurdepääsu jagatud ressurssidele kahe või enama lõime kaudu, kasutatakse sünkroonimismeetodit. Java on pakkunud sünkroniseeritud käitumise rakendamiseks sünkroniseeritud meetodeid.

Selle lähenemisviisi korral, kui lõime jõuab sünkroniseeritud ploki sisse, ei saa ükski teine ​​lõim seda meetodit samal objektil kutsuda. Kõik lõimed peavad ootama, kuni see lõim lõpetab sünkroonitud ploki ja väljub sellest. Sel viisil aitab sünkroonimine mitme lõimega rakenduses. Üks lõim peab ootama, kuni teine ​​lõim oma täitmise lõpetab, alles siis lubatakse teised lõimed täitmiseks.

Selle saab kirjutada järgmisel kujul:

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

Mitme lõime sisse lülitamine Java Näidisprogrammid

Selles mitmelõimeses Java Näiteks võtame kaks lõime ja hangime lõime nimed.

Näide1:

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

Koodi selgitus:

• Koodirida 3: Oleme võtnud klassi "GuruThread1", mis rakendab Runnable (seda peaks rakendama iga klass, mille eksemplarid on mõeldud lõimega täitmiseks).
• Koodirida 8: See on klassi peamine meetod
• Koodirida 9: Siin loome lõime klassi ja loome eksemplari nimega "guruThread1" ja loome lõime.
• Koodirida 10: Siin loome lõime klassi ja loome eksemplari nimega "guruThread2" ja loome lõime.
• Koodirida 11: Alustame lõime st guruThread1.
• Koodirida 12: Alustame lõime st guruThread2.
• Koodirida 13: Teksti väljastamine kujul "Lõimede nimed on järgmised:"
• Koodirida 14: Lõime 1 nime hankimine lõimeklassi meetodi getName() abil.
• Koodirida 15: Lõime 2 nime hankimine lõimeklassi meetodi getName() abil.

Kui käivitate ülaltoodud koodi, saate järgmise väljundi:

Väljund:

Lõimede nimed väljastatakse siia kui

• Guru1
• Guru2

Näide 2:

Selles multithreading in Java Näiteks õpime käivitatava liidese meetodite run() ja start() alistamise kohta ning loome selle klassi kaks lõime ja käivitame need vastavalt.

Samuti võtame kaks klassi,

• Üks, mis rakendab käivitatava liidese ja
• Teine, millel on põhimeetod ja mis käivitatakse vastavalt.

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

Koodi selgitus:

• Koodirida 2: Siin võtame klassi “GuruThread2”, milles on põhimeetod.
• Koodirida 4: Siin käsitleme klassi peamist meetodit.
• Koodirida 6–7: Siin loome klassi GuruThread3 eksemplari (mis luuakse koodi allolevatel ridadel) kui "threadguru1" ja alustame lõime.
• Koodirida 8–9: Siin loome teise klassi GuruThread3 eksemplari (mis luuakse koodi allolevatel ridadel) kui "threadguru2" ja alustame lõime.
• Koodirida 11: Siin loome klassi "GuruThread3", mis rakendab käitatavat liidest (seda peaks rakendama iga klass, mille eksemplarid on mõeldud lõime täitmiseks.)
• Koodirida 13–14: võtame kaks klassimuutujat, millest üks on lõimeklassi tüüpi ja teine ​​stringiklassist.
• Koodirida 15–18: me alistame GuruThread3 konstruktori, mis võtab stringitüübina ühe argumendi (mis on lõime nimi), mis määratakse klassi muutujale guruname ja seega salvestatakse lõime nimi.
• Koodirida 20: Siin alistame käivitatava liidese meetodi run().
• Koodirida 21: Väljastame lõime nime println-lause abil.
• Koodirida 22–31: Siin kasutame for-silmust, mille loendur on lähtestatud 0-ks ja see ei tohiks olla väiksem kui 4 (võime võtta mis tahes arvu, seega jookseb silmus siin 4 korda) ja loenduri suurendamist. Prindime lõime nime ja lülitame lõime 1000 millisekundiks unerežiimi proovivõtuplokis, kuna unerežiimil on märgitud erand.
• Koodirida 33: Siin alistame käivitatava liidese käivitusmeetodi.
• Koodirida 35: Väljastame teksti "Lõim alustatud".
• Koodirida 36–40: Siin kasutame tingimust if, et kontrollida, kas klassi muutujal guruthread on väärtus või mitte. Kui see on null, siis loome eksemplari lõimeklassi abil, mis võtab parameetrina nime (mille väärtus määrati konstruktoris). Pärast seda käivitatakse lõime, kasutades start() meetodit.

Kui käivitate ülaltoodud koodi, saate järgmise väljundi:

Väljund:

Seega on kaks lõime, saame kaks korda sõnumi "Lõim on alanud".

Me saame lõime nimed nii, nagu oleme need väljastanud.

See läheb tsüklisse, kus me prindime loenduri ja lõime nime ning loendur algab 0-ga.

Silmus käivitub kolm korda ja lõime vahel magatakse 1000 millisekundit.

Seega saame kõigepealt guru1, siis guru2 ja siis jälle guru2, sest niit magab siin 1000 millisekundit ja siis järgmine guru1 ja jälle guru1, niit magab 1000 millisekundit, seega saame guru2 ja seejärel guru1.

kokkuvõte

Selles õpetuses nägime mitme lõimega rakendusi Java ja kuidas kasutada ühe ja mitme keermega Java.

• Selgitage mitme lõime sisseviimist Java: mitme lõimega töötlemisel ei blokeerita kasutajaid, kuna lõimed on sõltumatud ja võivad korraga teha mitu toimingut
• Niidi elutsükli erinevad etapid on
  • Uus
  • Jooksev
  • Running
  • ootamine
  • Surnud
• Saime ka teada Sünkroonimine lõimede vahel, mis aitavad rakendusel sujuvalt töötada.
• Mitme lõimega programmeerimine Java muudab palju rakendusülesandeid lihtsamaks.