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:

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

• Code Rida 3: Me oleme võtnud kursuse "Guru„Thread1”, mis rakendab Runnable'i (seda peaks rakendama iga klass, mille eksemplare on mõeldud lõime poolt käivitamiseks).
• Code Rida 8: See on klassi peamine meetod
• Code Rida 9: Siin loome lõime klassi ja loome eksemplari nimega "guruThread1" ja loome lõime.
• Code Rida 10: Siin loome lõime klassi ja loome eksemplari nimega "guruThread2" ja loome lõime.
• Code Rida 11: Alustame lõime st guruThread1.
• Code Rida 12: Alustame lõime st guruThread2.
• Code Rida 13: Teksti väljastamine kujul "Lõimede nimed on järgmised:"
• Code Rida 14: Lõime 1 nime hankimine lõimeklassi meetodi getName() abil.
• Code Rida 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:

• Code Rida 2: Siin me võtame tundi "Guru„Thread2”, milles on peamine meetod.
• Code Rida 4: Siin käsitleme klassi peamist meetodit.
• Code Rida 6-7: Siin loome klassi eksemplari GuruLõim3 (mis luuakse koodi allolevates ridades) kui „threadguru1“ ja me alustame lõime.
• Code Rida 8-9: Siin loome klassi järjekordse eksemplari GuruLõim3 (mis luuakse koodi allolevates ridades) kui „threadguru2“ ja me alustame lõime.
• Code Rida 11: Siin me loome klassi "Guru„Thread3”, mis rakendab käivitatavat liidest (selle peaks rakendama iga klass, mille eksemplare on mõeldud lõime poolt käivitamiseks).
• Code Rida 13-14: võtame kaks klassimuutujat, millest üks on lõimeklassi tüüpi ja teine ​​stringiklassist.
• Code Rida 15-18: me tühistame GuruThread3 konstruktor, mis võtab ühe argumendi stringi tüübina (mis on lõime nimi), mis määratakse klassimuutujale guruname ja seega salvestatakse lõime nimi.
• Code Rida 20: Siin alistame käivitatava liidese meetodi run().
• Code Rida 21: Väljastame lõime nime println-lause abil.
• Code Rida 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.
• Code Rida 33: Siin alistame käivitatava liidese käivitusmeetodi.
• Code Rida 35: Väljastame teksti "Lõim alustatud".
• Code Rida 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.