Igal rakendusel võib olla mitu protsessi (eksemplari). Iga selle protsessi saab määrata kas ühe või mitme lõimena. Selles õpetuses näeme, kuidas korraga mitut ülesannet sooritada, samuti saate rohkem teada lõimede ja lõimede vahelise sünkroonimise kohta.
Selles õpetuses õpime:
- Mis on üks lõng
- Mis on Java mitmekihiline?
- Lõnga elutsükkel Java-s
- Java lõime sünkroniseerimine
- Java multithreading näide
Mis on üks lõng?
Üks lõng on põhimõtteliselt kerge ja väikseim töötlemisüksus. Java kasutab lõime, kasutades lõimeklassi.
Keermeid on kahte tüüpi - kasutaja lõime ja deemoni lõime (deemoni lõime kasutatakse siis, kui tahame rakendust puhastada ja neid kasutatakse taustal).
Rakenduse esmakordsel käivitamisel luuakse kasutaja lõim. Postitage see, et saame luua palju kasutajate lõime ja deemoni lõime.
Ühe lõime näide:
paketi demotest;avalik klass GuruThread{public staatiline void main (String [] args) {System.out.println ("üks lõime");}}
Ühe niidi eelised:
- Vähendab rakenduse üldkulusid, kui süsteemis täidetakse ühe lõimega
- Samuti vähendab see rakenduse hoolduskulusid.
Mis on Java mitmekihiline?
MULTITHREADING Java-s on protsess, mis täidab kahte või enamat lõime samaaegselt CPU maksimaalseks kasutamiseks. Mitme lõimega rakendused käivitavad kaks või enam samaaegselt töötavat lõime. Seega on see Java-s tuntud ka kui samaaegsus. Iga niit kulgeb üksteisega paralleelselt. Mitu lõime ei eralda eraldi mälupinda, seega säästavad nad mälu. Samuti võtab konteksti vahetamine lõimede vahel vähem aega.
Mitme lõime näide:
paketi demotest;avaliku klassi GuruThread1 rakendab Runnable{public staatiline void main (String [] args) {Teema guruThread1 = uus lõime ("Guru1");Teema guruThread2 = uus lõime ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("lõimenimed on järgmised:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Üleavalik void run () {}}
Mitme keerme eelised:
- Kasutajaid ei blokeerita, kuna lõimed on sõltumatud ja me võime korraga teha mitu toimingut
- Kuna sellised lõimed on sõltumatud, ei mõjuta teised teemad, kui üks lõim vastab erandile.
Lõnga elutsükkel Java-s
Lõnga elutsükkel:
Niidi elutsükli erinevaid etappe on näidatud ülaltoodud diagrammil:
- Uus
- Jooksev
- Jooksmine
- Ootan
- Surnud
- Uus: selles etapis luuakse lõim klassi "Thread class" abil. See jääb sellesse olekusse, kuni programm lõime käivitab . Seda tuntakse ka sündinud niidina.
- Käivitatav: sellel lehel kutsutakse lõime eksemplari algusmeetodiga . Lõime juhtimine antakse planeerijale täitmise lõpetamiseks. Kas lõime käivitada, sõltub ajastajast.
- Töötamine: kui lõime hakatakse täitma, muudetakse olek olekuks „töötab”. Planeerija valib lõimakogumist ühe lõime ja seda hakatakse rakenduses täitma.
- Ootamine: see on olek, kui lõime peab ootama. Kuna rakenduses töötab mitu lõime, tuleb lõimede vahel sünkroonida. Seega peab üks lõim ootama, kuni teine lõim käivitatakse. Seetõttu nimetatakse seda olekut ooteseisundiks.
- Surnud: see on olek, kui lõime lõpetatakse. Lõng on töötavas olekus ja niipea, kui see on töötlemise lõpetanud, on see "surnud olekus".
Mõned lõimede jaoks tavaliselt kasutatavad meetodid on:
| Meetod | Kirjeldus |
|---|---|
| algus () | See meetod alustab lõime käivitamist ja JVM kutsub lõime run () meetodit. |
| Uni (millisekundites) | See meetod paneb lõime unerežiimi muutma, mistõttu lõime käivitamine peatub antud millisekundite jooksul ja pärast seda hakkab lõime taas käivitama. See aitab lõimede sünkroonimisel. |
| getName () | See tagastab lõime nime. |
| setPriority (int newpriority) | See muudab lõime prioriteeti. |
| saagikus () | See põhjustab praeguse lõime peatamise ja muude lõimede käivitamise. |
Näide: Selles näites loome lõime ja uurime lõimede jaoks saadaolevaid sisseehitatud meetodeid.
paketi demotest;public class thread_example1 rakendab Runnable {@Üleavalik void run () {}public staatiline void main (String [] args) {Teema guruthread1 = uus lõime ();guruthread1.start ();proovige {guruthread1.sleep (1000);} saak (InterruptedException e) {// TODO Automaatselt loodud püüdeplokke.printStackTrace ();}guruthread1.setPriority (1);int gurupriority = guruthread1.getPriority ();System.out.println (gurupriority);System.out.println ("lõime jooksmine");}}
Koodi selgitus:
- Koodirida 2: Loome klassi "thread_Example1", mis juurutab liidese Runnable (selle peaks juurutama iga klass, kelle eksemplarid on mõeldud lõime käivitamiseks.)
- Koodirida 4: see alistab käivitatava liidese käitamismeetodi, kuna selle meetodi tühistamine on kohustuslik
- Koodirida 6: Siin oleme määratlenud peamise meetodi, mille abil alustame lõime käivitamist.
- Koodirida 7: Siin loome uue lõimenime "guruthread1", kiirendades uue lõimeklassi.
- Koodirida 8: me kasutame lõime algusmeetodit, kasutades eksemplari "guruthread1". Siin hakatakse lõime täitma.
- Koodirida 10: siin kasutame lõime "unerežiimi" meetodit, kasutades eksemplari "guruthread1". Seega magab niit 1000 millisekundit.
- Kood 9-14: Siin oleme unemeetodi proovinud proovida blokeerimisega, kuna on olemas erand, mis toimub, st katkestatud erand.
- Koodirida 15: Siin määrame lõime prioriteediks 1 olenevalt sellest, kumb see oli
- Koodirida 16: Siin saame lõime prioriteedi getPriority () abil
- Koodirida 17: siin trükime saidilt getPriority tõmmatud väärtuse
- Koodirida 18: Siin kirjutame teksti, mille lõime töötab.
Ülaltoodud koodi käivitamisel 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 lõime sünkroniseerimine
Mitme keermestamise korral on programmide asünkroonne käitumine. Kui üks lõim kirjutab andmeid ja teine niit, mis loeb andmeid samal ajal, võib see rakenduses ebajärjekindluse tekitada.
Kui jagatud ressurssidele on vaja juurde pääseda kahe või enama lõime kaudu, kasutatakse sünkroonimismeetodit.
Java on sünkroonitud käitumise rakendamiseks pakkunud sünkroniseeritud meetodeid.
Selle lähenemise korral, kui niit jõuab sünkroonitud 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 tuleb sellest välja.
Sel moel aitab sünkroonimine mitmelõimelises rakenduses. Üks lõime peab ootama, kuni teine lõim lõpetab selle täitmise, seejärel lubatakse ülejäänud lõimed käivitada.
Selle saab kirjutada järgmisel kujul:
Sünkroonitud (objekt){// Sünkroonitavate lausete plokk}
Java multithreading näide
Selles näites võtame kaks lõime ja toome lõime nimed.
Näide1:
GuruThread1.javapaketi demotest;avalik klass GuruThread1 rakendab Runnable {/ *** @param väidab* /public staatiline void main (String [] args) {Teema guruThread1 = uus lõime ("Guru1");Teema guruThread2 = uus lõime ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("lõimenimed on järgmised:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Üleavalik void run () {}}
Koodi selgitus:
- Koodirida 3: Oleme võtnud klassi "GuruThread1", mis rakendab Runnable'i (seda peaksid rakendama kõik klassid, kelle eksemplarid on mõeldud lõime käivitamiseks.)
- Koodirida 8: see on klassi peamine meetod
- Koodirida 9: Siin kiirendame klassi Thread ja loome eksemplari nimega "guruThread1" ning loome lõime.
- Koodirida 10: Siin kiirendame klassi Thread ja loome eksemplari nimega "guruThread2" ning loome lõime.
- Koodirida 11: alustame lõime st guruThread1.
- Koodirida 12: alustame lõime st guruThread2.
- Koodirida 13: teksti väljastamine järgmiselt: "lõimenimed 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.
Ülaltoodud koodi käivitamisel saate järgmise väljundi:
Väljund:
Siin on niidinimed välja antud kui
- Guru1
- Guru2
Näide 2:
Selles näites õpime käivitatava liidese meetodit run () ja start () ning loome sellest klassist kaks lõime ja käivitame vastavalt.
Lisaks käime kahes klassis,
- Üks, mis rakendab käivitatava liidese ja
- Teine meetod, millel on peamine meetod ja mida vastavalt sellele ka teostatakse.
paketi demotest;avalik klass GuruThread2 {public staatiline void main (String [] args) {// TODO Automaatselt loodud meetodi tüviGuruThread3 threadguru1 = uus GuruThread3 ("guru1");threadguru1.start ();GuruThread3 threadguru2 = uus GuruThread3 ("guru2");threadguru2.start ();}}klass GuruThread3 rakendab Runnable {Lõime guruthread;privaatne String guruname;GuruThread3 (stringi nimi) {guruname = nimi;}@Üleavalik void run () {System.out.println ("lõime töötab" + guruname);jaoks (int i = 0; i <4; i ++) {System.out.println (i);System.out.println (guruname);proovige {Niit.unne (1000);} saak (InterruptedException e) {System.out.println ("Teema on katkestatud");}}}avalik tühine algus () {System.out.println ("Teema algas");kui (guruthread == null) {guruthread = uus lõime (see, guruname);guruthread.start ();}}}
Koodi selgitus:
- Koodirida 2: Siin võtame klassi "GuruThread2", milles on peamine meetod.
- Koodirida 4: siin võtame klassi põhimeetodi.
- Koodirida 6-7: Siin loome klassi GuruThread3 (mis on loodud koodi allpool asuvatel ridadel) eksemplari nimega "threadguru1" ja alustame lõime.
- Koodirida 8-9: Siin loome veel ühe klassi GuruThread3 (mis on loodud koodi allpool asuvatel ridadel) eksemplari nimega "threadguru2" ja alustame lõime.
- Koodirida 11: Siin loome klassi "GuruThread3", mis rakendab käivitatavat liidest (seda peaksid rakendama kõik klassid, kelle eksemplarid on mõeldud lõime käivitamiseks.)
- Koodirida 13-14: võtame kaks klassimuutujat, millest üks on tüüpi lõimeklassi ja teine stringiklass.
- Koodirida 15-18: me tühistame GuruThread3 konstruktori, mis võtab stringi tüübiks ühe argumenti (mis on niidinimi), mis määratakse klassi muutujale guruname ja seega niidi nimi salvestatakse.
- Koodirida 20: Siin alistame käivitatava liidese run () meetodi.
- Koodirida 21: väljastame lõime nime println-lause abil.
- Koodirida 22-31: siin kasutame for-tsüklit, mille loendur on initsialiseeritud 0-ni, ja see ei tohiks olla väiksem kui 4 (võime võtta suvalise arvu, seega töötab siin silmus 4 korda) ja loendurit suurendades. Prindime lõime nime ja paneme lõime proovima püüdmise ploki ajal 1000 millisekundiks, kuna unemeetod tõi välja erandi.
- Koodirida 33: siin on käivitatava liidese algusmeetod ülimuslik.
- Koodirida 35: väljastame teksti "Teema algas".
- Koodirida 36-40: siin võtame tingimuse if, et kontrollida, kas klassi muutujal guruthread on väärtus või mitte. Kui selle väärtus on null, loome niidi klassi kasutades eksemplari, mis võtab nime parameetriks (väärtus, mille konstruktor määras). Pärast seda käivitatakse lõim algus () meetodil.
Ülaltoodud koodi käivitamisel saate järgmise väljundi:
Väljund :
Niisiis on kaks lõime, saame kaks korda teate "Teema algas".
Saame niidi nimed nii, nagu oleme need välja andnud.
See läheb silmusesse, kus me printime loenduri ja lõime nime ning loendur algab 0-ga.
Silmus käivitub kolm korda ja niidi vahel magatakse 1000 millisekundit.
Seega saame kõigepealt guru1, seejärel guru2, siis jälle guru2, kuna niit magab siin 1000 millisekundit ja seejärel järgmine guru1 ja jälle guru1, niit magab 1000 millisekundit, nii et saame guru2 ja seejärel guru1.
Kokkuvõte :
Selles õpetuses nägime Java-s mitmikeermelisi rakendusi ja seda, kuidas kasutada ühe- ja mitmemõimulisi.
- Mitmikeermelises kasutuses kasutajaid ei blokeerita, kuna lõimed on sõltumatud ja saavad korraga teha mitu toimingut
- Keerme olelusringi erinevad etapid on
- Uus
- Jooksev
- Jooksmine
- Ootan
- Surnud
- Õppisime ka lõimede sünkroniseerimist, mis aitab rakendusel tõrgeteta töötada.
- Mitme lõime abil on palju rohkem rakenduse ülesandeid lihtsam.