Monisäikeinen sisään Java

Jokaisella sovelluksella voi olla useita prosesseja (esiintymiä). Jokainen tästä prosessista voidaan määrittää joko yhdeksi säikeeksi tai useiksi säikeiksi. Näemme tässä opetusohjelmassa, kuinka suorittaa useita tehtäviä samanaikaisesti, ja opimme myös lisää säikeistä ja säikeiden välisestä synkronoinnista.

Mikä on yksisäike?

Yksi lanka sisään Java on periaatteessa kevyt ja pienin käsittelyyksikkö. Java käyttää säikeitä käyttämällä "Säieluokkaa". Lankoja on kahta tyyppiä - käyttäjäsäie ja daemon-säie (Daemon-säikeitä käytetään, kun haluamme puhdistaa sovelluksen ja niitä käytetään taustalla). Kun sovellus käynnistetään ensimmäisen kerran, käyttäjäsäie luodaan. Tämän jälkeen voimme luoda monia käyttäjäsäikeitä ja demonsäikeitä.

Esimerkki yksittäisestä säikeestä:

package demotest;

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

Yksilangan edut:

• Vähentää sovelluksen lisäkustannuksia, kun järjestelmässä suoritetaan yksi säie
• Lisäksi se vähentää sovelluksen ylläpitokustannuksia.

Esimerkki monisäikeestä:

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

Monisäikeen edut:

• Käyttäjiä ei ole estetty, koska säikeet ovat riippumattomia, ja voimme suorittaa useita toimintoja ajoittain
• Näin ollen säikeet ovat riippumattomia, muut säikeet eivät vaikuta, jos yksi säie kohtaa poikkeuksen.

Langan elinkaari sisään Java

Langan elinkaari:

Langan elinkaaressa on useita vaiheita, kuten yllä olevassa kaaviossa on esitetty:

1. Uusi
2. Ajettava
3. Running
4. odotus
5. Kuollut

1. Uutta: Tässä vaiheessa säiettä luodaan käyttämällä luokkaa "Thread class". Se pysyy tässä tilassa ohjelmaan asti alkaa lanka. Se tunnetaan myös nimellä born thread.
2. Ajettava: Tällä sivulla säikeen ilmentymä kutsutaan aloitusmenetelmällä. Säikeen ohjaus annetaan ajoittimelle suorituksen lopettamiseksi. Riippuu ajastimesta, ajaako säiettä.
3. Running: Kun säiettä alkaa suorittaa, tila vaihtuu "ajo"-tilaan. Ajoitus valitsee yhden säikeen säievarannosta, ja se alkaa suorittaa sovelluksessa.
4. odottavat: Tämä on tila, jolloin lanka joutuu odottamaan. Koska sovelluksessa on käynnissä useita säikeitä, säikeiden välinen synkronointi on tarpeen. Siksi yhden säikeen on odotettava, kunnes toinen säie suoritetaan. Siksi tätä tilaa kutsutaan odotustilaksi.
5. Kuollut: Tämä on tila, jolloin säiettä päätetään. Säie on käynnissä tilassa ja heti kun se on käsitellyt, se on "kuollut".

Monisäikeistysmenetelmät Java

Jotkut säikeille yleisesti käytetyistä menetelmistä ovat:

Menetelmä	Tuotetiedot
alkaa()	Tämä menetelmä aloittaa langan suorittamisen ja JVM kutsuu run()-metodia säikeessä.
Nukkuminen (mm millisekuntia)	Tämä menetelmä asettaa säikeen lepotilaan, jolloin säiettä keskeytyy tietyiksi millisekunteiksi ja sen jälkeen säie alkaa taas toimia. Tämä auttaa säikeiden synkronoinnissa.
getName ()	Se palauttaa ketjun nimen.
setPriority(int newpriority)	Se muuttaa ketjun prioriteettia.
tuotto ()	Se saa nykyisen säikeen pysähtymään ja muut säikeet suorittamaan.

Esimerkiksi: Tässä monisäikeisessä ohjelmassa sisään Java Esimerkiksi aiomme luoda säikeen ja tutkia säikeille saatavilla olevia sisäänrakennettuja menetelmiä.

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

Koodin selitys:

