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:

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

• Code Rivi 3: Olemme käyneet kurssin "GuruThread1”, joka toteuttaa Runnable-luokituksen (sen tulisi toteutua millä tahansa luokalla, jonka instanssit on tarkoitus suorittaa säikeellä).
• Code Rivi 8: Tämä on luokan päämenetelmä
• Code Rivi 9: Tässä luomme Thread-luokan ja luomme esiintymän nimeltä "guruThread1" ja luomme säiettä.
• Code Rivi 10: Tässä instantoimme Thread-luokan ja luomme esiintymän nimeltä "guruThread2" ja luomme säiettä.
• Code Rivi 11: Aloitamme ketjun eli guruThread1.
• Code Rivi 12: Aloitamme ketjun eli guruThread2.
• Code Rivi 13: Tekstin tulostaminen muodossa "Säikeiden nimet ovat seuraavat:"
• Code Rivi 14: Säikeen 1 nimen saaminen säieluokan menetelmällä getName().
• Code Rivi 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:

• Code Rivi 2: Tässä me käymme kurssia"GuruThread2”, jossa on päämetodi.
• Code Rivi 4: Tässä otamme luokan päämenetelmän.
• Code Rivi 6–7: Tässä luomme luokan instanssin GuruSäike3 (joka luodaan koodin alla olevilla riveillä) nimellä “threadguru1” ja aloitamme säikeen.
• Code Rivi 8–9: Tässä luomme uuden luokan instanssin GuruSäike3 (joka luodaan koodin alla olevilla riveillä) nimellä “threadguru2” ja aloitamme säikeen.
• Code Rivi 11: Tässä me luomme luokan "GuruThread3”, joka toteuttaa ajettavan rajapinnan (sen tulisi toteutua millä tahansa luokalla, jonka instanssit on tarkoitus suorittaa säikeellä).
• Code Rivi 13–14: otamme kaksi luokkamuuttujaa, joista toinen on lankaluokkaa ja toinen merkkijonoluokkaa.
• Code Rivi 15–18: me ohitamme GuruThread3-konstruktori, joka ottaa yhden argumentin merkkijonotyyppinä (joka on säikeiden nimi), joka määritetään luokkamuuttujalle guruname ja siten säikeen nimi tallennetaan.
• Code Rivi 20: Tässä ohitamme suoritettavan käyttöliittymän run()-menetelmän.
• Code Rivi 21: Tulostamme säikeen nimen println-käskyn avulla.
• Code Rivi 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.
• Code Rivi 33: Tässä ohitamme suoritettavan käyttöliittymän aloitusmenetelmän.
• Code Rivi 35: Tulostamme tekstin "Säie aloitettu".
• Code Rivi 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ä.