Ang call stack at catching error

"Hi, Amigo!

"Gusto kong sabihin sa iyo ang tungkol sa isang bagay na maliit, ngunit kawili-wili."

"Nakikinig ako. Mahilig ako sa mga bagay na maliliit at kawili-wili."

"Well, alam mo na ang bawat Thread object ay may run() method. At na maaari mong i-execute ito sa isang hiwalay na thread gamit ang start() method."

"Oo naman."

"Ngunit ngayon isipin ang sitwasyong ito: magsisimula ka ng isang thread upang magsagawa ng ilang trabaho, ngunit ang isang pagbubukod ay itinapon at ang thread ay tumigil sa pagtakbo dahil hindi nito alam kung ano ang gagawin. Hindi ba kailangan mong malaman ang tungkol sa error na ito kahit papaano?"

"Sumasang-ayon ako. Kailangan kong kahit papaano ay mahuli ang pagbubukod na naganap sa kabilang tumatakbong thread. Sinusuportahan ba iyon ng Java?"

"Iniinsulto mo ako. Syempre."

"Ang mga tagalikha ng Java ay nag-imbento ng isang espesyal na interface na tinatawag na UncaughtExceptionHandler. Narito kung paano mahuli at mahawakan ang isang pagbubukod na nangyayari sa isa pang thread, kung ang thread na iyon ay hindi nahuli:"

public class DownloadManager
{
 public static void main(String[] args)
 {
   Thread thread = new DownloadThread();
   thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler()
   {
    @Override
    public void uncaughtException(Thread t, Throwable e)
    {

    }
 });

 thread.start();
}

"Ang Thread object ay may espesyal na setUncaughtExceptionHandler method. Kailangan mong ipasa ito sa isang object na nagpapatupad ng Thread.UncaughtExceptionHandler interface. Ang interface na ito ay may isang paraan lamang: uncaughtException(Thread t, Throwable e) . Ito ang paraan na tatawagin ang naipasa na bagay kung ang isang hindi nahuli na pagbubukod ay nangyayari sa paraan ng pagtakbo."

"Sa aking halimbawa sa itaas, nagdedeklara lang ako ng anonymous na inner class (na naka-highlight sa pula) na nagpapatupad ng Thread. Thread.UncaughtExceptionHandler interface. At na-override ko ang uncaughtException(Thread t, Throwable e) na paraan nito."

"Tulad ng nakikita mo mula sa listahan ng parameter ng pamamaraan, dalawang argumento ang ipapasa: isang reference sa Thread object kung saan nangyari ang exception, at ang exception mismo, na ipinasa bilang Throwable e."

"Well, bakit ko kailangan ang Thread variable t? Hindi ba natin alam kung saang Thread tayo naglalagay ng Thread.UncaughtExceptionHandler object?"

"Ginawa nila ito upang maaari kang magsulat ng isang unibersal na tagapangasiwa para sa mga sitwasyong ito. ibig sabihin, maaari kang lumikha ng isang solong bagay at ipasa ito sa dose-dosenang iba't ibang mga thread. Pagkatapos ang paraan ng uncaughtException(Thread t, Throwable e) ay palaging nagbibigay sa iyo ng reference sa Thread object kung saan nangyari ang exception."

"Higit pa rito, maaari kang lumikha ng dose-dosenang mga thread, halimbawa, sa isang loop upang magsagawa ng mga partikular na gawain. Sa pangkalahatan, ang reference na ito sa Thread object ay hindi magiging kalabisan. Ipinapangako ko sa iyo iyon."

"Naniniwala ako sayo. Hindi ka nagkamali."