• Koodirivi 2: Olemme luomassa luokkaa "thread_Example1", joka toteuttaa Runnable-rajapinnan (se tulisi toteuttaa kaikissa luokissa, joiden esiintymät säikeen on tarkoitus suorittaa.)
• Koodirivi 4: Se ohittaa suoritettavan käyttöliittymän ajomenetelmän, koska se on pakollista ohittaa tämä menetelmä
• Koodirivi 6: Tässä olemme määrittäneet päämenetelmän, jolla aloitamme säiettä suorittamisen.
• Koodirivi 7: Täällä luomme uuden säikeen nimen "guruthread1" luomalla uuden luokan säiettä.
• Koodirivi 8: käytämme säiettä "start"-menetelmää käyttämällä "guruthread1"-instanssia. Tästä ketju alkaa toimia.
• Koodirivi 10: Tässä käytämme säikeen "sleep"-menetelmää käyttämällä "guruthread1" -esiintymää. Tästä syystä lanka nukkuu 1000 millisekuntia.
• Koodi 9-14: Tässä olemme laittaneet unimenetelmän try catch -lohkoon, koska siellä on tarkistettu poikkeus, joka tapahtuu eli keskeytetty poikkeus.
• Koodirivi 15: Tässä asetamme säikeen prioriteetin arvoon 1 riippumatta siitä, mikä prioriteetti se oli
• Koodirivi 16: Tässä saamme ketjun prioriteetin käyttämällä getPriority()
• Koodirivi 17: Tässä tulostamme getPrioritysta haetun arvon
• Koodirivi 18: Täällä kirjoitamme tekstiä, joka on käynnissä.

Kun suoritat yllä olevan koodin, saat seuraavan tulosteen:

lähtö:

5 on säikeen prioriteetti, ja säiettä käynnissä on teksti, joka on koodimme tulos.

Java Kierre Synchronisointi

Monisäikeisessä ohjelmissa on asynkroninen käyttäytyminen. Jos yksi säie kirjoittaa tietoja ja toinen säie, joka lukee tietoja samaan aikaan, saattaa aiheuttaa epäjohdonmukaisuutta sovelluksessa. Kun on tarvetta käyttää jaettuja resursseja kahdella tai useammalla säikeellä, käytetään synkronointitapaa. Java on tarjonnut synkronoidut menetelmät synkronoidun toiminnan toteuttamiseksi.

Tässä lähestymistavassa, kun säie saavuttaa synkronoidun lohkon sisällä, mikään muu säie ei voi kutsua tätä menetelmää samassa objektissa. Kaikkien säikeiden on odotettava, kunnes tämä säie päättää synkronoidun lohkon ja tulee ulos siitä. Tällä tavalla synkronointi auttaa monisäikeisessä sovelluksessa. Yhden säikeen on odotettava, kunnes toinen säie suorittaa suorituksensa, vasta sitten muut säikeet sallitaan suorittamiseen.

Se voidaan kirjoittaa seuraavassa muodossa:

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

Monisäikeinen sisään Java Esimerkkiohjelmat

Tässä monisäikeisyydessä Java Esimerkiksi otamme kaksi säiettä ja haemme säikeen nimet.

Esimerkki1:

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

Koodin selitys:

• Koodirivi 3: Olemme ottaneet luokan "GuruThread1", joka toteuttaa Runnable-toiminnon (se tulisi toteuttaa kaikissa luokissa, joiden esiintymät on tarkoitettu säikeen suoritettavaksi.)
• Koodirivi 8: Tämä on luokan päämenetelmä
• Koodirivi 9: Tässä luomme Thread-luokan ja luomme esiintymän nimeltä "guruThread1" ja luomme säiettä.
• Koodirivi 10: Tässä instantoimme Thread-luokan ja luomme esiintymän nimeltä "guruThread2" ja luomme säiettä.
• Koodirivi 11: Aloitamme ketjun eli guruThread1.
• Koodirivi 12: Aloitamme ketjun eli guruThread2.
• Koodirivi 13: Tekstin tulostaminen muodossa "Säikeiden nimet ovat seuraavat:"
• Koodirivi 14: Säikeen 1 nimen saaminen säieluokan menetelmällä getName().
• Koodirivi 15: Säikeen 2 nimen saaminen säieluokan menetelmällä getName().

Kun suoritat yllä olevan koodin, saat seuraavan tulosteen:

lähtö:

Säikeiden nimet tulostetaan tässä muodossa

• Guru1
• Guru2

Esimerkki 2:

Tässä monisäikeisessä sisäänkäynnissä Java Esimerkiksi opimme ohittamaan suoritettavan käyttöliittymän menetelmiä run() ja start() ja luomme kaksi säiettä kyseisestä luokasta ja suoritamme ne sen mukaisesti.

