"Hi, Amigo!"
"Oo, nandito ako, nandito ako."
"Ngayon, sasabihin ko sa iyo ang tungkol sa paggamit ng naka-synchronize sa pagsasanay."
"Kapag ang isang programa ay may maraming mga bagay at mga thread, madalas na nangyayari na maraming mga thread ang gumagana sa parehong bagay nang sabay-sabay. Sa paggawa nito, ang mga thread ay nakakasagabal sa isa't isa."
"Oo, alam ko na ito."
"Kaya, sabihin nating mayroon kang isang bagay na ina-access ng maraming mga thread. Maaari kang gumawa ng dalawang bagay upang maiwasan ang mga problema."
"Ang una ay ang paggamit ng mga naka-synchronize na bloke upang balutin ang bawat lokasyon kung saan ina-access ang object. Ngunit maaaring hindi gumana ang diskarteng ito kung ang ilang programmer ay nagsusulat ng code na direktang nag-a-access sa object, nang walang naka-synchronize na block."
"Samakatuwid, ang pangalawang diskarte ay ginagamit halos lahat ng oras-ginagawa ang object thread-safe." "Sa madaling salita, ang naka-synchronize na mekanismo ay binuo sa mismong object: ipinapahayag nito ang mga pamamaraan nito na naka-synchronize at/o binabalot ang code sa loob ng mga pamamaraan nito sa mga naka-synchronize na bloke."
"Kaya anumang bagay na maaari kong gamitin mula sa maraming mga thread, at ito ay halos lahat ng mga bagay sa programa, kailangan kong gawing ligtas ang thread?"
"Sa pangkalahatan, oo. Sa katotohanan, hindi lahat ng mga bagay sa isang programa ay ginagamit ng iba't ibang mga thread, ngunit kadalasan ay marami. Kaya, kapag nagsimula kang magsulat ng code para sa isang thread at ma-access ang iba't ibang mga bagay mula dito, pagkatapos ay sa bawat tawag sa pamamaraan dapat mong tanungin ang iyong sarili, «Ligtas ba ang tawag na ito?»"
"Ligtas?"
"Thread-safe, na nangangahulugang maaari itong ligtas na tawagan mula sa maraming mga thread."
"Narito ang ilang mga halimbawa. Ipagpalagay na mayroon kang isang String object na na-access mula sa iba't ibang mga thread. Tulad ng dapat mo nang tandaan, ang String ay hindi nababago —gaya ng lahat ng iba pang mga primitive na uri. Nangangahulugan ito na ang isang bagay ay hindi nagbabago pagkatapos na ito ay nilikha . Nangangahulugan ito na imposibleng «masira» ang gayong bagay. Lahat ng hindi nababagong bagay ay ligtas sa sinulid."
"Well, ginagawang mas madali ang mga bagay."
"Ngayon, ipagpalagay na kailangan mo ng nababagong string."
"Oo, naalala ko. Mayroong dalawang uri ng gayong mga string: StringBuffer at StringBuilder. Ang StringBuffer ay parang StringBuilder, ngunit lahat ng mga pamamaraan nito ay naka-synchronize. Ito ba ay ligtas sa thread?"
"Oo. Kung kailangan mong i-access ang isang StringBuilder object mula sa maraming mga thread, dapat mong palitan ito ng isang StringBuffer. Kung hindi man, maaga o huli ay babaguhin ito ng mga thread sa parehong oras at «masira» ito."
"Paano kung ang bagay na ina-access mula sa iba't ibang mga thread ay isang bagay ng aking sariling klase? Kailangan ko bang magdagdag ng naka-synchronize sa mga pamamaraan nito sa kasong ito rin?"
"Oo. Pinakamainam na sundin ang panuntunang ito: ang lahat ng bagay na maa-access mula sa iba't ibang mga thread ay dapat na ligtas sa thread."
"I see. Hindi ko akalain na ganito pala kaseryoso ang lahat. Salamat, Ellie."
"You're welcome. Sana ay makatulong sa iyo ang mga tips na ito kapag binigyan ka ni Diego ng ilan sa mga madaling gawain niya. ☺"