Mahalagang Pagkakaiba – tulog kumpara sa paghihintay sa Java
Ang Sleep and wait ay dalawang paraan na ginagamit para sa multithreading sa Java. Ang sleep method ay kabilang sa Thread class habang ang wait method ay mula sa Object class. Ang pangunahing pagkakaiba sa pagitan ng pagtulog at paghihintay sa Java ay iyon, ang pagtulog ay ginagamit upang suspindihin ang pagpapatupad ng kasalukuyang thread para sa tinukoy na bilang ng mga millisecond habang ang paraan ng paghihintay ay ginagamit upang maging sanhi ng kasalukuyang thread na maghintay hanggang sa isa pang thread ay humihiling ng abiso o ipaalam ang lahat ng paraan para sa bagay.
Ang isang thread ay ang pinakamaliit na yunit ng pagproseso sa operating system. Ito ay isang solong sunud-sunod na daloy ng kontrol sa loob ng isang programa. Ang mga thread ay magaan. Ang multithreading ay ang mekanismo ng pagpapatakbo ng maramihang mga thread sa parehong oras. Ang mga programming language tulad ng Java ay sumusuporta sa multithreading. Ang multithreading ay may mga pakinabang dahil pinapayagan nitong magpatakbo ng maramihang mga thread nang sabay-sabay at ang mga thread ay independyente sa bawat isa. Mayroong mga pamamaraan sa Java na maaaring magamit para sa multithreading. Dalawa sa kanila ay natutulog at naghihintay.
Ano ang sleep sa Java?
May maraming prosesong tumatakbo sa isang operating system. Ang proseso ay isang programa sa pagpapatupad. Ang bawat proseso ay maaaring magkaroon ng maraming mga thread, at mayroong isang paglipat ng konteksto na nagaganap sa pagitan ng mga thread na ito. Sa Java, mayroong dalawang paraan upang lumikha ng isang thread. Iyon ay sa pamamagitan ng pagpapalawak ng thread class o sa pamamagitan ng pagpapatupad ng Runnable interface. Ang klase ng Thread ay may mga konstruktor at pamamaraan upang lumikha at magsagawa ng mga operasyon sa isang thread. Ang Thread class ay nagpapalawak ng Object class at nagpapatupad ng Runnable interface. Ang Runnable na interface ay dapat ipatupad ng anumang klase na ang mga pagkakataon ay nilayon na isagawa ng isang thread. Kapag nag-execute ang thread, ang code na dapat i-execute ay nakasulat sa loob ng run method. Ang thread na dapat tumakbo ay pinili ng thread scheduler. Isang thread lang ang tumatakbo sa iisang proseso.
Ang isang thread ay dumaraan sa ilang yugto. Pagkatapos gumawa ng object ng Thread class, maaaring gamitin ng programmer ang paraan ng pagsisimula. Bago gamitin ang pamamaraang iyon, sinasabing ang thread ay nasa bagong estado. Ang thread scheduler ay pumipili ng thread na tatakbo. Kung ang thread ay hindi pa napili ng thread scheduler ngunit kung ang paraan ng pagsisimula ay ginagamit, ang thread ay nasa isang runnable na estado. Pagkatapos piliin ng scheduler ng thread ang thread na ipapatupad, lilipat ito sa tumatakbong estado. Kung ang thread ay buhay ngunit kasalukuyang hindi karapat-dapat na tumakbo, kung gayon ito ay nasa non-runnable o naka-block na estado. Matapos makumpleto ang paraan ng pagtakbo, ang thread ay pupunta sa tinapos na estado. Iyan ang mga pangunahing yugto ng ikot ng buhay ng thread.
May iba't ibang paraan na available sa klase ng thread para magsagawa ng iba't ibang gawain. Ang paraan ng pagtulog ay ginagamit upang matulog ang pamamaraan para sa isang tiyak na tagal ng oras. Ang syntax para sa paraan ng pagtulog ay public void sleep (mahabang milliseconds) throws InterruptedException. Nagiging sanhi ito ng kasalukuyang gumaganang thread upang pansamantalang ihinto ang pagpapatupad para sa isang tinukoy na bilang ng mga millisecond. Kung ang isa pang thread ay nakakaabala sa kasalukuyang thread, ang naantala na status ng kasalukuyang thread ay iki-clear kapag ang exception na ito ay itinapon.
Figure 01: Java Program with sleep Method
Ayon sa programa sa itaas, ang run method ay naglalaman ng code na dapat isagawa. Sa pangunahing programa, ang dalawang bagay ng ExampleThread1 ay nilikha, at ang mga pamamaraan ng pagsisimula ay ginagamit sa kanila. Iyon ay magpapahintulot na patakbuhin ang code sa loob ng paraan ng pagtakbo. Isang thread lang ang naisasagawa sa isang pagkakataon. Gamit ang Thread.pagtulog (1000); ay magbibigay-daan sa unang thread na wakasan ang execution para sa 1000 milliseconds. Kapag natutulog ang isang thread, kukunin ng thread scheduler ang kabilang thread.
Ano ang paghihintay sa Java?
Maaaring ma-access ng maraming thread ang isang nakabahaging mapagkukunan. Maaari itong maging sanhi upang makabuo ng hindi tamang output. Maaaring gamitin ang pag-synchronize ng thread upang gumawa lamang ng isang thread upang ma-access ang nakabahaging mapagkukunan. Ipagpalagay ang isang sitwasyon tulad ng sumusunod. Kung, mayroong dalawang thread bilang t1 at t2, magsisimula ang t1 na mag-save ng mga value sa isang text file na tinatawag na Text1.txt. Gagamitin ang mga halagang iyon para sa ilang iba pang kalkulasyon kapag bumalik ang t1. Kung magsisimula ang t2 bago bumalik ang t1, maaaring baguhin ng t2 ang mga halagang na-save ng t1. Maaari itong maging sanhi ng t1 na magbigay ng maling output. Sa tulong ng pag-synchronize, kapag nagsimula ang t1 gamit ang Text1.txt file, maaaring i-lock ang file na iyon, kaya maa-access lamang ito ng t1. Hindi ito mababago ng t2 hanggang sa ilabas ng t1 ang lock para ma-access ang text file na iyon. Kapag nakumpleto na ang gawain, maaaring ilabas ng t1 ang lock. Ang lock ay kilala rin bilang monitor.
Ang pag-synchronize ng thread ay maaaring makamit sa pamamagitan ng inter-thread na komunikasyon. Ang kritikal na seksyon ay isang code segment na nag-a-access sa mga nakabahaging mapagkukunan. Sa inter-thread na komunikasyon, ang isang thread ay naka-pause na tumatakbo sa kritikal na seksyon nito, at isa pang thread ang pinapayagang pumasok sa parehong kritikal na seksyon na isasagawa. Ito ay ipinatupad gamit ang wait, notify at notifyAll na mga pamamaraan. Nabibilang sila sa klase ng Object. Ang paraan ng paghihintay ay ginagamit upang payagan ang kasalukuyang thread na bitawan ang lock at maghintay hanggang sa isa pang thread ang mag-invoke ng notify o notifyAll na paraan para sa object. Ang paraan ng pag-abiso ay ginagamit upang gisingin ang isang thread na naghihintay para sa lock. Gigisingin ng notifyAll ang lahat ng mga thread na naghihintay sa lock.
Figure 02: Calculator Class
Figure 03: Pangunahing Paraan
Pinahaba ng klase ng Calculator ang Thread. Ang naka-synchronize na block ay nasa loob ng run method. Ang paraang para sa loop at abiso ay nasa loob ng naka-synchronize na bloke. Sa loob ng pangunahing pamamaraan, ang isang halimbawa ng isang thread na nilikha at ang paraan ng pagsisimula ay tinatawag sa pagkakataong iyon. Maghihintay ang pangunahing paraan hanggang sa magbigay ng abiso ang thread. Kapag isinasagawa ang programa, ang pangunahing pamamaraan ay naghihintay hanggang sa buong pagpapatupad ng paraan ng pagtakbo at naghihintay para sa paraan ng pag-abiso. Kapag tinawag na ang paraan ng pag-abiso, ang pangunahing pamamaraan ay huminto sa paghihintay at magsisimulang isagawa ang natitirang bahagi ng code. Naghihintay ang Main hanggang sa makumpleto ang thread ng Calculator. Sa wakas, ang resulta ng kabuuan ay naka-print.
Kung walang naka-synchronize na block at kung ang pangunahing paraan ay may code tulad ng nasa ibaba, ibibigay nito ang output bilang zero dahil hindi nito hinihintay na makumpleto ang kabilang thread.
Calculator t1=bagong Calculator ();
t1. simulan ();
System.out.println (t1.sum);
Ano ang Pagkakatulad sa pagitan ng pagtulog at paghihintay sa Java?
Ang parehong pagtulog at paghihintay ay mga paraan na magagamit kapag nagpapatupad ng multithreading sa Java
Ano ang Pagkakaiba sa pagitan ng pagtulog at paghihintay sa Java?
sleep vs wait in Java |
|
| Ang paraan ng pagtulog ay nagsasanhi sa kasalukuyang thread na suspindihin ang pagpapatupad para sa tinukoy na bilang ng mga millisecond, napapailalim sa katumpakan at katumpakan ng mga system timer at scheduler. | Ang paraan ng paghihintay ay nagsasanhi sa kasalukuyang thread na maghintay hanggang sa isa pang thread ang mag-invoke ng notify o notifyAll na paraan para sa object. |
| Pagsasama sa Lock | |
| Ang paraan ng pagtulog ay hindi naglalabas ng lock sa isang bagay habang nagsi-synchronize. | Ang paraan ng paghihintay ay naglalabas ng lock habang nagsi-synchronize. |
| Paraan ng Pagpapatupad | |
| Ang paraan ng pagtulog ay isinasagawa sa kasalukuyang thread. | Ang paraan ng paghihintay ay tinatawag sa object. |
| Nauugnay na Klase | |
| Ang sleep ay isang paraan ng Thread class. | Ang paghihintay ay isang paraan ng Object class. |
| Pagkumpleto | |
| Ang proseso ng pagtulog ay nakumpleto pagkatapos ng tinukoy na tagal ng oras. | Naaantala ang paraan ng paghihintay sa pamamagitan ng pagtawag sa notify o notifyAll method. |
Buod – sleep vs wait sa Java
May maraming prosesong tumatakbo sa operating system. Ang bawat proseso ay maaaring magkaroon ng maramihang mga thread. Ang thread ay ang pinakamaliit na yunit ng pagproseso sa isang operating system. Sinusuportahan ng Java programing language ang multithreading. Pinapayagan nito ang pagpapatakbo ng maraming mga thread nang sabay-sabay. Ang pagtulog at paghihintay ay dalawang paraan na maaaring gamitin kapag nagpapatupad ng multi-threading. Ang pagkakaiba sa pagitan ng pagtulog at paghihintay sa Java ay, ang pagtulog ay ginagamit upang suspindihin ang pagpapatupad ng kasalukuyang thread para sa tinukoy na bilang ng mga millisecond habang ang paraan ng paghihintay ay ginagamit upang maging sanhi ng kasalukuyang thread na maghintay hanggang sa isa pang thread ay mag-invoke ng notify o notifyAll paraan para sa bagay.