Lisäksi meillä on kaksi luokkaa,

• Sellaisen, joka toteuttaa ajettavan käyttöliittymän ja
• Toinen, jolla on päämenetelmä ja joka suoritetaan sen mukaisesti.

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

Koodin selitys:

• Koodirivi 2: Tässä otamme luokan "GuruThread2", jossa on päämenetelmä.
• Koodirivi 4: Tässä otamme luokan päämenetelmän.
• Koodirivit 6-7: Täällä luomme luokan GuruThread3 esiintymän (joka luodaan koodin alla oleville riveille) nimellä "threadguru1" ja aloitamme säiettä.
• Koodirivit 8-9: Täällä luomme toisen luokan GuruThread3 esiintymän (joka luodaan koodin alla oleville riveille) nimellä "threadguru2" ja aloitamme säiettä.
• Koodirivi 11: Täällä luomme luokan "GuruThread3", joka toteuttaa suoritettavaa käyttöliittymää (se tulisi toteuttaa millä tahansa luokalla, jonka ilmentymät säikeen on tarkoitus suorittaa.)
• Koodirivit 13-14: otamme kaksi luokkamuuttujaa, joista toinen on lankaluokkaa ja toinen merkkijonoluokkaa.
• Koodirivit 15-18: ohitamme GuruThread3-konstruktorin, joka ottaa yhden argumentin merkkijonotyypiksi (joka on säikeiden nimi), joka liitetään luokkamuuttujaan guruname ja tästä syystä säikeen nimi tallennetaan.
• Koodirivi 20: Tässä ohitamme suoritettavan käyttöliittymän run()-menetelmän.
• Koodirivi 21: Tulostamme säikeen nimen println-käskyn avulla.
• Koodirivit 22-31: Tässä käytetään for-silmukkaa, jonka laskuri on alustettu nollaan, ja sen ei pitäisi olla pienempi kuin 0 (voimme ottaa minkä tahansa luvun, joten tässä silmukka kulkee 4 kertaa) ja lisäämällä laskuria. Tulostamme langan nimen ja asetamme langan nukkumaan 4 millisekunnin ajaksi try-catch-lohkossa, koska unimenetelmä nosti valitun poikkeuksen.
• Koodirivi 33: Tässä ohitamme suoritettavan käyttöliittymän aloitusmenetelmän.
• Koodirivi 35: Tulostamme tekstin "Säie aloitettu".
• Koodirivit 36-40: Tässä otamme if-ehdon tarkistaaksemme, onko luokkamuuttujalla guruthread arvoa vai ei. Jos se on nolla, luomme ilmentymän säieluokan avulla, joka ottaa nimen parametriksi (jonka arvo määritettiin rakentajassa). Tämän jälkeen säiettä käynnistetään start()-menetelmällä.

Kun suoritat yllä olevan koodin, saat seuraavan tulosteen:

ulostulo:

Säikeitä on kaksi, joten saamme kaksi kertaa viestin "Säie aloitettu".

Saamme säikeen nimet sellaisina kuin ne on tulostettu.

Se menee for-silmukkaan, jossa tulostetaan laskuri ja langan nimi, ja laskuri alkaa 0:lla.

Silmukka suoritetaan kolme kertaa ja säikeen välissä nukkuu 1000 millisekuntia.

Tästä syystä saamme ensin guru1, sitten guru2 ja sitten taas guru2, koska lanka nukkuu täällä 1000 millisekuntia ja sitten seuraava guru1 ja jälleen guru1, lanka nukkuu 1000 millisekuntia, joten saamme guru2:n ja sitten guru1:n.

Yhteenveto

Tässä opetusohjelmassa näimme monisäikeisiä sovelluksia Java ja kuinka käyttää yhtä ja useaa lankaa Java.

• Selitä monisäikeisyys Java: monisäikeisessä käytössä käyttäjiä ei estetä, koska säikeet ovat riippumattomia ja voivat suorittaa useita toimintoja kerrallaan
• Langan elinkaaren eri vaiheet ovat,
  • Uusi
  • Ajettava
  • Running
  • odotus
  • Kuollut
• Opimme myös mm tahdistus säikeiden välillä, mikä auttaa sovellusta toimimaan sujuvasti.
• Monisäikeinen ohjelmointi sisään Java helpottaa monia muita sovellustehtäviä.