Ikot ng buhay ng thread at mga estado ng thread

"Hi, Amigo!"

"Magsisimula tayo ng bagong paksa: mga thread."

"Magsimula tayo. Ngayon ay susuriin natin ang mga estado na dinadaanan (o maaaring madaanan) ng isang Thread object kapag tumatakbo ang isang thread."

"Ilang estado ang maaari mong pangalanan ngayon, Amigo?"

"Dalawa. Ang una ay isang thread bago ang start() method ay tinatawag: ang object ay umiiral, ngunit ang thread ay hindi pa aktibo. At ang pangalawa ay pagkatapos na ang start() method ay tinatawag na: kapag ang thread ay gumagawa ng isang bagay mahalaga."

"Tama ka—may pagkakaiba. Ang mga estadong ito ay tinatawag na bago at tumatakbo , ngunit iyon ay simula pa lamang."

"Una, sa ilang mga punto ang thread ay matatapos sa pagtakbo, na nangangahulugan na maaaring may isang sitwasyon kung saan ang Thread object ay umiiral, ngunit ang thread ay wala sa bago o tumatakbo na estado. "Ang estado na ito, kung saan ang thread ay tapos nang tumakbo, ay tinatawag na tinapos na ."

"Ngunit may higit pa. Huwag kalimutan na sa anumang oras ay isang thread lang ang aktwal na tumatakbo. Ang lumilitaw na sabay-sabay na trabaho ay talagang ang processor ay patuloy na tumatalon mula sa thread patungo sa thread. Mayroong isang hiwalay na estado kung kailan ang thread ay tila tumatakbo, ngunit talagang naghihintay para sa kanyang turn: ito ay tinatawag na ready-to-run . Habang gumagana ang isang thread, patuloy itong lumilipat mula sa pagtakbo patungo sa ready , at pagkatapos ay bumalik sa pagtakbo kapag naging aktibo muli."

"Kaagad pagkatapos na tawagin ang start () na paraan, ang thread ay itinalaga ang ready-to-run na status at inilalagay sa isang nakabahaging listahan ng mga thread na pinaglilipatan ng JVM."

"Hindi iyon masyadong mahirap. Bago ito magsimulang tumakbo, mayroon itong bagong estado. Pagkatapos nito, ito ay natapos . Kapag ito ay tumatakbo, ang thread ay nasa tumatakbong estado; pagkatapos ay kapag naghihintay, ito ay nasa handa na estado . ."

"Nakakamangha ang ikli mo, pero tama ka."

"Ngunit marami pa. Maaaring ma-block ang thread. Halimbawa, kapag nagpasok ka ng isang naka-synchronize na bloke. Kung ang isang thread ay nakarating sa isang bloke ng code na minarkahan bilang naka-synchronize at ginagamit ito ng isa pang thread, kung gayon ang aming thread ay papasok sa naka-block na estado at maghihintay para mailabas ang mutex (lock) ng bagay."

"Narito ang hitsura ng sitwasyong ito sa mga estado:"

"Ngunit marami pa. Mayroon ding hiwalay na estado na tinatawag na waiting . Ito ay kapag ang isang thread ay hindi naka-block , ngunit hindi rin handa . Halimbawa, kapag tinawag mo ang join () method sa isa pang thread."

Kapag tinawag natin ang join() sa isa pang bagay sa Thread, para bang ang ating thread ay «sinasali» dito, ngunit sa katotohanan ay naghihintay lang ito para matapos ang kabilang thread.

"Bukod pa rito, mayroon ding wait () method (mula sa wait/notify/notifyAll trio of methods), na nagpapalit ng thread sa waiting state kapag tinawag ito."

"Whoa."

"Sandali lang! Mayroon pa. Ang isang thread ay maaaring matulog sa pamamagitan ng pagtawag sa sleep method, halimbawa. Mayroon ding isang hiwalay na estado para dito. Ito ay tinatawag na « timed waiting ». « timed waiting » ay nangangahulugan na ang thread ay naghihintay para sa isang bagay para sa isang limitadong oras. Kung tatawag ka ng paraan ng paghihintay na may parameter, gaya ng wait(timeout) o join(timeout), pagkatapos ay papasok ang thread sa timed-waiting state."

"Narito ang buong diagram:"

"Hmm. Yun lang ba? O may 10 pang interesting states?"

"Sa ngayon, yun lang."

"Sa practice, maaalala mo lang yung unang diagram. Mas simple. Pero mas tumpak yung pangalawa."

"Kakaibang sapat, mayroong maraming mga diagram ng estado ng Thread sa Internet, at lahat sila ay naiiba."

"Iyon ang dahilan kung bakit ibinigay ko sa iyo ang diagram na ito—ito ang pinakakumpleto at tama."

"Sa diagram na ito, ang handa at tumatakbong estado ay pinagsama sa isang bloke na tinatawag na runnable. Alam mo ba kung bakit?"

"Hindi. First time kong makakita ng ganyan."

"Ang klase ng Thread ay may panloob na klase na tinatawag na State , pati na rin ang isang pampublikong State getState() na pamamaraan."

public enum State
{
 NEW,
 RUNNABLE,
 BLOCKED,
 WAITING,
 TIMED_WAITING,
 TERMINATED;
}

"Maaari mong palaging tawagan ang getState () method sa isang Thread object, at alamin ang kasalukuyang estado nito. At, siyempre, isa ito sa mga value ng State enum."

"Nakikita ko. Kaya, ang mga totoong estado ay nasa loob ng JVM, ngunit mayroon ding mga estado na maaari mong ma-access sa pamamagitan ng Java code gamit ang paraan ng State getState()."

"At sa ilalim ng anong mga pagkakataon gagamitin ko iyon?"

"Malamang, hindi kailanman."

"Ngunit kailangan mong malaman kung ano ang nangyayari sa loob ng mga thread. Kung hindi, magkakaroon ka ng maraming mga bug, at hindi mo na rin mahulaan kung ano ang sanhi ng mga ito."

"Dagdag pa, ang mga tagapag-empleyo ay gustong magtanong tungkol sa mga estado ng Thread sa panahon ng mga panayam."