Ang lahat ng mga nuances ng nakakaabala / humihinto sa mga thread

"Hi, Amigo!

"Lahat ng bago ay isang bagay lang na luma na nakalimutan na natin. Ngayon ay magsasalita ako tungkol sa paghinto ng mga thread. Sana ay nakalimutan mo na kung paano gumagana ang interrupt() method."

"Oo, Ellie, nakalimutan ko na."

"Great. Tapos ipapaalala ko sayo."

"Sa Java, kung gusto ng isang tao na ihinto ang tumatakbong thread, maaari niyang i-signal ito sa thread. Para magawa ito, kailangan mong itakda sa true ang hidden isInterrupted variable ng Thread object."

"Ang bawat Thread ay may interrupt() method, na ginagamit para itakda ang flag na ito. Kapag tinawag ang interrupt () method, ang isInterrupted variable sa loob ng Thread object ay nakatakda sa true."

"At kapag ang Thread.sleep() o join() na pamamaraan ay tinawag sa isang thread, ang pamamaraan ay nagsusuri kung ang isInterrupted na bandila ay nakatakda para sa kasalukuyang thread. Kung ang flag na ito ay nakatakda (ang variable na isInterrupted ay katumbas ng totoo), kung gayon ang mga pamamaraan magtapon ng InterruptedException ."

"Narito, ipapaalala ko sa iyo ang isang lumang halimbawa:"

class Clock implements Runnable
{
public void run()
{
Thread current = Thread.currentThread();

while (!current.isInterrupted())
{
Thread.sleep(1000);
System.out.println("Tik");
}
}
}

public static void main(String[] args)
{
Clock clock = new Clock();
Thread clockThread = new Thread(clock);
clockThread.start();

Thread.sleep(10000);
clockThread.interrupt();
}

"Dito ginagamit namin ang sleep method bilang bahagi ng isang infinite loop sa run method. Sa loop, ang isInterrupt variable ay awtomatikong sinusuri. Kung ang isang thread ay tumawag sa sleep method, ang paraan ay susuriin muna kung ang isInterrupt ay totoo para sa thread na iyon (ang isa na tinatawag na paraan ng pagtulog). Kung ito ay totoo, kung gayon ang pamamaraan ay hindi matutulog. Sa halip, ito ay nagtatapon ng isang InterruptedException ."

"Ngunit sa halimbawang ito, palagi naming sinusuri ang isInterrupted variable sa kondisyon ng loop."

"I remember there were some reasons why we could not use this approach. Can you remind me?"

" Una , ang run method ay hindi palaging may loop. Ang pamamaraan ay maaaring binubuo lamang ng ilang dosenang mga tawag sa iba pang mga pamamaraan. Sa kasong ito, kailangan mong magdagdag ng isInterrupted check bago ang bawat tawag sa pamamaraan."

" Pangalawa , ang ilang paraan na kinasasangkutan ng maraming iba't ibang mga aksyon ay maaaring tumagal ng napakatagal na panahon upang maisagawa."

" Pangatlo , hindi pinapalitan ng paghahagis ng exception ang isInterrupted check. Isa lang itong maginhawang karagdagan. Hinahayaan ka ng itinapon na exception na mabilis na i-unwind ang call stack pabalik sa run method mismo."

" Pang-apat , ang paraan ng pagtulog ay madalas na ginagamit. Lumalabas na ang kapaki-pakinabang na pamamaraang ito ay pinahusay ng isang implicit na pagsusuri na hindi gaanong nakakatulong.  Para bang walang partikular na nagdagdag ng tseke, ngunit nariyan ito.  Ito ay sobrang mahalaga kapag ikaw Gumagamit ka ng code ng ibang tao at hindi mo maidaragdag ang tseke sa iyong sarili."

" Ikalima , ang karagdagang pagsusuri ay hindi nagpapababa ng pagganap. Ang pagtawag sa paraan ng pagtulog ay nangangahulugan na ang thread ay hindi dapat gumagawa ng anuman (maliban sa pagtulog), kaya ang labis na trabaho ay hindi nakakaabala sa sinuman."

"Ganyan talaga ang sinabi mo kanina."

"At paano naman ang iyong pahayag, « Walang sinuman ang makakagarantiya na ang isang thread ay ititigil. Isang thread lamang ang makakapigil sa sarili nito. » Maaari mo bang ipaliwanag iyon?"

"Oo naman."

"Noon, sa mga unang bersyon ng Java, ang mga thread ay may stop() na pamamaraan. At kapag tinawag mo ito, ang JVM ay talagang huminto sa thread. Ngunit kung ang isang thread ay gumagawa ng isang bagay sa labas ng JVM (halimbawa, pagsulat sa isang file o pagtawag OS functions) kapag naantala ito sa ganitong paraan, ang pagkaantala ay nagdulot ng maraming problema, tulad ng mga hindi nakasarang file, hindi na-release na mapagkukunan ng system, atbp."

"Napagpasyahan ng isang pangkalahatang pagpupulong ng mga tagalikha ng Java na tanggalin ang paraan para sa puwersahang paghinto ng mga thread. Ngayon ang magagawa na lang natin ay magtakda ng isang partikular na flag (isInterrupted) at umaasa na ang thread code ay naisulat nang tama, upang ang flag na ito ay maproseso. Ang flag na ito ay parang sign na nagsasabing, 'Thread, stop, please. It's very important!'. Pero kung titigil man ito o hindi ay sarili niyang negosyo."

"Ngunit paano ang InterruptedException?"

"Paano kung ang code na tumatakbo sa thread na ito ay may isang grupo ng mga bloke ng try-catch? Kahit na mangyari ang isang InterruptedException sa isang lugar, tiyak na walang garantiya na ang ilang try-catch ay hindi mahuhuli at makakalimutan ito. Kaya walang mga garantiya na ang titigil ang thread."

"Ang isa pang bagay ay ang mga thread ay itinuturing na medyo mababang antas ng programming. Ngunit sasabihin ko sa iyo ang tungkol sa susunod na pagkakataon."

"Hindi ikaw si Ellie—ikaw si Scheherazade!"

"So, Amigo! Malinaw ba ang lahat sa kasalukuyang aralin?"

"Oo."

"Mabuti."